displayDefinitionWidget.h

Go to the documentation of this file.

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

#pragma once

#include <vrvUtil/signalslib.h>

#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "simulationObjectEditorImpl/visualEditors.h"
#include "simulationObjectEditorImpl/uiElement.h"
#include "simulationObjectEditorImpl/simulationModelSetLoader.h"
#include "simulationObjectEditorImpl/markerVisualizer.h"
#include <vlpi/entityType.h>
#include "ui_DtTacticalGraphicStylesUi.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 <QImage>
#include <QWidget>

class DtModelSetEntry;
class DtUiElementEvent;
class QComboBox;
class QHBoxLayout;
class QGroupBox;
class QLabel;
class QPushButton;
class DtModelDefinitionEditor;
class DtSymbolEditor;
class DtMarkerVisualizer;
class QCheckBox;
class QLineEdit;
class QFrame;
class QSpinBox;
class QGridLayout;
class QStandardItem;
class QTreeWidget;

namespace makVrf
{
   class DtVrfObjectFacadeInterface;
   class DtEnvironmentalFacadeCollection;
}

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

class DtBuoyancyEditingDialog;

class DT_DLL_simulationObjectEditorimpl DtDisplayWidget : public QWidget
{
   Q_OBJECT

public:

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

   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::signal<void ()> signal_channelsInitialized;

   virtual void initializeObservers();
   
   QImage contents();

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;

   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 bool hasOneDiGuy() const;

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

   virtual void updateStatus();
   
   virtual void preSimulationModelSetSave();

   virtual void simulationModelSetLoaded();

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

   virtual void setCompressedView(bool);
   virtual void setStackedView(bool);
   virtual QString visualBase() const;

   virtual void disable();
   virtual void enable();
   DtDisplayWidget* displayWidget() { return myDisplayWidget; };
   virtual void updateSpecifics();
   virtual MarkerColor determineMarkerColor(const int markNum);

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

   virtual void reeditForModelSet(int);

   boost::signal<void (bool)> signal_compressedChanged;

protected:
   virtual makVrv::DtUniqueID uniqueIDForModelSet() const;

   virtual void makeSureAllMilStdVisualizersAreTheSameAs(int modelSet);

   virtual void postInitialize();
   virtual void reedit();

   virtual void setupVisualBases(const makVrv::DtElementDefinitionNew*);

   virtual bool setupEditor(int set, bool* hasCenteredIcon = 0);

   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);

   void initSematicsTextMapping();

   virtual DtVector visualPlacementFor(int set, const DtString&, 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 bool changeFromLineToVolumetricLine();
   virtual bool changeFromVolumetricLineToLine();

   virtual void updateMarkerAttachments();

   virtual bool changeFrom2DAreaTo3DArea();
   virtual bool changeFrom3DAreaTo2DArea();

   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 void setupLabel();
   virtual void createEditors(bool allIs2D);
   virtual bool hasScribeOnExtent() const;
   virtual void setShowScribeOnExtent(bool);

   virtual void resetMarkers();

   virtual void visualsHaveBeenModified();
   virtual void hasVertices(QCheckBox*);
   virtual void hasSymbolDecorations(QCheckBox*);
   virtual void isEllipse(QCheckBox*);
   virtual void isScribed(QCheckBox*);
   virtual void isOutlineScribed(QCheckBox*);
   virtual void setupArrowStyle(QComboBox*);
   virtual void setupDefaultWidth(QSpinBox*);
   virtual void setupDefaultPhysicalWidth(QSpinBox*);
   virtual void setupDefaultPhysicalHeight(QSpinBox*);
   virtual void setupDefaultScribedWidth(QSpinBox*);
   virtual void setupArrowSize(QSpinBox*);
   virtual void setupArrowFrequency(QComboBox*);
   virtual void setupLineStyle(QComboBox*);
   virtual void setupFillStyle(QComboBox*);
   virtual void setupStipple(QComboBox*);
   virtual void setupDefaultColor(QPushButton*);
   virtual void setupScribeColor(QPushButton*);
   virtual void setup(const std::string& attribute, QComboBox*);
   virtual void setup(const std::string& attribute, QSpinBox*);
   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 setupColor(QPushButton*, QColor&, const std::string&);
   virtual void changeColor(QPushButton*, QColor&, const std::string&);
   virtual void setupForSimulationObjectGroup();
   virtual void zoomToExtents();
   virtual void cleanupEditors();
   virtual std::string schemaFromFacade(makVrf::DtEnvironmentalFacadeCollection*) const;
   virtual void initSemanticsTextMapping();
   virtual void setupModelStates();

   virtual void resetVisuals();

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

   virtual void uiElementModified(DtUiElement*);
   virtual void setIsEllipse(bool);
   virtual void setScribed(bool);
   virtual void setOutlineScribed(bool);
   virtual void setShowVertices(bool);
   virtual void setShowSymbolDecorations(bool);
   virtual void setVisualizerEnabledChanged(int, bool);

public slots:
   virtual void forcesModified();
   virtual void setMarkerLabelsVisible(bool);
   virtual void setMarker2DMode(bool);
   virtual void setBoundingVolumesVisible(bool);

   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();

protected slots:
   virtual void finalizeModelChange();
   virtual void updateVisualizerModifiedData();
   virtual void buoyancyDialogDestroyed();
   virtual void elementDefinitionWidgetDestroyed();
   virtual void buoyancyDestroyed();
   virtual void editBuoyancy();
   virtual void spotReportEditingChanged();
   virtual void onDaylightChanged();
   virtual void useMildStdFontChanged();
   virtual void setDiGuyData(const DtDiGuyInformation& diGuyData);
   virtual void onChangeDefaultView();
   virtual void changeViewMode(int);
   virtual void visualBaseChanged(int);
   virtual void visualizerModified();
   virtual void markerVisibilityChanged();
   virtual void marker2DModeChanged();
   virtual void boundingVolumesVisibilityChanged();
   virtual void showVertices();
   virtual void showSymbolDecorations();
   virtual void setIsEllipse();
   virtual void visualizerEnabledChanged();
   virtual void changeArrowStyle(int);
   virtual void setScribed();
   virtual void setOutlineScribed();
   virtual void changeScribedWidth(int);
   virtual void changeDefaultWidth(int);
   virtual void changeDefaultPhysicalWidth(int);
   virtual void changeDefaultPhysicalHeight(int);
   virtual void changeArrowSize(int);
   virtual void changeArrowFrequency(int);
   virtual void changeLineStyle(int);
   virtual void changeFillStyle(int);
   virtual void change(const std::string& style, int);
   virtual void changeStipple(int);
   virtual void changeDefaultColor();
   virtual void changeScribeColor();
   virtual void modelStateChanged(QTreeWidgetItem*, int);
   virtual void calculateSupportPoints();
   virtual void calculateBoundingVolume();
   virtual void buoyancyModelModified();

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

public:
   QWidget*                   myDisplayContainerWidget;
   QVBoxLayout*               myDisplayContainerLayout;
   QLabel*                    myFreezeFrame;
   DtDisplayWidget*           myDisplayWidget;
   QLabel*                    myVisualBasesLabel;
   QComboBox*                 myVisualBases;
   QHBoxLayout*               myMainLayout;
   QGroupBox*                 myGroupBox;
   QLabel*                    myObserverModeLabel;
   QComboBox*                 myObserverMode;
   QWidget*                   myTopLineWidget;
   QWidget*                   myModelStates;
   QTreeWidget*               mySwitchNodeStates;
   QLabel*                    mySwitchNodesLabel;
   QComboBox*                 myDefaultView;
   QLabel*                    myDefaultViewLabel;

   QCheckBox* myMarkerLabelsVisible;
   QCheckBox* myMarkerLabels2D;
   QHBoxLayout* myDaylightLayout;
   QWidget* myDaylightCanvas;
   QLabel* myDaylightLabel;
   QComboBox* myDaylight;
   QCheckBox* myBoundingVolumesVisible;
   QCheckBox* myShowSpotReports;
   QFrame* mySeparator;
   QGridLayout*               myTitleLayout;

   std::vector<QWidget*> myEditorCanvases;
   std::vector<QCheckBox*> myTitles;

   std::vector<QWidget*> myMilStdEditorCanvases;
   std::vector<QCheckBox*> myMilStdTitles;
   QHBoxLayout* myCompressedObserverLayout;

   Ui_DtTacticalGraphicStylesUi myStylesImpl;
   QWidget* mySpecificsCanvas;
   QFrame* mySpecificsSeparator;
   QWidget* myBuoyancyWidget;
   DtBuoyancyEditingDialog* myBuoyancyDialog;

   QWidget* myElementDefinitionWidget;
   QLabel* myElementDefinitionLabel;
   QLabel* myElementDefinitionUsed;

protected:
   makVrv::DtDe&              myAppDe;
   makVrv::DtDe*              myDe;
   makVrf::DtEntityMapperKey          myKey;
   makVrf::DtEntityMapperKey          myLastKey;

   bool myIsFirstDiGuyShow;
   bool myLastWasDiGuy;

   typedef std::vector<makVrf::DtVrfObjectFacadeInterface*> Facades;

   Facades myFacades;

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

   typedef std::pair<makVrv::DtElementDefinitionManager*, makVrv::DtElementDefinitionNew*> ElementDefinitionPair;
   typedef std::map<std::string, ElementDefinitionPair> ElementDefinitionMap;
   typedef std::map<bool, ElementDefinitionMap> ElementDefinitionMapByType;

   ElementDefinitionMapByType myElementDefinitionMap;
   bool myAddingStates;

   std::map<int, DtVisualEditor*>   myEditors;
   std::map<int, DtVisualEditor*>   myEnvironmentalMilStdIcons;
   std::vector<int> myIsFirstShow;
   bool myAllIs2D;

   bool myModelDefinitionModified;
   bool myEntityModified;
   bool mySpotReportsModified;
   bool myAggregateModified;
   bool myTacticalGraphicsModified;

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

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

   DtUiElementEvent myLastBoundingVolume;
   bool myCompressedView;
   bool myStackedView;

   bool myHaveWarned;
   QColor myDefaultColor;
   QColor myScribeColor;
   int myArrowSize;
   int myLineWidth;
   std::string myLabel;
   bool myShowingTacticalGraphic;
   bool myEditable;
   makVrv::vrvTacticalGraphicUtilities::PenStyle myPenStyle;
   makVrv::vrvTacticalGraphicUtilities::FillStyle myFillStyle;
   makArchives::DtObserverStateRecordsList myObserverViews;

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

   std::map<int, QString>  mySemanticsTextMapping;
   bool myWakesEnabled;
   bool mySettingUpEditor;

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

   makVrv::DtSignalConnectionManager myViewModeConnections;
};

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;
};