CPanelLogicsEditor.hpp

Go to the documentation of this file.

#ifndef LIBS_PANELS_CPANELLOGICSEDITOR_HPP_
#define LIBS_PANELS_CPANELLOGICSEDITOR_HPP_
 
#include "logic/CLogicsAllowed.hpp"
#include "logic/LogicsGenerationParams.hpp"
#include "logic/enums.hpp"
#include "logic/types.hpp"
#include "ui/gui/AbstractCanvasItem.hpp"
#include "ui/gui/CButton.hpp"
#include "ui/gui/CComboBox.hpp"
#include "ui/gui/CLogicsDrawingAreaModel.hpp"
#include "ui/gui/CPaned.hpp"
#include "ui/panels/editor/logic/CPanelLogicsDrawingArea.hpp"
#include "ui/panels/editor/logic/CPanelLogicsSearchTagsAndLabels.hpp"
#include "ui/panels/editor/logic/CPanelsLogicsLibraries.hpp"
#include "ui/panels/editor/main/AbstractViewPanelEditor.hpp"
#include "ui/shapes/CDrawLogicsElements.hpp"
#include "units/model/enums.hpp"
 
#include <cstdint>
#include <map>
#include <memory>
#include <set>
 
class CPanelLogicsEditor : public AbstractViewPanelEditor
{
public:
    static inline const int32_t kMinimumWidthToolBox = 200;
    static uint32_t getIDTypeLOMInDataBase(iv::units::eUnitType unitType);
    static std::optional<iv::units::eUnitType> getLomTypeFromIdTypeInDataBase(uint32_t idLomType);
    static bool hasLogicLibrary(iv::units::eUnitType unitType);
 
    explicit CPanelLogicsEditor(bool isLibrary);
    ~CPanelLogicsEditor() override;
    CPanelLogicsEditor() = delete;
    CPanelLogicsEditor(const CPanelLogicsEditor &other) = delete;
    CPanelLogicsEditor(CPanelLogicsEditor &&other) = delete;
    CPanelLogicsEditor &operator=(const CPanelLogicsEditor &other) = delete;
    CPanelLogicsEditor &operator=(CPanelLogicsEditor &&other) = delete;
 
    bool loadLibrary(const std::string &libraryFile, std::string &libraryName, std::string &resultMsg);
    bool addLibrary(iv::types::logic::customBlockId idLibrary, const std::string &name, const std::string &file);
    bool addLibrary(const std::string &name);
    void changeToolBox();
    void rebuildToolBox();
    bool cloneLibrary(const std::string &name);
    bool renameLibrary(const std::string &name);
 
    [[nodiscard]] CLogicsAllowed::TMapDBBlockParamNStr
    getLibraryParametersDesc(iv::types::logic::customBlockId libraryId) const;
    [[nodiscard]] CLogicsAllowed::TMapDBBlockParamNStr
    getLibraryExternalParametersValues(iv::types::logic::customBlockId libraryId) const;
    [[nodiscard]] LogicLibraryInfo getLibraryInfo(iv::types::logic::customBlockId libraryId,
                                                  const CLogicsAllowed::TMapDBBlockParamNStr &mapBlockParamsDesc) const;
 
    [[nodiscard]] std::optional<iv::units::eUnitType> getActiveLomType() const;
    [[nodiscard]] iv::types::logic::customBlockId getFirstFreeIdLibrary();
    [[nodiscard]] std::string
    getLibraryName(std::optional<iv::types::logic::customBlockId> libraryId = std::nullopt) const;
    [[nodiscard]] std::string
    getLibraryFileName(std::optional<iv::types::logic::customBlockId> libraryId = std::nullopt) const;
    [[nodiscard]] iv::types::logic::customBlockId getLibraryId(const std::string &libraryName) const;
 
    static AbstractComponentGUI *panelEditLibraryName(std::string *libraryName, bool requiresChangeName = false);
 
    AbstractComponentGUI *buildPanel(CDialog *dialogFather) override;
    void logicProcessLibLoad();
    void update() override;
    bool isLibrary() const;
 
    void setActiveLibraryById(std::optional<iv::types::unitId> idLibrary);
    void setActiveLogicId(std::optional<iv::types::unitId> logicId);
    void setActiveUnitId(std::optional<iv::types::unitId> logicId);    //Para lógicas, trabaja con unidades
    void setActiveLOMType(std::optional<iv::units::eUnitType> lomType);//Para librerías, trabaja con librerías
    void setFunctionalBarSelectedLogicId(std::optional<iv::types::unitId> logicId) const;
    void setFunctionalBarSelectedLOM(std::optional<iv::types::unitId> lomId) const;
    void setSearchTagsAndLabelsRepeatFlag(bool changed);
 
    static bool updateVariableOnlineLibraryTagName(std::optional<iv::types::unitId> logicId,
                                                   const iv::types::logic::libraryTagName &oldTagLibraryBlock,
                                                   const iv::types::logic::libraryTagName &newTagLibraryBlock);
 
    static bool addVariableOnline(std::optional<iv::types::unitId> logicUnitId,
                                  const iv::types::logic::libraryTagName &libraryTagName,
                                  const iv::types::logic::parameterOnlineTag &tag);
    static bool updateVariableOnlineTag(std::optional<iv::types::unitId> logicUnitId,
                                        const iv::types::logic::libraryTagName &libraryTagName,
                                        const iv::types::logic::parameterOnlineTag &oldTag,
                                        const iv::types::logic::parameterOnlineTag &newTag);
    static bool updateLibraryVariablesOnlinesValues(std::optional<iv::types::unitId> logicUnitId,
                                                    const iv::types::logic::libraryTagName &libraryTagName);
    static bool removeVariableOnline(std::optional<iv::types::unitId> logicUnitId,
                                     const iv::types::logic::libraryTagName &libraryTagName,
                                     const iv::types::logic::parameterOnlineTag &tag);
 
    [[nodiscard]] bool getSearchTagsAndLabelsRepeatFlag() const;
 
    void resetToolBoxSelection();
 
    [[nodiscard]] CPanelLogicsDrawingArea *getActiveDrawingArea();
    [[nodiscard]] std::shared_ptr<CLogicsDrawingAreaModel> getActiveDrawingAreaModel() const;
    void grabFocusCanvas(std::optional<iv::types::unitId> logicId);
 
    void runContextMenuAction(CLogicsDrawingAreaModel::EActionOnLogicsComponent action);
    void runDoubleClickAction(const CDrawLogicsElements::TTupleElementType &elementType);
    void setElementIdForCurrentContextMenu(AbstractCanvasItem::TId id);
    void setPointClickedForCurrentContextMenu(iv::math::geometry::Point2d pointClicked);
    void showContextMenu(EContextMenu contextMenuType);
 
    [[nodiscard]] std::optional<iv::types::unitId> getActiveLogicId() const;
    [[nodiscard]] const iv::types::logic::ComponentType &getSelectedComponentType() const;
    [[nodiscard]] iv::logic::eGeneralType getSelectedComponentGeneralType() const;
    [[nodiscard]] iv::types::logic::componentType getSelectedComponentTType() const;
    [[nodiscard]] iv::types::logic::componentFinalType getSelectedComponentTFinalType() const;
 
    [[nodiscard]] bool isSelectedLCALeaf() const;
 
    void updateCurrentLibraryFilePath(const std::string &file) const;
    bool deleteCurrentLibrary();
    bool saveFileActiveLibrary(const std::string &fileName, std::string &resultMsg) const;
 
    void generateLogicsGenerationParams(const iv::logic::LogicGenerationParams &generationParams);
 
private:
    void setAllowedLogics(const CLogicsAllowed &allowedLogics);
    CLogicsAllowed *getAllowedLogics();
 
    // TODO: crear clase CPanelLogicsFunctionalBar aparte si crecen los métodos
    struct SPrvLogicsFunctionalBar
    {
        CComboBox *m_comboBoxSelectedLogicIdRef {nullptr};//se utiliza para las unidades y para las librerías
        AbstractComponentGUI *m_panelInfoLogic {nullptr};
        AbstractComponentGUI *m_panelChangeLogicOrder {nullptr};
        AbstractComponentGUI *m_panelLibraryButtons {nullptr};
        AbstractComponentGUI *m_panelCopyLogic {nullptr};
 
        AbstractComponentGUI *m_panelChangeLibraryIOOrder {nullptr};
        CButton *m_buttonChangeLibraryInputOrder {nullptr};
        CButton *m_buttonChangeLibraryOutputOrder {nullptr};
 
        CPanelLogicsSearchTagsAndLabels *m_panelSearch {nullptr};
        CButton *m_buttonAddLibrary {nullptr};
        CButton *m_buttonLoadLibrary {nullptr};
        CButton *m_buttonDeleteLibrary {nullptr};
        CButton *m_buttonCloneLibrary {nullptr};
        //CButton *m_buttonRenameLibrary;
        CButton *m_buttonSaveLibrary {nullptr};
        CComboBox *m_cmbSelectedLOM {nullptr};
    };
 
    struct SPrvDrawingArea
    {
        SPrvDrawingArea(const std::weak_ptr<CLogicsDrawingAreaModel> &drawingAreaModel,
                        CPanelLogicsEditor *panelLogicsEditor)
        {
            m_panelDrawingArea = std::make_unique<CPanelLogicsDrawingArea>(drawingAreaModel, panelLogicsEditor);
            m_componentBuiltRef = nullptr;
            m_isPaned = false;
        }
        SPrvDrawingArea() = delete;
        ~SPrvDrawingArea()
        {
            // delete drawing area panels that are not inside CPaned widget (the ones inside will be deleted with CPaned destructor)
            if (not m_isPaned && m_componentBuiltRef != nullptr)
            {
                delete m_componentBuiltRef;
                m_componentBuiltRef = nullptr;
            }
        }
 
        SPrvDrawingArea(const SPrvDrawingArea &other) = delete;
        SPrvDrawingArea(SPrvDrawingArea &&other) = delete;
        SPrvDrawingArea &operator=(const SPrvDrawingArea &other) = delete;
        SPrvDrawingArea &operator=(SPrvDrawingArea &&other) = delete;
 
        void setPaned(bool isPaned)
        {
            m_isPaned = isPaned;
        }
 
        std::unique_ptr<CPanelLogicsDrawingArea> m_panelDrawingArea;
        AbstractComponentGUI *m_componentBuiltRef;
        bool m_isPaned;// flag indicating whether the drawing area is shown in the CPaned widget or not
    };
 
    bool prvAddLibrary(uint16_t idLibrary, const std::string &name, const std::string &file);
 
    AbstractComponentGUI *prvBuildFunctionalLayout();
    AbstractComponentGUI *prvPanelInfoLogic();
    AbstractComponentGUI *prvPanelSortLibraryIOButtons();
    AbstractComponentGUI *prvPanelLibraryButtons();
    AbstractComponentGUI *prvPanelChangeLogicOrder();
    AbstractComponentGUI *prvPanelCopyLogic();
 
    void prvDeleteLogicsOfDeletedUnits();
    void prvDeleteLibrariesOfDeletedLibraries();
    void prvComboBoxLogicIdAddNoSelected() const;
    void prvPopulateAllLibrariesComboBox();
    void prvPopulateAllUnitsComboBox();
    void prvPopulateAllModulesComboBox();
    void prvUpdateLogicComboBoxModules();
    void prvUpdateLogicComboBoxLibraries();
    void prvUpdateLogicComboBoxUnits();
    void prvUpdateLogicsElements();
 
    AbstractComponentGUI *prvBuildToolBox();
    AbstractComponentGUI *prvBuildToolBox(uint32_t typeLOM);
    AbstractComponentGUI *prvBuildDrawingArea(std::optional<iv::types::unitId> logicId);
    AbstractComponentGUI *prvBuildDrawingAreaLibrary(std::optional<iv::types::unitId> logicId);
    AbstractComponentGUI *prvBuildPanedLayout();
 
    void prvBuildContextMenus();
    void prvBuildContextMenuBackground();
    void prvBuildContextMenuLogicText();
    void prvBuildContextMenuLogicRectangle();
    void prvBuildContextMenuBasicBlock();
    void prvBuildContextMenuChannel();
    void prvBuildContextMenuConnection();
    void prvBuildContextMenuConst();
    void prvBuildContextMenuBroadCastChannel();
    void prvBuildContextMenuLabel();
    void prvBuildContextMenuLibraryIOBlock();
    void prvBuildContextMenuLibrary();
 
    void prvBuildDoubleClickAction();
 
    CLogicsAllowed &m_logicsAllowed;
 
    iv::types::logic::customBlockId m_firstFreeIdLibrary;
    std::optional<iv::types::unitId> m_activeLogicId;
    std::optional<iv::units::eUnitType> m_activeLomType;
    SPrvLogicsFunctionalBar m_functionalBar;
    bool m_searchTagsAndLabelsRepeatFlag;
 
    SLogicsToolBox *m_toolBox;
 
    bool m_isLibrary;
 
    std::map<uint16_t, std::unique_ptr<SPrvDrawingArea>> m_drawingAreas;
    std::unique_ptr<SPrvDrawingArea> m_startingEmptyDrawingArea;
 
    CPaned *m_panedRef;// horizontal paned windows containing the toolbox and the drawing area
 
    std::map<EContextMenu, std::unique_ptr<CMenuContext>> m_contextMenus;
    AbstractCanvasItem::TId m_elementIdForCurrentContextMenu;// current element id for which to show a context menu
    std::optional<iv::math::geometry::Point2d> m_pointForCurrentContextMenu;// point clicked
 
    std::map<CDrawLogicsElements::TTupleElementType, CLogicsDrawingAreaModel::EActionOnLogicsComponent>
            m_doubleClickActions;
 
    std::string m_libraryNameToSelectOpt;
 
    void filterAllowedLogicsByLomType(CLogicsAllowed *allowedLogics, std::optional<iv::units::eUnitType> lomType);
};
 
#endif /* LIBS_PANELS_CPANELLOGICSEDITOR_HPP_ */