DtTerrainEditorWidget.h

Go to the documentation of this file.

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


#pragma once

#include <vrvTerrainEditor/vrvTerrainEditor.h>
#include <QtWidgets/QWidget>
#include <vrvTerrainEditor/DtTerrainEditorInterface.h>
#include <vrvTerrainEditor/DtTerrainEditorPropertyTreeWidgetItem.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvOsgEarth/DtOsgEarthPropertyItemKey.h>

// Class Forward Declarations
class QHBoxLayout;
class QVBoxLayout;
class QGridLayout;
class QTreeWidget;
class QTabWidget;
class QPushButton;
class QToolButton;
class QMenu;
class QTreeWidgetItem;

namespace makVrv
{
   class DtTerrainEditorPropertyTreeWidgetItem;
   class DtTerrainEditorRuntimePropertyWidgetItem;
   class DtOsgEarthAddTerrainLayerWidget;
   class DtOsgEarthAddModelLayerWidget;
   class DtOsgEarthCacheDialog;
   class DtOsgEarthGenerateBoundaryWidget;

   class DT_DLL_VRVTERRAINEDITOR DtTerrainEditorWidget : public QWidget,
      public DtTerrainEditorInterface
   {
      Q_OBJECT

   public:
      friend class DtTerrainEditorWidgetCreator;

      enum TerrainContentItemDataRole
      {
         ItemDataType = Qt::UserRole,
         ItemDataId,
         ItemDataName,
         ItemDataParentType,
         ItemDataParentId,
         ItemDataDisplayName
      };

      enum OsgEarthFragmentItemDataRole
      {
         ItemDataUrl = Qt::UserRole
      };

      enum TreeWidgetType
      {
         TerrainContent,
         TerrainFragment,
         TerrainProperty,
         UnknownTree
      };

      typedef std::map<TerrainContentItemKey, QTreeWidgetItem*> TerrainContentTreeWidgetItemsMap;

      typedef std::map<TerrainContentItemKey, DtTerrainEditorPropertyTreeWidgetItem*> TerrainPropertyTreeWidgetItemsMap;

      typedef std::map<TerrainContentItemKey, DtTerrainEditorRuntimePropertyWidgetItem*> TerrainRuntimeTreeWidgetItemsMap;

      typedef std::map<std::string, QTreeWidgetItem*> OsgEarthFragmentContentItemsMap;

      virtual ~DtTerrainEditorWidget();

      virtual void initialize();

      virtual bool isInitialized();

      virtual void cleanup();


      virtual void addTerrainContentTopLevelItem(const TerrainContentItemKey& key, const std::string& displayName);

      virtual void addTerrainContentItem(const TerrainContentItemKey& key, const TerrainContentItemKey& parentKey, const std::string& displayName, int index = -1, bool editable = false,
         bool checked = true);

      virtual void addOsgEarthFragmentContentTopLevelItem(const std::string& key, const std::string& displayName);

      virtual void addOsgEarthFragmentContentItem(const std::string& key, const std::string& parentKey, const std::string& displayName);

      virtual void clearTreeWidgets();

      virtual void cleanOsgEarthFragmentTreeWidget();

      virtual void setSelectedOsgEarthFragmentKeys(const std::vector<TerrainContentItemKey>& keys);

      virtual void setStyleSheetForTopPanelButtons();

      virtual void setFocusOnTerrainContentTreeWidgetItem(const TerrainContentItemKey& key, bool expanded = true);

      virtual void removeTerrainContentTreeWidgetItem(const TerrainContentItemKey& key);

      virtual bool hasTerrainContentTreeWidgetItem(const TerrainContentItemKey& key);

      virtual bool hasTerrainPropertyTreeWidgetItem(const TerrainContentItemKey& key);

      virtual void resizeTerrainPropertyTreeWidget();

      virtual void resizeTerrainRuntimeTreeWidget();

      virtual void resizeTerrainFragmentTreeWidget();

      virtual void moveTerrainContentTreeWidgetItem( TerrainContentItemKey key, bool up);

      virtual void setGenerateCacheButtonEnabled(bool enabled);

      virtual void setGenerateBoundaryButtonEnabled(bool enabled);

      virtual void setSaveTerrainButtonEnabled(bool enabled);

      virtual void setCommitChangeButtonEnabled(bool enabled);

      virtual void setRevertChangeButtonEnabled(bool enabled);

      virtual void enableOsgEarthFragmentTabWidget(bool enabled);

      virtual void enableTerrainRuntimeTabWidget(bool enabled);

      virtual void showTerrainPropertyTreeWidgetItem(const TerrainContentItemKey& key);

      virtual void showTerrainPropertyTreeWidgetItems(const std::vector<TerrainContentItemKey>& key);

      virtual void showTerrainRuntimeTreeWidgetItem(const TerrainContentItemKey& key);

      int getIndexOfTerrainContentItem(const TerrainContentItemKey& key);

      //| Methods used to set/get the property in the terrain property tree widget

      virtual void setOsgEarthTerrainProperty(const TerrainContentItemKey& key, const osgEarth::MapOptions& mapOptions,
         const osgEarth::MapNodeOptions& mapNodeOptions, const osgEarth::TerrainOptions& terrainOptions);

      virtual void getOsgEarthTerrainProperty(const TerrainContentItemKey& key, osgEarth::MapOptions& mapOptions,
         osgEarth::MapNodeOptions& mapNodeOptions, osgEarth::TerrainOptions& terrainOptions);

      virtual void setTerrainPatchProperty(const TerrainContentItemKey& key, const makArchives::DtModelDefinitionRecord& rec);

      virtual void getTerrainPatchProperty(const TerrainContentItemKey& key, makArchives::DtModelDefinitionRecord& rec);

      virtual void setFeatureLayerProperty(const TerrainContentItemKey& key, const makArchives::DtFeatureLayerRecord& rec);

      virtual void getFeatureLayerProperty(const TerrainContentItemKey& key, makArchives::DtFeatureLayerRecord& rec);

      virtual void setOceanLayerProperty(const TerrainContentItemKey& key, const makArchives::DtOceanLayerRecord& ref);

      virtual void getOceanLayerProperty(const TerrainContentItemKey& key, makArchives::DtOceanLayerRecord& rec);

      void setImageLayerProperty(const TerrainContentItemKey& key, const osgEarth::ImageLayerOptions& options);

      virtual void getImageLayerProperty(const TerrainContentItemKey& key, osgEarth::ImageLayerOptions& options);

      void setElevationLayerProperty(const TerrainContentItemKey& key, const osgEarth::ElevationLayerOptions& options);

      virtual void getElevationLayerProperty(const TerrainContentItemKey& key, osgEarth::ElevationLayerOptions& options);

      void setModelLayerProperty(const TerrainContentItemKey& key, const osgEarth::ModelLayerOptions& options);

      virtual void getModelLayerProperty(const TerrainContentItemKey& key, osgEarth::ModelLayerOptions& options);

      void setMaskLayerProperty(const TerrainContentItemKey& key, const osgEarth::MaskLayerOptions& options);

      virtual void setBuildingLayerProperty(const TerrainContentItemKey& key, const osgEarth::Buildings::BuildingLayerOptions& options);

      virtual void setLandCoverLayerProperty(const TerrainContentItemKey& key, const osgEarth::LandCoverLayerOptions& options);

      virtual void setGroundCoverLayerProperty(const TerrainContentItemKey& key, const osgEarth::Splat::GroundCoverLayerOptions& options);

      virtual void setGroundCoverProperty(const TerrainContentItemKey& key, const osgEarth::Splat::GroundCoverOptions& options);

      virtual void setRoadSurfaceLayerProperty(const TerrainContentItemKey& key, const osgEarth::Splat::RoadSurfaceLayerOptions& options);

      virtual void setSplatLayerProperty(const TerrainContentItemKey& key, const osgEarth::Splat::SplatLayerOptions& options);



      virtual void showCacheDialog(const std::string& osgEarthTerrainDefinition);

      virtual DtUnicode showSaveMtfFileDialog(const DtUnicode& directory);

      virtual DtUnicode showSaveOsgEarthFileDialog(const DtUnicode& directory);

      virtual void showSaveFileConfirmationMessageBox(const DtUnicode& fileName);

      virtual bool showOverrideOsgEarthFileDialog();

      virtual bool showWarnReloadTerrainMessageBox(bool& checked);

      virtual bool showReloadTerrainAfterGenerateMaskMessageBox(const std::string& terrainPatch);

      virtual bool showChooseLayerTypeMessageBox(const DtUnicode& url, int& type);

      virtual void showFileExtensionNotSupportedMessageBox(const DtUnicode& fileName);

      virtual void setGenerateBoundaryModels(const std::vector<std::string>& models);

      virtual void setTerrainPropertyTreeItemName(const std::string& name);

      virtual void setTerrainPropertyTreeItemVisiblity(bool visible);

      virtual void expandTerrainContentTreeWidget();

      virtual void expandOsgEarthFragmentTreeWidget();

      //| Methods used to set the runtime property of the terrain content item(Does not require commiting changes).

      virtual void setOceanLayerHeight(const TerrainContentItemKey& key, double height);

      virtual void setOceanLayerLod(const TerrainContentItemKey& key, int lod);

      virtual void setLayerVisiblity(const TerrainContentItemKey& key, bool visible);

      virtual void setLayerOpacity(const TerrainContentItemKey& key, double opacity);

      virtual void setLayerMinVisibleRange(const TerrainContentItemKey& key, double range);

      virtual void setLayerMaxVisibleRange(const TerrainContentItemKey& key, double range);

      virtual void setGroundCoverWind(const TerrainContentItemKey& key, double wind);

      virtual void setGroundCoverFill(const TerrainContentItemKey& key, double fill);

      virtual void setGroundCoverMaxDistance(const TerrainContentItemKey& key, double maxDistance);


   protected:

      DtTerrainEditorWidget(DtDe& de, QWidget* parent);

      void setupGui();

      virtual void connectSignals();

      virtual void connectRuntimeWidgetSignals(const TerrainContentItemKey& key);

      virtual void addTerrainPropertyTreeWidgetItem(const TerrainContentItemKey& key, DtTerrainEditorPropertyTreeWidgetItem* item);

      virtual void addTerrainRuntimeTreeWidgetItem(const TerrainContentItemKey& key, DtTerrainEditorRuntimePropertyWidgetItem* item);

      virtual QTreeWidgetItem* getTerrainContentItem(const TerrainContentItemKey& key);

      virtual void setTerrainContentItemAttributes(QTreeWidgetItem* item, const TerrainContentItemKey& key, const std::string& displayName, bool checked = true);

      virtual void removeTerrainContentTreeWidgetItem(QTreeWidgetItem* item);

      virtual void removeTerrainContentTreeWidgetItemFromMap(QTreeWidgetItem* item);

      virtual void setItemExpandedOrCollapsed(QTreeWidget* tree, QTreeWidgetItem* item, bool expanded);

      virtual void setItemCheckedOrUnchecked(QTreeWidget* tree, QTreeWidgetItem* item, bool checkedOrUnchecked);

      int getTerrainContentItemType(QTreeWidgetItem* item);

      int getTerrainContentItemId(QTreeWidgetItem* item);

      std::string getTerrainContentItemName(QTreeWidgetItem* item);

      std::string getTerrainContentItemDisplayName(QTreeWidgetItem* item);

      int getTerrainContentItemParentType(QTreeWidgetItem* item);

      int getTerrainContentItemParentId(QTreeWidgetItem* item);

      TerrainContentItemKey getTerrainContentItemKey(QTreeWidgetItem* item);

      virtual DtTerrainEditorPropertyTreeWidgetItem* getTerrainEditorPropertyTreeWidgetItem(const TerrainContentItemKey& key);

      virtual DtTerrainEditorPropertyTreeWidgetItem* createTerrainEditorPropertyTreeWidgetItem(const TerrainContentItemKey& key);

      virtual std::string getTerrainEditorPropertyTreeWidgetItemCreatorName(TerrainContentItemType type);

      virtual DtTerrainEditorRuntimePropertyWidgetItem* getTerrainEditorRuntimePropertyWidgetItem(const TerrainContentItemKey& key);

      virtual DtTerrainEditorRuntimePropertyWidgetItem* createTerrainEditorRuntimePropertyWidgetItem(const TerrainContentItemKey& key);

      std::string getOsgEarthFragmentItemKey(QTreeWidgetItem* item);

      bool hasTerrainContentItem(const TerrainContentItemKey& key);

      virtual void populateTerrainContentTreeContextMenu(QContextMenuEvent* e);

      virtual void populateTerrainFragmentTreeContextMenu(QContextMenuEvent* e);

      virtual void populateTerrainPropertyTreeContextMenu(QContextMenuEvent* e);

      virtual void renameTerrainContentTreeWidgetItem();

      virtual void moveUpTerrainContentTreeWidgetItem();

      virtual void moveDownTerrainContentTreeWidgetItem();

      virtual void saveTerrainContentTreeWidgetItem();

      virtual void deleteTerrainContentTreeWidgetItem();

      virtual void hideAllTerrainContentTreeTopLevelItems();

      virtual void hideAllTerrainPropertyTreeTopLevelItems();

      virtual void showTerrainPropertyTreeTopLevelItem(DtTerrainEditorPropertyTreeWidgetItem* item);

      virtual void showTerrainPropertyTreeTopLevelItems(const std::vector<DtTerrainEditorPropertyTreeWidgetItem*>& items);

      virtual void showTerrainRuntimeTreeTopLevelItem(DtTerrainEditorRuntimePropertyWidgetItem* item);

      virtual bool isTerrainContentTabEnabled();

      virtual bool isTerrainPropertyTabEnabled();

      virtual bool checkIfNameDuplicate(QTreeWidgetItem* item, const std::string& name);

   protected:

      virtual void slot_osgEarthTerrainLayerRequestAdded(int type, const std::string& name, const std::string& driver, const DtUnicode& url);

      virtual void slot_osgEarthModelLayerDataRequestAdded(const std::string& name, const std::string& driver, const DtUnicode& url, const std::string& wfsType);

      virtual void slot_generateBoundary(const std::string& definition, const std::string& name, bool, bool);

      protected slots:

      virtual void on_terrainContentTreeWidget_currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);

      virtual void on_terrainContentTreeWidget_itemPressed(QTreeWidgetItem* item, int column);

      virtual void on_terrainContentTreeWidget_itemDoubleClicked(QTreeWidgetItem* item, int column);

      virtual void on_terrainContentTreeWidget_itemChanged(QTreeWidgetItem* item, int column);

      virtual void on_osgEarthFragmentTreeWidget_currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);

      virtual void on_terrainPropertyTreeWidget_currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);

      virtual void on_terrainPropertyTreeWidget_itemPressed(QTreeWidgetItem*, int column);

      virtual void on_terrainContentTabWidget_currentChanged(int index);

      virtual void on_terrainRuntimeOptionsTabWidget_currentChanged(int index);

      virtual void on_terrainContentTreeMenu_triggered(QAction* action);

      virtual void on_terrainPropertyTreeMenu_triggered(QAction* action);

      virtual void on_terrainContentTree_checkBox_stateChanged(const QTreeWidgetItem *, int checked);

      virtual void on_addTerrainPatchButton_released();

      virtual void on_addImageLayerButton_released();

      virtual void on_addElevationLayerButton_released();

      virtual void on_addFeatureButton_released();

      virtual void on_addFeatureLayerButton_released();

      virtual void on_addOceanLayerButton_released();

      virtual void on_commitChangesButton_released();

      virtual void on_revertChangesButton_released();

      virtual void on_saveTerrainButton_released();

      virtual void on_generateCacheButton_released();

      virtual void on_generateBoundaryButton_released();

      virtual void slot_visibleLayerVisibilityChanged(bool visible);

      virtual void slot_visibleLayerOpacityChanged(double opacity);

      virtual void slot_visibleLayerMinVisibleRangeChanged(double minRange);

      virtual void slot_visibleLayerMaxVisibleRangeChanged(double maxRange);

      virtual void slot_modelLayerLightingChanged(bool lighting);

      virtual void slot_oceanLayerHeightChanged(double height);

      virtual void slot_oceanLayerLodChanged(int lod);

      virtual void slot_groundCoverWindChanged(double wind);

      virtual void slot_groundCoverFillChanged(double fill);

      virtual void slot_groundCoverMaxDistanceChanged(double maxDistance);

      virtual void contextMenuEvent(QContextMenuEvent* e);

      virtual void dragEnterEvent(QDragEnterEvent *e);

      virtual void dropEvent(QDropEvent* e);


   private:
      DtTerrainEditorWidget();
      DtTerrainEditorWidget(const DtTerrainEditorWidget&);
      DtTerrainEditorWidget &operator=(const DtTerrainEditorWidget&);

   protected:

      DtDe & myDe;
      bool myIsInitialized;
      DtSignalConnectionManager mySignals;

      DtOsgEarthAddTerrainLayerWidget* myOsgEarthAddTerrainLayerWidget;
      DtOsgEarthAddModelLayerWidget* myOsgEarthAddModelLayerWidget;
      DtOsgEarthCacheDialog* myOsgEarthCacheDialog;
      DtOsgEarthGenerateBoundaryWidget* myOsgEarthGenerateBoundaryWidget;

      QVBoxLayout* myMainLayout;
      QTabWidget* myTopLevelTabWidget;

      QWidget* myAddDataWidget;
      QGridLayout* myAddDataButtonsLayout;
      QToolButton* myAddTerrainPatchButton;
      QToolButton* myAddServerConnectionButton;
      QToolButton* myAddImageLayerButton;
      QToolButton* myAddElevationLayerButton;
      QToolButton* myAddFeatureButton;
      QToolButton* myAddFeatureLayerButton;
      QToolButton* myAddOceanLayerButton;

      QWidget* myCacheWidget;
      QHBoxLayout* myCacheButtonsLayout;
      QToolButton* myGenerateCacheButton;
      QToolButton* myGenerateBoundaryButton;

      QWidget* mySaveWidget;
      QHBoxLayout* mySaveButtonsLayout;
      QToolButton* mySaveOsgEarthTerrainButton;
      QToolButton* mySaveTerrainButton;

      QTabWidget* myTerrainRuntimeOptionsTabWidget;

      QHBoxLayout* myBottomButtonsLayout;
      QPushButton* myCommitChangesButton;
      QPushButton* myRevertChangesButton;

      QTabWidget*  myTerrainContentTabWidget;
      QTreeWidget* myTerrainContentTreeWidget;
      QTreeWidget* myOsgEarthFragmentTreeWidget;
      QTreeWidget* myTerrainPropertyTreeWidget;
      QTreeWidget* myTerrainRuntimeTreeWidget;

      TerrainContentItemKey mySelectedTerrainContentItemKey;
      TerrainContentTreeWidgetItemsMap myTerrainContentTreeWidgetItemsMap;
      TreeWidgetType mySelectedTreeWidget;
      DtOsgEarthPropertyItemKey mySelectedDtOsgEarthPropertyItemKey;
      std::vector<TerrainContentItemKey> mySelectedOsgEarthFragmentKeys;

      OsgEarthFragmentContentItemsMap myOsgEarthFragmentContentItemsMap;

      TerrainPropertyTreeWidgetItemsMap myTerrainPropertyTreeWidgetItemsMap;
      TerrainRuntimeTreeWidgetItemsMap myTerrainRuntimeTreeWidgetItemsMap;

      QMenu* myTerrainContentTreeMenu;
      QMenu* myTerrainPropertyTreeMenu;
   };

   class DT_DLL_VRVTERRAINEDITOR DtTerrainEditorWidgetCreator
      : public DtVirtualBaseClass
   {
   public:
      static DtTerrainEditorWidgetCreator& instance(DtDe& de);
      static void registerInstance(DtDe& de, DtTerrainEditorWidgetCreator* creator);
      virtual DtTerrainEditorWidget* create(DtDe& de, QWidget* parent) const;
   };
}