DynExpManager.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include <QtWidgets/QMainWindow>
#include "DynExpAbout.h"
#include "DynExpCore.h"
#include "CircuitDiagram.h"
#include "ErrorListDialog.h"
 
namespace Ui
{
    class DynExpManagerClass;
}
 
class DynExpManager : public QMainWindow
{
    Q_OBJECT
 
public:
    struct ItemTreeItemDataType
    {
        enum class ItemTreeItemStateType { New, Normal, Running, Paused, Warning, Error, NotConnected, NotResponding };
 
        constexpr ItemTreeItemDataType() noexcept : ItemTreeItemState(ItemTreeItemStateType::New), ID(0) {}
        constexpr ItemTreeItemDataType(const DynExp::ItemIDType ID,
            const ItemTreeItemStateType ItemTreeItemState = ItemTreeItemStateType::New) noexcept
            : ItemTreeItemState(ItemTreeItemState), ID(ID) {}
 
        ItemTreeItemStateType ItemTreeItemState;    
        const DynExp::ItemIDType ID;                
    };
 
    DynExpManager(DynExp::DynExpCore& DynExpCore, QWidget *parent = Q_NULLPTR);
 
    ~DynExpManager();
 
private:
    static std::string GetObjectNameSafe(DynExp::Object* Object);
 
    template <typename LibraryVectorT>
    void RegisterItemsFromLibrary(const LibraryVectorT& Lib, QMenu* const MenuBase,
        const QString IconPath, void(DynExpManager::*Slot)());
 
    template <typename LibraryVectorT, typename ManagerT>
    void MakeItem(QAction* SenderAction, LibraryVectorT& Lib, ManagerT& ResourceManager);
 
    template <typename LibraryVectorT, typename ManagerT>
    bool UpdateItemConfig(DynExp::Object* Object, LibraryVectorT& Lib, ManagerT& ResourceManager);
 
    void EnsureItemReadyState(DynExp::Object* Object);
    
    void ResetItem(DynExp::Object* Object);
 
    void UpdateLog();
    void ResetLogColors();
    void UpdateModulesUI() noexcept;
    void UpdateTitleBar();
    void UpdateStatusBar();
    void UpdateCircuitDiagram();
    void UpdateItemTree();
    void UpdateItemTreeItem(const DynExp::HardwareAdapterManager::ResourceType& Resource);
    void UpdateItemTreeItem(const DynExp::InstrumentManager::ResourceType& Resource);
    void UpdateItemTreeItem(const DynExp::ModuleManager::ResourceType& Resource);
 
 
    template <typename ManagerT>
    QTreeWidgetItem* UpdateItemTreeSection(QTreeWidgetItem* Section, ManagerT& ResourceManager);
 
    void UpdateItemTreeItemObjectName(QTreeWidgetItem* Item, const DynExp::Object* Object);
 
    void SelectItemTreeItem(QTreeWidgetItem* SelectedEntry);
 
    void ChangeItemTreeItemToNormalState(QTreeWidgetItem& ItemTreeItem, const ItemTreeItemDataType& ItemTreeItemData,
        const QString& Description, const QString& StateTitle, const char* IconPath = DynExpUI::Icons::Stopped);
    void ChangeItemTreeItemToRunningState(QTreeWidgetItem& ItemTreeItem, const ItemTreeItemDataType& ItemTreeItemData,
        const QString& Description);
    void ChangeItemTreeItemToPausedState(QTreeWidgetItem& ItemTreeItem, const ItemTreeItemDataType& ItemTreeItemData,
        const QString& Description);
    void ChangeItemTreeItemToWarningState(QTreeWidgetItem& ItemTreeItem, const ItemTreeItemDataType& ItemTreeItemData,
        const QString& Description);
    void ChangeItemTreeItemToErrorState(QTreeWidgetItem& ItemTreeItem, const ItemTreeItemDataType& ItemTreeItemData,
        const std::exception_ptr& ExceptionPtr);
    void ChangeItemTreeItemToNotConnectedState(QTreeWidgetItem& ItemTreeItem, const ItemTreeItemDataType& ItemTreeItemData,
        const QString& Description);
    void ChangeItemTreeItemToNotRespondingState(QTreeWidgetItem& ItemTreeItem, const ItemTreeItemDataType& ItemTreeItemData,
        const QString& Description);
 
    QColor HTMLColorStringToThemeColor(const std::string& HTMLColor) const;
 
    QColor AdjustColorToThemeColor(const QColor& Color) const;
 
    void Reset(bool Force = false);
 
    bool CloseProject() noexcept;
 
    bool Shutdown() noexcept;
 
    void SaveProject(std::string_view Filename) noexcept;
 
    void DisableAllActions() noexcept;
 
    void UpdateModuleWindowsActionShortcuts() noexcept;
 
    void UpdateModuleWindowsActionIcons() noexcept;
 
    DynExp::QModuleBase* GetModuleByActiveUIWindow() noexcept;
 
    virtual void closeEvent(QCloseEvent* event) override;
 
    DynExp::DynExpCore& DynExpCore;                     
 
    std::unique_ptr<Ui::DynExpManagerClass> ui;         
 
    QTimer* UpdateUITimer;                              
    DynExpAbout* AboutDialog;                           
 
    std::unique_ptr<CircuitDiagram> CircuitDiagramDlg;
 
    ErrorListDialog* ErrorListDlg;                      
    QActionGroup* ModuleWindowsActionGroup;             
    QActionGroup* UIThemeActionGroup;                   
    QAction* UIBrightThemeAction;                       
    QAction* UIDarkThemeAction;                         
    QMenu* LogContextMenu;                              
    QMenu* ItemTreeContextMenu;                         
    QAction* ClearWarningAction;                        
    QTreeWidgetItem* ItemTreeHardwareAdapters;          
    QTreeWidgetItem* ItemTreeInstruments;               
    QTreeWidgetItem* ItemTreeModules;                   
 
    struct StatusBarType
    {
        StatusBarType(DynExpManager* Owner);
 
        size_t NumItemsInWarningState;
        size_t NumItemsInErrorState;
 
        QPushButton* State;
        QWidget* NumRunningInstrGroup;
        QHBoxLayout* NumRunningInstrLayout;
        QLabel* NumRunningInstrImage;
        QLabel* NumRunningInstr;
        QWidget* NumRunningModuleGroup;
        QHBoxLayout* NumRunningModuleLayout;
        QLabel* NumRunningModuleImage;
        QLabel* NumRunningModule;
    } StatusBar;
 
    ErrorListDialog::ErrorEntriesType ErrorEntries;
 
    bool IsResetting;
 
    bool ShouldRedrawCircuitDiagram;
    
    bool ShouldUpdateCircuitDiagram;
 
public:
    void RegisterModuleUI(DynExp::Object* const Object);
    
    bool StopItem(DynExp::RunnableObject* Object, bool Force = false) noexcept;
    
    void FocusMainWindow() noexcept;
 
    void PostKeyPressEvent(QKeyEvent* Event) noexcept;
    
    std::string GetDataSaveDirectory() const { return DynExpCore.GetDataSaveDirectory(); }
 
    void SetDataSaveDirectory(std::string_view Directory) const { return DynExpCore.SetDataSaveDirectory(Directory); }
 
private slots:
    void OnUpdateUI();
    void OnUIThemeChanged(QAction* ThemeAction);
    void OnNewProject();
    void OnOpenProject();
    void OnSaveProject();
    void OnSaveProjectAs();
    void OnRunProject();
    void OnStopProject();
    void OnResetFailedItems();
    void OnRestoreWindowStatesFromParams();
    void OnProjectSettingsClicked();
    void OnRunItem();
    void OnStopItem(bool Force = false);
    void OnForceStopItem();
    void OnResetItem();
    void OnConfigureItem();
    void OnDeleteItem();
    void OnWindowMenuOpened();
    void OnWindowMenuClosed();
    void OnDockUndockWindow();
    void OnShowCircuitDiagram();
    void OnAboutClicked();
    void OnStatusBarStateClicked();
    void OnLogContextMenuRequested(const QPoint& Position);
    void OnItemTreeContextMenuRequested(const QPoint& Position);
    void OnClearLog();
    void OnClearWarning();
    void OnAddHardwareAdapter();
    void OnAddInstrument();
    void OnAddModule();
    void OnItemSelectionChanged();
    void OnItemDoubleClicked(QTreeWidgetItem* Item, int Column);
    void OnModuleWindowActivated(QMdiSubWindow* Window);
};
 
Q_DECLARE_METATYPE(DynExpManager::ItemTreeItemDataType);
 
template <typename LibraryVectorT>
void DynExpManager::RegisterItemsFromLibrary(const LibraryVectorT& Lib, QMenu* const MenuBase,
    const QString IconPath, void(DynExpManager::*Slot)())
{
    std::string LastCategoryString("");
    QMenu* CurrentCategoryMenu = nullptr;
 
    for (size_t i = 0; i < Lib.size(); ++i)
    {
        const auto& LibEntry = Lib[i];
 
        std::string CategoryString(LibEntry.Category);
        QMenu* MenuToAdd = CategoryString.empty() ? MenuBase : CurrentCategoryMenu;
 
        if (!CategoryString.empty() && CategoryString != LastCategoryString)
        {
            // ...because one & only makes the next letter a shortcut (see QAction and QMenu)
            CurrentCategoryMenu = MenuBase->addMenu(QString::fromStdString(CategoryString).replace("&", "&&"));
            LastCategoryString = CategoryString;
            MenuToAdd = CurrentCategoryMenu;
        }
 
        auto AddedAction = MenuToAdd->addAction(QIcon(IconPath),
            QString::fromStdString(LibEntry.Name).replace("&", "&&"), this, Slot);
        AddedAction->setData(QVariant::fromValue(i));
    }
}
 
template <typename LibraryVectorT, typename ManagerT>
void DynExpManager::MakeItem(QAction* SenderAction, LibraryVectorT& Lib, ManagerT& ResourceManager)
{
    if (!SenderAction)
    {
        Util::EventLog().Log("SenderAction cannot be nullptr.",
            Util::ErrorType::Error, Util::DynExpErrorCodes::InvalidArg);
        return;
    }
 
    auto Variant = SenderAction->data();
    if (!Variant.canConvert<size_t>())
    {
        Util::EventLog().Log("No library entry has been assigned to this item.",
            Util::ErrorType::Error, Util::DynExpErrorCodes::TypeError);
        return;
    }
 
    const auto& LibEntry = Lib[Variant.value<size_t>()];
 
    const std::string ObjectType = DynExp::Object::CategoryAndNameToStr(LibEntry.Category, LibEntry.Name);
    std::string ObjectName = "";
    std::string ErrorMessage = "";
 
    DynExp::ItemIDType NewItemID = DynExp::ItemIDNotSet;
    try
    {
        auto Params = LibEntry.ConfigFactoryPtr()->MakeConfigFromDialog(ResourceManager.GetNextID(), DynExpCore, this);
        if (!Params)    // e.g. cancelled by user
            return;
 
        ObjectName = Params->ObjectName;
 
        NewItemID = DynExpCore.MakeItem(LibEntry, std::move(Params));
    }
    catch (const Util::EmptyException& e)
    {
        ErrorMessage = e.what();
    }
    catch (const Util::Exception& e)
    {
        Util::EventLog().Log(e);
        ErrorMessage = e.what();
    }
    catch (const std::exception& e)
    {
        ErrorMessage = e.what();
    }
    catch (...)
    {
        ErrorMessage = "Unknown Error";
    }
 
    if (!ErrorMessage.empty())
    {
        QMessageBox::warning(this, "DynExp - Error",
            QString::fromStdString(
                "Creating item " + (ObjectName.empty() ? "< Unnamed >" : ObjectName) +
                + " (" + ObjectType + "), the following error occurred:\n\n"
                + ErrorMessage
            ));
    }
 
    if (NewItemID != DynExp::ItemIDNotSet)
    {
        const auto Object = ResourceManager.GetResource(NewItemID);
 
        EnsureItemReadyState(Object);
        RegisterModuleUI(Object);
    }
}
 
template <typename LibraryVectorT, typename ManagerT>
bool DynExpManager::UpdateItemConfig(DynExp::Object* Object, LibraryVectorT& Lib, ManagerT& ResourceManager)
{
    if (!Object)
        throw Util::InvalidArgException("Object cannot be nullptr.");
    
    auto LibEntry = DynExp::FindInLibraryVector(Lib, Object->GetCategory(), Object->GetName());
    auto ResultState = LibEntry.ConfigFactoryPtr()->UpdateConfigFromDialog(Object, DynExpCore, this);
 
    if (ResultState.IsAccepted())
        ResourceManager.DeleteTreeWidgetItem(Object->GetID());
 
    return ResultState.IsResetRequired();
}
 
template <typename ManagerT>
QTreeWidgetItem* DynExpManager::UpdateItemTreeSection(QTreeWidgetItem* Section, ManagerT& ResourceManager)
{
    QTreeWidgetItem* LastAdded = nullptr;
 
    for (auto Resource = ResourceManager.cbegin(); Resource != ResourceManager.cend(); ++Resource)
    {
        if (!Resource->second.TreeWidgetItem)
        {
            auto CategoryAndName = QString::fromStdString(Resource->second.ResourcePointer->GetCategoryAndName());
            auto ID = Resource->second.ResourcePointer->GetID();
 
            Resource->second.TreeWidgetItem = std::make_unique<QTreeWidgetItem>(Section,
                QStringList{ "", CategoryAndName, "" });
            UpdateItemTreeItemObjectName(Resource->second.TreeWidgetItem.get(), Resource->second.ResourcePointer.get());
            Resource->second.TreeWidgetItem->setToolTip(1, CategoryAndName);
            Resource->second.TreeWidgetItem->setData(1, Qt::ItemDataRole::UserRole, QVariant::fromValue(Resource->second.TreeWidgetItem.get()));
            Resource->second.TreeWidgetItem->setData(2, Qt::ItemDataRole::UserRole, QVariant::fromValue(ItemTreeItemDataType(ID)));
 
            // Show and sort by item name.
            Section->setExpanded(true);
            Section->sortChildren(0, Qt::SortOrder::AscendingOrder);
 
            LastAdded = Resource->second.TreeWidgetItem.get();
 
            ShouldRedrawCircuitDiagram = true;
        }
        else if (Resource->second.TreeWidgetItem->data(0, Qt::ItemDataRole::UserRole).template value<bool>())
        {
            UpdateItemTreeItemObjectName(Resource->second.TreeWidgetItem.get(), Resource->second.ResourcePointer.get());
 
            ShouldRedrawCircuitDiagram = true;
        }
 
        UpdateItemTreeItem(Resource->second);
    }
 
    return LastAdded;
}