displayDefinitionWidget.h

Go to the documentation of this file.

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

#pragma once

#if !defined(Q_MOC_RUN)


#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "simulationObjectEditorImpl/uiElement.h"
#include "simulationObjectEditorImpl/simulationModelSetLoader.h"
#include "simulationObjectEditorImpl/markerVisualizer.h"
#include <vlpi/entityType.h>
#include <vrfGuiCore/entityMapperKey.h>
#include <makArchives/DtObserverStateRecordsList.h>

#include <vrvCore/DtWindow.h> 
#include <vrvCore/DtSelectionManager.h> 
#include <vrvCore/DtTacticalGraphicUtilities.h> 
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <matrix/vlQuaternion.h>
#endif

#include <QImage>
#include <QWidget>

class DtModelSetEntry;
class QComboBox;
class DtVisualMarkingsWidget;
class QHBoxLayout;
class QLabel;
class QPushButton;
class QToolButton;
class DtModelDefinitionEditor;
class DtSymbolEditor;
class DtMarkerVisualizer;
class QCheckBox;
class QLineEdit;
class QFrame;
class QSpinBox;
class QGridLayout;
class QStandardItem;
class QTreeWidget;
class QToolButton;
class QAbstractButton;
class QVBoxLayout;
class DtBuoyancyEditingDialog;
class DtVisualSettingsWidget;
class DtVisualSpotReportSettingsWidget;

namespace makVrf
{
   class DtVrfObjectFacadeInterface;
   class DtEnvironmentalFacadeCollection;
   class DtForceSelectionEntryWidget;
   class DtToolButtonWrapperWidget;
}

namespace makVrv
{
   class DtDe;
   class DtPluginManager;
   class DtOsgAdapterQtWidget;
   class DtDeMainWindowProvider;
   class DtElementDefinitionManager;
   class DtElementDefinitionNew;
   class DtChannelManager;
   class DtChannel;
   class DtObserver;
   class DtOsgObserverObject;
   class DtWindowTextAgent;
   class DtWidgetLabelAgent;
   class DtVisualizerDefinitionSet;
   class DtVrvApplicationConfiguration;
   class DtCachedIntersectorsContainer;
}

class DT_DLL_simulationObjectEditorimpl DtDisplayWidget : public QWidget
{
   Q_OBJECT

public:

   DtDisplayWidget(makVrv::DtDe& appDe, makVrv::DtDe* de, QWidget * parent = 0, Qt::WindowFlags f = 0);

   DtDisplayWidget();

   virtual ~DtDisplayWidget();

   makVrv::DtOsgAdapterQtWidget* adapterWidget();

   virtual void init();
   virtual void quitting();

   virtual void buildAdapterWidget();

   virtual void buildTicker();

   const std::vector<int>& modelSets() const
   {
      return myModelSets;
   }

   int observerMode(int i) const
   {
      std::map<int, int>::const_iterator iter = myModeKeyMap.find(i);

      if (iter != myModeKeyMap.end())
      {
         return iter->second;
      }

      return 0;
   }

   const std::map<int, int>& modeMap() const
   {
      return myModeKeyMap;
   }

   boost::signals2::signal<void()> signal_channelsInitialized;

   virtual void initializeObservers();

   QImage contents();

   boost::signals2::signal<void()> signal_resized;

protected:

   virtual void createIg();

   virtual void preIgInitialize();

   virtual void overrideIgFunctionality();

   virtual void igInitialize();

   virtual void postIgInitialize();
   virtual void resizeEvent(QResizeEvent* event);

protected:
   makVrv::DtDe* myDe;
   makVrv::DtDe& myAppDe;
   makVrv::DtOsgAdapterQtWidget* myAdapterWidget;
   std::vector<int> myModelSets;
   std::map<int, int> myModeKeyMap;
};

class DT_DLL_simulationObjectEditorimpl DtDisplayWidgetCreator : public makVrv::DtWindowCreator
{

public:

   DtDisplayWidgetCreator(DtDisplayWidget* pWidget);

   virtual makVrv::DtWindow* create(makVrv::DtDe& de, makVrv::DtWindowConfiguration& wc);

protected:

   DtDisplayWidget* myWidget;

};

class DT_DLL_simulationObjectEditorimpl DtDisplayDefinitionWidget : public QWidget
{
   Q_OBJECT

public:
   typedef boost::function<void()> AskToChangeIfShared;
   typedef std::vector<makVrf::DtVrfObjectFacadeInterface*> Facades;

   DtDisplayDefinitionWidget(makVrv::DtDe& appDe, QWidget* p);

   virtual ~DtDisplayDefinitionWidget();

   virtual void init();

   virtual void edit(const makVrf::DtEntityMapperKey&, bool move = true, bool fromSelection = false);
   virtual void clearContents();

   makVrv::DtDe* de()
   {
      return myDe;
   }

   virtual void startSimulation();
   virtual void stopSimulation();

   virtual bool hasOneDiGuy() const;

   virtual void revertExisting(const std::set<makVrf::DtEntityMapperKey>& key);

   virtual void updateStatus();

   virtual void preSimulationModelSetSave();

   virtual void simulationModelSetLoaded();
   virtual void callReset();

   virtual void cloneEntry(const DtEntityType& oldType, const DtEntityType& newType, DtModelSetEntry*);
   virtual void uiEvent(const DtUiElementEvent&);

   virtual void setCompressedView(bool);

   virtual void setBlockOcean(const bool& set);
   virtual void moveObserverPosition(bool isMoved);


   virtual void disable();
   virtual void enable();
   DtDisplayWidget* displayWidget() { return myDisplayWidget; };

   virtual MarkerColor determineMarkerColor(const int markNum);

   virtual void setOnlyVisualControlsEnabled(bool);
   virtual bool askToChangeIfShared(AskToChangeIfShared);

   virtual void reeditForModelSet(int);

   virtual void setSpeedMultiplier(double d);

   bool showIMGui() const;
   virtual void setShowIMGui(bool);

   void updateDisplayIfSameElementDefinition(makVrv::DtElementDefinitionNew*);

   bool showMarkersAs2D() const
   {
      return myShowMarkersAs2D;
   }

   bool showMarkerLabels() const
   {
      return myShowMarkerLabels;
   }

   bool showMarkers() const
   {
      return myShowMarkers;
   }

   bool showBoundingVolumes() const
   {
      return myShowBoundingVolumes;
   }

   const Facades& facades() const
   {
      return myFacades;
   }

   bool isTacticalGraphic() const
   {
      return myShowingTacticalGraphic;
   }

   bool isUnit() const
   {
      return myShowingAggregate;
   }

   bool isEntity() const
   {
      return !isTacticalGraphic() && !isUnit();
   }

   makVrv::DtElementDefinitionNew* elementDefinition() const
   {
      return myElementDefinition;
   }

   makVrv::DtElementDefinitionManager* elementManager() const
   {
      return myManager;
   }

   const makVrf::DtEntityMapperKey& editingKey() const
   {
      return myKey;
   }

   bool showingSpotReports() const
   {
      return (spotReportMode() != -1);
   }

   bool showOceanForWaterVehicles() const
   {
      return myShowOceanForWaterVehicles;
   }

   virtual void setShowOceanForWaterVehicles(bool);

   virtual void setKeepVisualModelEditorUpToDate(bool);
   bool keepVisualModelEditorUpToDate() const
   {
      return myKeepVisualModelEditorUpToDate;
   }

   virtual void updateVisualModelEditorWithCurrentSelection();

   virtual bool displayEnabled() const;

   virtual void selectModelSet(int, bool spotReportMode = false);

   virtual void draw2DIcon();
   virtual void resetVisuals();

   virtual void visualBaseChangedForTacticalGraphic(const std::string& schema, const std::string& visualizer);
   virtual void visualBaseChangedForEntity(makVrv::DtElementDefinitionNew*);

   virtual void setEnvironmentalLabel(const std::string&, bool andSetInEnv = false);
   virtual void updateVisualizerModifiedData();

   virtual bool changeFromLineToVolumetricLine();
   virtual bool changeFromVolumetricLineToLine();
   virtual bool changeFrom2DAreaTo3DArea();
   virtual bool changeFrom3DAreaTo2DArea();

   virtual void setViewMagnification(double);

   boost::signals2::signal<void(bool)> signal_compressedChanged;
   boost::signals2::signal<void()> signal_visualizersHaveBeenModified;
   boost::signals2::signal<void()> signal_disabled;
   boost::signals2::signal<void()> signal_enabled;
   boost::signals2::signal<void(bool)> signal_showingSpotReports;
   boost::signals2::signal<void(const Facades&)> signal_facadesCreated;
   boost::signals2::signal<void(const Facades&)> signal_facadesRecreated;
   boost::signals2::signal<void(int)> signal_reeditForModelSet;
   boost::signals2::signal<void()> signal_visualsModified;

protected:
   virtual void simulate();
   virtual void initializeFacadeForSimulation();
   virtual void enableEditButton();
   virtual bool checkAndCreateDiGuyModelDefinition(const makVrf::DtEntityMapperKey&);

   virtual makVrv::DtUniqueID uniqueIDForModelSet() const;

   virtual void makeSureAllMilStdVisualizersAreTheSameAs(int modelSet);

   virtual void postInitialize();

   virtual void createNewEntry(const DtEntityType& newType, DtModelSetEntry* model, const DtEntityType& basedOnType = DtEntityType(),
      bool resetTacticalGraphic = true, bool force = false, const makVrv::DtUnicode& elementDefinitionName = makVrv::DtUnicode::fromAscii(""),
      makVrv::DtElementDefinitionManager* = 0);

   virtual DtVector visualPlacementFor(int set, makVrf::DtVrfObjectFacadeInterface*) const;
   virtual double groundHeight(const DtVector&) const;

   virtual void createOrUpdatePositionMarker(const DtUiElementEvent&);
   virtual void destroyPositionMarker(const DtUiElementEvent&);
   virtual void setBoundingVolume(const DtUiElementEvent&);
   virtual void runAfterCallFunction();

   virtual void updateMarkerAttachments();

   virtual void changeTrailingEffect(const QString&);

   virtual void resetEntityOrigin();
   virtual void showEvent(QShowEvent*);

   virtual void mergeVisualizerAttributes(int modelSet, const makVrv::DtVisualizerDefinitionSet& source, makVrv::DtElementDefinitionNew* target) const;

   virtual void createEntryIfNoEntry(const DtEntityType&, bool force = false);
   virtual void createEntityIfNoEntry(const DtEntityType&, bool force = false);
   virtual void createTacticalGraphicIfNoEntry(const DtEntityType&, bool force = false);
   virtual void createAggregateIfNoEntry(const DtEntityType&, bool force = false);

   virtual bool hasScribeOnExtent() const;
   virtual void setShowScribeOnExtent(bool);

   virtual void resetMarkers();

   virtual DtString createVisualizerNameFor(makVrv::DtElementDefinitionManager*, DtModelSetEntry* entry);
   virtual void opdEntryAdded(DtModelSetEntry* model, const DtEntityType&);
   virtual void newDataFilesAdded(const std::vector<DtSimulationModelSetLoader::EntityData*>&);
   virtual void visualMappingsModified(DtSimulationModelSetLoader::EntityData*);
   virtual std::string modeForModelSet(int s);
   virtual void setupForSimulationObjectGroup();
   virtual void zoomToExtents();

   virtual bool isTacticalSmoke(const makVrf::DtEntityMapperKey&) const;
   virtual void enableDynamicOceanAndPosition();

   virtual void uiElementModified(DtUiElement*);

   virtual void resetObserverViewModeToDefault(int tickCount, bool changeViewMode);

   virtual void setMarkingDecal(const std::string& annotation, const std::string& value);

   virtual void setupForces();


   virtual int spotReportMode() const;
   virtual void spotReportEditingChanged();

   virtual void displayWidgetResized();
   virtual void isBuoyancyAvailable();
   virtual void areVisualMarkingsAvailable();
   virtual void createEditors();
   virtual void resetMaintainObserverPosition();
   virtual bool checkMaintainObserverPosition(bool force = false);
   virtual void finishUpVisuals();

public slots:
   virtual void resetView();
   virtual void edit2DVisuals();
   virtual void editVisuals();
   virtual void forcesModified();
   virtual void setShowMarkerLabels(bool);
   virtual void setShowMarkers(bool);
   virtual void setShowMarkersAs2D(bool);
   virtual void setShowBoundingVolumes(bool);
   virtual void buoyancyDialogDestroyed();

   virtual bool setupForTacticalGraphic(const DtEntityType&, const std::vector<int>& modelSets);
   virtual bool setupForEntity(const DtEntityType&, const std::vector<int>& modelSets);
   virtual void visualizerModifiedWithReedit(bool reedit);
   virtual void modelDefinitionModified();
   virtual void visualizerModified();
   virtual void visualsHaveBeenModified();
   virtual void onChangeDefaultView();
   virtual void onChangeDefaultViewWithObserverReset();
   virtual void restoreObserverView();
   virtual QString markerKey(const DtUiElementEvent& e) const;

protected slots:
   virtual void buoyancyDestroyed();
   virtual void observerModeChanged();
   virtual void reedit();
   virtual void finalizeModelChange();
   virtual void setDiGuyData(const DtDiGuyInformation& diGuyData);
   virtual void changeViewMode(int);
   virtual void calculateSupportPoints();
   virtual void calculateBoundingVolume();
   virtual void forceComboChanged();
   virtual void buoyancyModelRejected();
   virtual void editBuoyancy();
   virtual void editVisualMetaData();

signals:
   void visualsModified();
   void uiElementEvent(const DtUiElementEvent&);
   void redisplayListIcons();

public:
   QWidget*                   myDisplayContainerWidget;
   QVBoxLayout*               myDisplayContainerLayout;
   QVBoxLayout*               myCanvasLayout;
   QLabel*                    myFreezeFrame;
   DtDisplayWidget*           myDisplayWidget;
   QHBoxLayout*               myMainLayout;
   QWidget*                   myMainCanvas;
   QLabel*                    myObserverModeLabel;
   QComboBox*                 myObserverMode;
   QComboBox*                 myDefaultView;
   QLabel*                    myDefaultViewLabel;
   makVrf::DtForceSelectionEntryWidget* myForces;
   QToolButton*               my2DIcon;

   QWidget*                   myToolbarButtonsWidget;
   QHBoxLayout*               myToolbarButtonsLayout;
   QToolButton*               myShowVisualEffects;
   QToolButton*               myShowSwitchNodes;
   QToolButton*               myShowEnvironmentSettings;

   QToolButton*               myEditVisualConfiguration;
   QToolButton*               myEditBuoyancyModel;
   QToolButton*               myEditVisualMetaData;

   QWidget*                   myVisualModificationWidget;
   QGridLayout*               myVisualModificationLayout;

   QWidget*                   myVisualDisplayChangeWidget;
   QGridLayout*               myVisualDisplayChangeLayout;

   QHBoxLayout* myCompressedObserverLayout;
   DtBuoyancyEditingDialog* myBuoyancyDialog;
   DtVisualSpotReportSettingsWidget* myVisualSpotReportSettingsWidget;
   DtVisualSettingsWidget* myVisualSettingsWidget;
   DtVisualMarkingsWidget* myVisualMarkingsWidget;
protected:
   makVrv::DtDe&              myAppDe;
   makVrv::DtDe*              myDe;
   makVrf::DtEntityMapperKey          myKey;
   makVrf::DtEntityMapperKey          myLastKey;

   QSize myDisabledSize;

   bool myWakeDisplayEnabled;
   double mySpeedMultiplier;
   int myTerrainLength;
   bool myImageCheck;
   bool myIsFirstDiGuyShow;
   bool myLastWasDiGuy;
   bool myShowMarkersAs2D;
   bool myShowMarkerLabels;
   bool myShowMarkers;
   bool myBlockOcean;
   bool myShowBoundingVolumes;
   bool myWarnedForBoundingVolumes;
   bool myWasInSpotReportMode;
   bool myShowOceanForWaterVehicles;
   bool myEditingVisuals = false;
   std::map<int, int> myViewSelection;
   bool myMaintainObserverPosition;

   Facades myFacades;

   bool myShowingAggregate;
   makVrv::DtElementDefinitionNew* myElementDefinition;
   makVrv::DtElementDefinitionManager* myManager;

   struct ElementInformation
   {
      ElementInformation() : manager(0), definition(0), type(makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes_End) {};
      ElementInformation(makVrv::DtElementDefinitionManager* mgr, makVrv::DtElementDefinitionNew* def, makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes t)
         : manager(mgr), definition(def), type(t)
      {
      }
      ElementInformation(const ElementInformation& orig)
         : manager(orig.manager), definition(orig.definition), type(orig.type)
      {
      }

      makVrv::DtElementDefinitionManager* manager;
      makVrv::DtElementDefinitionNew* definition;
      makVrv::DtElementDefinitionTypeManager::BuiltInElementTypes type;
   };

   typedef std::map<std::string, ElementInformation> ElementDefinitionMap;
   typedef std::map<bool, ElementDefinitionMap> ElementDefinitionMapByType;

   ElementDefinitionMapByType myElementDefinitionMap;

   bool myAllIs2D;

   bool myModelDefinitionModified;
   bool myEntityModified;
   bool mySpotReportsModified;
   bool myAggregateModified;
   bool myTacticalGraphicsModified;
   QAbstractButton* myCurrentForceButtonSelected;

   typedef std::pair<DtVector, DtTaitBryan> CameraInfo;
   typedef std::map<int, CameraInfo> CameraMap;
   CameraMap myCameraInfo;

   typedef std::map<QString, DtMarkerVisualizer*> Markers;
   Markers myMarkers;

   DtUiElementEvent myLastBoundingVolume;
   bool myCompressedView;

   bool myHaveWarned;
   int myArrowSize;
   std::string myLabel;
   bool myShowingTacticalGraphic;
   bool myEditable;
   makVrv::vrvTacticalGraphicUtilities::PenStyle myPenStyle;
   makVrv::vrvTacticalGraphicUtilities::FillStyle myFillStyle;
   makArchives::DtObserverStateRecordsList myObserverViews;
   bool myCheckMaintainObserverPosition;
   DtVector myObserverPosition, myModifiedObserverPosition;
   DtQuaternion myObserverOffsetRotation;

   std::vector<makVrv::DtWidgetLabelAgent*> myInSpotReportMode;

   bool myWakesEnabled;
   bool mySettingUpEditor;
   bool myDisplayEnabled;

   std::set<std::string> myAlreadyAskedForShared;
   bool myForceCreateNewElementDefinition;
   bool myCallAfterEditFunction;
   int myRunTicker;
   bool myResetInstead;
   AskToChangeIfShared myFunctionToCallAfterEdit;

   int myLastSelectedObserverMode;

   makVrv::DtCachedIntersectorsContainer* myCachedIntersectorManager = nullptr;
   makVrv::DtSignalConnectionManager myViewModeConnections;
   makVrv::DtSignalConnectionManager myConnections;
   boost::signals2::connection myChangeObserverViewConnection;
   boost::signals2::connection myReeditConnection;
   boost::signals2::connection myPostReeditFunctionConnection;
   boost::signals2::connection myResetObserverViewToDefault;

   bool myNeedsResetView;
   bool myWantsToSimulate;
   double myLastSimulationTime;
   double myIsGroundVehicle;
   DtVector myStartingLocation;
   double myAltitudeAboveSeaLevel;
   bool myIsSimulating;
   std::string myCurrentAction;
   int mySpotReportModeStart;

   double myViewMagnification;
   double myDelayReeditUntil;
   int myLastKind;

   std::vector<DtUiElementEvent> myQueuedEvents;
   bool myKeepVisualModelEditorUpToDate;
};

class DT_DLL_simulationObjectEditorimpl DtUiDisplayWidgetCanvas : public DtUiElement
{
public:
   DtUiDisplayWidgetCanvas(makVrv::DtDe&);

   virtual ~DtUiDisplayWidgetCanvas();

   static DtUiElement* CreatorFunction(makVrv::DtDe&);

   virtual void processUiEvent(const DtUiElementEvent&);

   virtual DtString uniqueName() const
   {
      return "DtUiDisplayWidgetCanvas";
   }

   virtual void setEnabled(bool b);

protected:
   virtual void createControls(QWidget*);
   virtual void setFromParameters(const std::vector<DtReaderWriter*>& parentRw);
};

class DT_DLL_simulationObjectEditorimpl DtDisplayDefinitionWidgetHolder : public makVrv::DtVirtualBaseClass
{
public:
   DtDisplayDefinitionWidgetHolder(makVrv::DtDe& de, QWidget* parent);

   virtual ~DtDisplayDefinitionWidgetHolder();

   static DtDisplayDefinitionWidget* instance(makVrv::DtDe& de, QWidget* parent);

   DtDisplayDefinitionWidget* displayDefinitionWidget() { return myWidget; };

protected:
   DtDisplayDefinitionWidget* myWidget;
};

class DT_DLL_simulationObjectEditorimpl DtDisplayWidgetDe : public makVrv::DtDe
{
public:
   DtDisplayWidgetDe(makVrv::DtVrvApplicationConfiguration& appConfig, DtDe& appDe);

   virtual makVrv::DtVirtualBaseClass* findInstance(const std::string& instanceName) const;
   virtual void createDebugLog(const std::string& fileName, makVrv::DtDebugLog::PrintLevel level) override;
   virtual void postInitialize() override;

   virtual ~DtDisplayWidgetDe();

   virtual void quit() override;

   DtDe& appDe()
   {
      return myAppDe;
   }

protected:
   DtDe& myAppDe;
};