DtElementEditorLogic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2023 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once

#include <vrvCore/DtElementDefinitionManager.h>
#include <vrvCore/DtVisualizerDefinition.h>

#include <vrvCoreQt/vrvCoreQt.h>
#include <vrvCoreQt/DtPersistenceControlsInterface.h>
#include <vrvCoreQt/DtDefinitionPersistenceWidget.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtUnicode.h>
#include <vrvUtil/DtVirtualBaseClass.h>

namespace makVrv
{
   class DtElementDefinitionManager;
   class DtElementEditorInterface;
   class DtVisualizerAttributeEditorInterface;
   class DtVisualizerAttribute;
   class DtPage;
   class DtUnicode;
   class DtVisualizerDefinition;

   class DT_DLL_VRVCOREQT DtElementEditorLogic : public DtVirtualBaseClass
   {
   public:

      DtElementEditorLogic(DtElementDefinitionTypeManager::ElementDefinitionType type,
         DtDe& de, DtElementEditorInterface* iface, DtPersistenceControlsInterface* persistenceControls,
         DtPage* page = 0);

      virtual ~DtElementEditorLogic();

      DtElementEditorLogic() = delete;

      DtElementEditorLogic(const DtElementEditorLogic &copy) = delete;

      DtElementEditorLogic& operator=(const DtElementEditorLogic&) = delete;

   public:
      virtual void selectElement(const DtUnicode& elementName, bool valid);

      virtual void setElementRemoveAllowed(const DtUnicode& elementName);

      virtual void checkIfModified();

   protected:

      virtual void selectVisualizerDefinition(const std::string& uuidString);
      virtual void selectAttribute(int index, const std::string& uuidString, const std::string& attrName);

      // TDL not sure what this is the index of...
      virtual void deselectAttribute(int index, const std::string& attrName);

      virtual void refreshElementDefinitions();

      virtual void refreshVisualizerDefinitionView();

      virtual void clearElementSelection();

      virtual void setupModifiedEntitiesDialog();

      virtual void runThroughChildren(DtElementDefinition* elem, std::map<std::string, std::string>& names);

      virtual void addVisualizerDefinition();

      virtual void removeVisualizerDefinition(const std::string& uuidString);

      // TDL This doesn't appear to be possible in the current element editor widget
      virtual void deselectVisualizerDefinition();

      virtual void addElement(const DtUnicode& name);

      virtual void removeElement();

      // TDL Currently unused as renaming elements has a bunch of issues (including the fact
      // that entity type mappings point to elements by name, as do child nodes to their parents)
      virtual void renameElement(const DtUnicode& oldName, const DtUnicode& newName);

      virtual void addAttributeRequested(int index, const std::string& uuidString);

      virtual void removeAttribute(const std::string& uuidString, const std::string& name);

      virtual void removeLocalAttribute(const std::string& uuidString, const std::string& name);

      virtual void changeAttribute(const DtUnicode& origin, int index, const std::string& uuidString, const std::string& name);

      virtual void cancelAttributeChange(int defIndex, const std::string& name);

      // Determine if a visualizer definition is inherited
      virtual bool visualizerDefinitionInherited(DtElementDefinition*, DtVisualizerDefinition*) const;

      virtual void refreshModelSets();

      virtual void refreshFileSaveTo();

      void changeFileLocation();

      virtual void reloadFile(const std::string& filePath);

      virtual void updateAttributeEditorInterface(int index, const std::string& uuidString, const std::string& name,
         DtVisualizerAttributeEditorInterface* iface);

      virtual void changeModelSet(int index);

      virtual void changeFileSaveTo(int index);

      virtual void changeFileFilter();

      virtual void on_import();

      virtual void on_restoreFactory();

      virtual void on_restoreStartup();

      virtual void on_saveAll();

      virtual void on_saveAllHier();

      virtual void on_saveAllLeaves();

      virtual void on_exportSelectedNode();

      virtual void on_reloadFiles();

      virtual void on_merge();

      virtual void on_exportSelected();

      virtual void on_importFilePathChosen(const std::string& filePath);

      virtual void on_exportFilePathChosen(const std::string& filePath);

      virtual void on_leafFilePathChosen(const std::string& filePath);

      virtual void on_mergeFilePathChosen(const std::string& filePath);

      virtual void on_exportSelectedFilePathChosen(const std::string& filePath);

      virtual void on_exportSelectedNodeFilePathChosen(const std::string& filePath);

      virtual void on_saveDefaults();

      virtual void on_copyVisualizerDefinition();

      virtual void on_pasteAndReplaceVisualizerDefinition();

      virtual void on_pasteAndAddVisualizerDefinition();

      virtual void on_clearVisualizerDefinitions();

      virtual bool shouldDisableSave();

      virtual void mapTypeToDirectoryPath(DtElementDefinitionTypeManager::ElementDefinitionType type);

      virtual void slot_managerAboutToBeDeleted();

      virtual void slot_currentStyleSheetsPathAboutToBeChanged();

      virtual void slot_postCurrentStyleSheetsPathChanged();

      virtual DtElementDefinitionManager& elementDefinitionManager();

   protected:

      DtUnicode mySelectedElement;
      DtModelSetId mySelectedModelSet;
      unsigned int mySelectedFileSaveTo;

      DtPage* myPage;

      DtDe& myDe;
      DtSignalConnectionManager myConnections;
      DtSignalConnectionManager myManagerConnections;
      DtElementDefinitionManager* myManager;
      int myManagerType;
      DtElementEditorInterface* myInterface;
      DtPersistenceControlsInterface* myPersistenceControls;
      std::string myDirectoryPath;
      std::string myPathofSelectedModel;
      std::vector<std::string> myNewList;
      std::vector<std::string> myVisualList;
      DtVisualizerDefinition* myCopiedVisualizerDefinition;
      std::vector<DtVisualizerDefinition*> myCopiedVisDefs;
      std::vector<std::string> myListOfCopiedVisDefs;
      bool myAdjustDropDown;
      std::string mySelectedVisualizerUuid;
      DtVisualizerAttribute* myEditAttribute;

   };

   class DT_DLL_VRVCOREQT DtElementEditorLogicCreator : public DtVirtualBaseClass
   {
   public:
      DtElementEditorLogicCreator(DtDe& de);

      virtual ~DtElementEditorLogicCreator();

      static DtElementEditorLogicCreator& instance(DtDe&);

      static void registerInstance(DtDe&, DtElementEditorLogicCreator*);

      virtual DtElementEditorLogic* create(DtElementDefinitionTypeManager::ElementDefinitionType type,
         DtElementEditorInterface* iface, DtPersistenceControlsInterface* persistenceControls,
         DtPage* page = 0);

   protected:
      DtDe& myDe;
   };
}