DtTerrainEditorInterface.h

Go to the documentation of this file.

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

#pragma once

#include <vrvTerrainEditor/vrvTerrainEditor.h>
#include <vrvUtil/DtUnicode.h>

namespace osgEarth
{
   class MapOptions;
   class MapNodeOptions;
   class TerrainOptions;
   class ImageLayerOptions;
   class ElevationLayerOptions;
   class ModelLayerOptions;
   class MaskLayerOptions;
   class LandCoverLayerOptions;
   namespace Buildings
   {
      class BuildingLayerOptions;
   }
   namespace Splat
   {
      class GroundCoverLayerOptions;
      class GroundCoverOptions;
      class RoadSurfaceLayerOptions;
      class SplatLayerOptions;
   }
}

namespace makArchives
{
   class DtModelDefinitionRecord;
   class DtFeatureLayerRecord;
   class DtOceanLayerRecord;
   class DtTerrainRecord;
}

namespace makVrv
{
   class DtOsgEarthXmlReference;
   class DtOsgEarthFileParser;
   class DtTerrainEditorProperties;

   class DT_DLL_VRVTERRAINEDITOR DtTerrainEditorInterface
   {
   public:

      //Type of the terrain content item.
      enum TerrainContentItemType
      {
         Terrain,
         ImageLayerGroup,
         ElevationLayerGroup,
         ModelLayerGroup,
         MaskLayerGroup,
         BuildingLayerGroup,
         LandCoverLayerGroup,
         GroundCoverLayerGroup,
         RoadSurfaceLayerGroup,
         SplatLayerGroup,
         TerrainPatchGroup,
         OceanLayerGroup,
         FeatureSourceGroup,
         FeatureLayerGroup,
         AerodromeLayerGroup,
         OsgEarthFeatureLayerGroup,
         OsgEarthTerrainPatch,
         OpenFlightTerrainPatch,
         FeatureSource,
         FeatureLayer,
         AerodromeLayer,
         OsgEarthFeatureLayer,
         OceanLayer,
         ImageLayer,
         ElevationLayer,
         ModelLayer,
         MaskLayer,
         BuildingLayer,
         LandCoverLayer,
         GroundCoverLayer,
         GroundCover,
         RoadSurfaceLayer,
         SplatLayer,
         TreeWidget,
         CompositeImageLayer,
         CompositeElevationLayer,
         CompositeParentLayer,
         CompositeChildLayer,
         UnknownType
      };

      class TerrainContentItemKey
      {
      public:

         TerrainContentItemKey();

         TerrainContentItemKey(int type, int id, const TerrainContentItemKey& parentKey);

         TerrainContentItemKey(int type, const std::string& name, const TerrainContentItemKey& parentKey);

         TerrainContentItemKey(int type, const std::string& name, int parentType, int parentId);

         TerrainContentItemKey(int type, int id, int parentType, int parentId);

         void invalid();

         void setType(int type);

         void setId(int id);

         void setParentType(int type);

         void setParentId(int id);

         void setParentKey(const TerrainContentItemKey& parentKey);

         void setName(const std::string& name);

         const int type() const;

         const int id() const;

         const int parentType() const;

         const int parentId() const;
         
         std::string name() const;

         const bool useName() const;

         bool operator<(const TerrainContentItemKey&) const;

         bool operator==(const TerrainContentItemKey&) const;

      protected:
         int myType;
         int myId;
         int myParentType;
         int myParentId;
         bool myUseName;
         std::string myName;
      };

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

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

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

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

      virtual void clearTreeWidgets() = 0;

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

      virtual void removeTerrainContentTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual bool hasTerrainContentTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual bool hasTerrainPropertyTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual void cleanOsgEarthFragmentTreeWidget() = 0;

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

      virtual void moveTerrainContentTreeWidgetItem( TerrainContentItemKey key, bool up) = 0;

      virtual void setGenerateCacheButtonEnabled(bool enabled) = 0;

      virtual void setGenerateBoundaryButtonEnabled(bool enabled) = 0;

      virtual void setSaveTerrainButtonEnabled(bool enabled) = 0;

      virtual void setCommitChangeButtonEnabled(bool enabled) = 0;
      
      virtual void setRevertChangeButtonEnabled(bool enabled) = 0;

      virtual void enableOsgEarthFragmentTabWidget(bool enabled) = 0;

      virtual void resizeTerrainPropertyTreeWidget() = 0;

      virtual void resizeTerrainFragmentTreeWidget() = 0;

      virtual void setTerrainPropertyTreeItemName(const TerrainContentItemKey& key, const std::string& name) = 0;

      virtual void setTerrainPropertyTreeItemVisibility(const TerrainContentItemKey& key, bool visible) = 0;

      virtual void setTerrainContentTreeItemName(const TerrainContentItemKey& key, const std::string& name) = 0;

      virtual void setTerrainContentTreeItemVisibility(const TerrainContentItemKey& key, bool visible) = 0;

      virtual void showTerrainPropertyTreeWidgetItem(const TerrainContentItemKey& key) = 0;

      virtual void showTerrainPropertyTreeWidgetItems(const std::vector<TerrainContentItemKey>& keys) = 0;

      virtual void setProperties(const TerrainContentItemKey& key, const DtTerrainEditorProperties* props) = 0;

      virtual bool properties(const TerrainContentItemKey& key, DtTerrainEditorProperties* props) = 0;

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

      virtual DtUnicode showSaveMtfFileDialog(const DtUnicode& directory) = 0;

      virtual DtUnicode showSaveOsgEarthFileDialog(const DtUnicode& directory) = 0;

      virtual void showSaveFileConfirmationMessageBox(const DtUnicode& fileName) = 0;

      virtual bool showWarnReloadTerrainMessageBox(bool& checked) = 0;

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

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

      virtual void showFileExtensionNotSupportedMessageBox(const DtUnicode& fileName) = 0;

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

      virtual void expandTerrainContentTreeWidget() = 0;

      virtual void expandOsgEarthFragmentTreeWidget() = 0;

      virtual int getIndexOfTerrainContentItem(const TerrainContentItemKey& key) = 0;

      virtual bool checkIfNameDuplicate(const TerrainContentItemKey& key, const std::string& name) = 0;

   public:


      boost::signalslib::signal<void(const TerrainContentItemKey& key)> signal_terrainPropertyTreeWidgetItem_currentItemChanged;
   
      boost::signalslib::signal<void(const TerrainContentItemKey& key)> signal_terrainContentTreeWidget_itemDoubleClicked; 

      boost::signalslib::signal<void(const std::string& key)> signal_osgEarthFragmentTreeWidget_currentItemChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key)> signal_terrainContentCommitChangesButtonReleased;

      boost::signalslib::signal<void(const TerrainContentItemKey& key)> signal_terrainContentRevertChangesButtonReleased;

      boost::signalslib::signal<void(const std::vector<TerrainContentItemKey>& keys)> signal_osgEarthFragmentCommitChangesButtonReleased;

      boost::signalslib::signal<void(const TerrainContentItemKey& key)> signal_saveTerrainContentTreeWidgetItem;

      boost::signalslib::signal<void(const TerrainContentItemKey& key)> signal_deleteTerrainContentTreeWidgetItem;

      boost::signalslib::signal<void()> signal_generateBoundaryButton_released;

      boost::signalslib::signal<void(const DtUnicode& fileName, bool toFrontEnd, bool toSimEngine)> signal_addFeatureLayerButtonReleased;

      boost::signalslib::signal<void()> signal_addOceanLayerButtonReleased;

      boost::signalslib::signal<void(int type, const std::string& name, const std::string& driver, const DtUnicode& url)> signal_osgEarthTerrainLayerRequestAdded;

      boost::signalslib::signal<void(const std::string& name, const std::string& driver, const DtUnicode& url, const std::string& wfsType)> signal_osgEarthModelLayerRequestAdded;

      boost::signalslib::signal<void(const std::string& definition, const std::string& name, bool geocentric, bool convexHull)> signal_generateBoundary;

      boost::signalslib::signal<void()> signal_saveOsgEarthTerrain;

      boost::signalslib::signal<void()> signal_saveTerrain;

      boost::signalslib::signal<void()> signal_generateCacheButtonReleased;

      boost::signalslib::signal<void(std::vector<std::string>)> signal_addData;


      //| Signals used to change the runtime property(visibility, visible range, etc) of the terrain content item.

      boost::signalslib::signal<void(const TerrainContentItemKey& key, bool visible)> signal_visibleLayerVisiblityChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, double opacity)> signal_visibleLayerOpacityChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, double minRange)> signal_visibleLayerMinVisibleRangeChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, double maxRange)> signal_visibleLayerMaxVisibleRangeChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, bool enabled)> signal_osgEarthDebugModeStateChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, const std::string& description)> signal_terrainDescriptionChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, int maxPagedLODs)> signal_terrainMaxPagedLODsChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, const std::string& name)> signal_oceanLayerNameChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, double height)> signal_oceanLayerHeightChanged;

      boost::signalslib::signal<void(const TerrainContentItemKey& key, int lod)> signal_oceanLayerLodChanged;

   };
}