commonScenarioManager.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 <vrfGuiCommonQt/vrfGuiCommonQt.h>
#include <vrfGuiCore/scenarioSignaler.h>

#include <vrfGuiCore/vrfGuiApplicationSettings.h>
#include <vrfGuiCore/vrfMenu.h>
#include <vrfGuiCore/entityMapperKey.h>
#include <vrfGuiCore/vrfObjectManipulationManager.h>
#include <vrfGuiCore/vrfScriptedTaskSettingsRecord.h>
#include <vrvCore/DtUniqueID.h>
#include <makArchives/DtObserverStateRecordsList.h>
#include <vrfutil/simulationObjectCategoryInformation.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>

#include <vrvCore/DtToolbarConfiguration.h>

#include <vrfutil/scenario.h>
#include <vrfutil/deadReckoningSettings.h>
#include <vrfutil/rwHazardAreaInformation.h>
#include <vrfutil/stealthCommand.h>
#include <vlutil/vlPerformanceStats.h>
#endif

#include <boost/signals2.hpp>

#include <QtCore/QVector>
#include <QtCore/QFileInfo>
#include <QtCore/QEvent>
#include <QtWidgets/QDialog>

#include <QtCore/qnamespace.h>

class QLabel;
class DtScenario;
class DtScenarioExplorer;
class QFileDialog;
class DtSimMessage;
class DtIfServerMessage;
class DtModelSetEntry;
class QTranslator;
class DtSimulationModelSet;
class DtTerrainFilenameRemapper;
class QWidget;

namespace makArchives
{
   class DtTerrainOperationRecord;
   class DtTerrainRecord;
}

namespace makVrv
{
   class DtRecordSettingsBackupInterface;
   class DtMenuConfiguration;
   class DtDe;
}

#define DtFavoritesTopLevelIconRank -99999
#define DtRecentTopLevelIconRank 99998

namespace makVrf
{
   class DtUnifiedControlToolbarConfiguration;
   class DtFileCommChannel;
   class DtVrfScenarioRemapFunction;
   class DtVrfSimBackendManager;
   class DtVrfBackendState;
   class DtNeverAskAgainMessageBox;
   class DtSessionStatusBox;
   class DtSessionStartupDialog;
   class DtSubMenuConfiguration;
   class DtVrfModelSetManager;
   class DtEventManagerEventInterface;

   class DT_DLL_VRFGUICOMMONQT DtVrfGuiRecentScenarios : public DtVrfGuiApplicationSetting
   {
   public:
      DtVrfGuiRecentScenarios(makVrv::DtDe* = 0);
      DtVrfGuiRecentScenarios(const DtVrfGuiRecentScenarios&);

      virtual ~DtVrfGuiRecentScenarios() override;

      virtual DtVrfGuiApplicationSetting* clone() const override;

      const std::vector<std::string> recentScenarios() const
      {
         return myRecentScenarios;
      }

      int maxSize() const
      {
         return myMaxSize;
      }

      void setMaxSize(int);

      void insertScenario(const std::string&, int pos = -1);
      int removeScenario(const std::string&);

      virtual std::string classType() const override;

   protected:
      friend class boost::serialization::access;

      virtual void write(boost::archive::xml_oarchive& out, const unsigned int) override;
      virtual void read(boost::archive::xml_iarchive& in, const unsigned int) override;

   protected:
      std::vector<std::string>   myRecentScenarios;
      unsigned int               myMaxSize;
   };

   class DT_DLL_VRFGUICOMMONQT DtCommonScenarioManager : public QObject, public makVrv::DtVirtualBaseClass
   {
      Q_OBJECT

   public:
      friend class DtSessionStatusBox;

      enum DtJoinSessionTerrainAction
      {
         DtTerrainActionUseSessionTerrain,
         DtTerrainActionChooseAlternateTerrain,
         DtTerrainActionKeepCurrentTerrain,
         DtShowSessionStartupDialog,
         DtLoadScenarioSpecifiedInApplication,
         DtTerrainActionUseSessionTerrainWithoutJoining,
         DtLoadSimulationObjectGroupSpecifiedInApplication,
         DtTerrainActionWaitingToJoin
      };

      enum SessionStatusDialogs
      {
         Loading = 0x00000001,
         Saving = 0x00000002,
         Closing = 0x00000004,
         Importing = 0x00000008,
         CreatingSimulationObjectGroup = 0x00000010,
         Reinitializing = 0x00000020,
         AllStatusDialogs = Loading | Saving | Closing | Importing | CreatingSimulationObjectGroup | Reinitializing
      };

   public:
      static const QEvent::Type LoadScenarioFromDialogEventType = (QEvent::Type)(QEvent::User + 302);
      static const QEvent::Type LoadScenarioFromScenarioInformationEventType = (QEvent::Type)(QEvent::User + 303);

      class LoadScenarioFromScenarioInformationEvent : public QEvent
      {
      public:
         LoadScenarioFromScenarioInformationEvent(const DtScenarioLoadInformation& s);
         LoadScenarioFromScenarioInformationEvent(const LoadScenarioFromScenarioInformationEvent& orig);
         virtual ~LoadScenarioFromScenarioInformationEvent() override;
         DtScenarioLoadInformation myInformation;
      };

      class LoadScenarioFromDialogEvent : public QEvent
      {
      public:
         LoadScenarioFromDialogEvent(const DtString& s, bool useDefault);
         virtual ~LoadScenarioFromDialogEvent() override;

         DtString myScenario;
         bool myUseDefault;
      };

   public:
      DtCommonScenarioManager(makVrv::DtDe&);
      virtual ~DtCommonScenarioManager() override;

      static DtCommonScenarioManager& instance(makVrv::DtDe& de);

      static void init(makVrv::DtDe&);

      const DtScenarioExplorer* scenarioExplorer() const
      {
         return myExplorer;
      }

      const std::vector<DtEntityMapperKey>& controlObjects() const
      {
         return myControlObjectTypes;
      }

      bool loadingSessionTerrain() const
      {
         return myLoadingSessionTerrain;
      }

      bool simulationObjectGroupEditingMode() const
      {
         return mySimulationObjectGroupEditingMode;
      }

      virtual void addControlObject(const DtEntityMapperKey& key);
      virtual void removeControlObject(const DtEntityMapperKey& key);
      virtual void clearControlObjects();

      virtual bool isControlObject(const DtEntityMapperKey& key) const;

      virtual bool wantsToSaveTerrain(bool& ignoredModifications);

      virtual bool saveGuiTerrain(bool askForName = false);

      virtual bool saveSimTerrain(bool askForName = false);

      bool importingScenario() const { return myImportingScenario; };

      virtual bool generateNavigationArea(makVrv::DtUniqueID);

      virtual bool regenerateNavigationAreas(bool);

      virtual DtFilename loadingScenarioFile() const;

      virtual void goToAerodrome(const std::string&);

      virtual std::string language() const;

      virtual void loadScenarioFromSessionDialog(QWidget*);

      virtual void closeScenario(bool resetScenario = true, const DtFilename& databaseToOpen = "", bool forceCloseAll = false);
      virtual bool loadScenario(std::string, DtVrfScenarioRemapFunction* remapping = 0);
      virtual bool loadScenario(const DtScenarioLoadInformation& s);
      virtual bool importScenario(const DtScenarioLoadInformation& s);
      virtual void runScenario();
      virtual void pauseScenario();
      virtual void postSaveLoadFromSession(QWidget* p);

      virtual bool rewindScenario(double toSimTime = -1);


      virtual void setCreateMenuBuilderFlags(int);
      virtual int createMenuBuilderFlags() const;

      virtual void loadBatchScenario(QWidget* p);

      virtual void tickedLoadScenario(const DtString& scenario = "", bool useDefaultRemappingFunction = false);


      virtual void setHelpFile(const std::string&, bool save = false);
      virtual std::string helpFile() const;


      virtual void setDefaultScenarioFile(const std::string& f, bool save = false);
      virtual std::string defaultScenarioFile() const;


      virtual void setSimulationObjectGroupTerrain(const std::string& f, bool save = false);
      virtual std::string simulationObjectGroupTerrain() const;


      virtual void setDefaultSimulationModelSetFile(const std::string& f, bool save = false);
      virtual std::string defaultSimulationModelSetFile() const;

      virtual void rebuildCreateMenu(bool recreate = true);

      virtual void reloadVisuals();

      virtual DtString scenarioSaveExtension(bool includesDot = true) const;

      virtual void recreateCreateMenu();

      virtual void cleanupBackupFile(double simTime) const;

      virtual void loadTaskMenu(const DtScenarioExplorer& explorer);

      virtual void loadUnifiedControlToolbar(const DtScenarioExplorer& explorer);

      virtual void loadSetMenu(const DtScenarioExplorer& explorer);

      virtual void removeSimulationObjectGroupTasksSets(const DtScenarioExplorer& explorer);

      virtual DtFilename saveScenarioName(bool askIfDoesNotExist = true, bool* asked = 0, bool createDefaultIfEmpty = false,
         bool useScenarioNameAsSeed = true) const;

      const DtSimulationObjectCategoryInformation& tags() const
      {
         return mySimulationObjectsCategoryInformation;
      }

      DtSimulationObjectCategoryInformation& tags()
      {
         return mySimulationObjectsCategoryInformation;
      }

      virtual void setupWindowTitleBasedOnScenario();

      virtual makArchives::DtObserverStateRecordsList scenarioObserverViews() const;
      virtual void setScenarioObserverViews(const makArchives::DtObserverStateRecordsList&) const;

      virtual void newScenario(const std::string&, const std::string& sms = "");

      virtual bool joinSession(DtJoinSessionTerrainAction terrainAction = DtTerrainActionUseSessionTerrain);

      virtual void resignSession(bool closeTerrain = true);

      virtual bool saveScenarioAs();

      virtual int saveScenario();

      virtual bool canRewind() const;

      void setValidateForVrfObjects(bool b)
      {
         myValidateForVrfObjects = b;
      }

      bool validateForVrfObjects() const
      {
         return myValidateForVrfObjects;
      }

      virtual void setScenarioDirty(bool b);

      void setReadyToQuit(bool b)
      {
         myReadyToQuit = b;
      }

      bool scenarioDirty() const
      {
         return myScenarioDirty;
      }

      const DtScenario* scenario() const
      {
         return myScenario;
      }

      void setAskSaveIfScenarioModified(bool b)
      {
         myAskSaveIfScenarioModified = b;
      }

      bool askSaveIfScenarioModified() const
      {
         return myAskSaveIfScenarioModified;
      }

      bool joinedToSession() const
      {
         return myJoinedToSession;
      }

      void setDisplayExistingGdbWarningMessages(bool b)
      {
         myDisplayExistingGdbWarningMessage = b;
      }

      bool displatExistingGdbWarningMessages() const
      {
         return myDisplayExistingGdbWarningMessage;
      }

      virtual void setCorrelated(bool);

      bool correlated() const
      {
         return myCorrelated;
      }

      DtVrfMenu* createMenu()
      {
         return myMenu;
      }

      bool initialized() const
      {
         return myInitialized;
      }

      const DtDeadReckoningSettings& deadReckoningSettings() const
      {
         return myDeadReckoningSettings;
      }

      void setAllowEditingOnScenarioJoin(bool b)
      {
         myAllowEditingOnScenarioJoin = b;
      }

      bool allowEditingOnScenarioJoint() const
      {
         return myAllowEditingOnScenarioJoin;
      }

      virtual std::string currentlyLoadedTerrain() const;

      virtual void processJoinSession(bool startupMessage = false);
      virtual void processGuiEvent(DtEventManagerEventInterface* msg);

      virtual void setFromRecord(const DtVrfScriptedTaskSettingsRecord& rec);
      virtual void loadDefaultScriptedTaskSettings(bool loadOnlyFactorySettings = false);
      virtual void saveScriptedTaskSettingsAsDefaults();
      virtual void getRecord(DtVrfScriptedTaskSettingsRecord& rec) const;

      virtual void getSplitRecord(std::vector<DtVrfScriptedTaskSettingsRecord>& rec,
         std::vector<std::string>& fileNames) {
      };

      virtual void addRecords(DtVrfScriptedTaskSettingsRecord& recs,
         DtVrfScriptedTaskSettingsRecord& combinedRec) {
      };


      virtual bool autoJoinSession() const;
      virtual bool automaticallyOpenSessionDatabaseWithoutJoiningSession() const;
      virtual bool askToJoin() const;
      virtual bool alwaysJoinWithSessionDatabase() const;
      virtual bool zoomToScenarioExtentsOnLoad() const;
      virtual bool alwaysJoinWithOpenDatabase() const;
      virtual bool displaySessionDialogs() const;
      virtual bool displayCorrelationWarningMessages() const;
      virtual void displayCorrelationWarningMessage();

      virtual bool isDefaultObserverView(const std::string&);
      virtual std::string defaultObserverView(bool& is2D) const;
      virtual void setDefaultObserverView(const std::string&);
      virtual void setTerrainViewVisible(const std::string&, bool vis);

      virtual void setHiddenTerrainViews(const std::string&);

      virtual bool terrainViewHidden(const std::string&) const;
      virtual const std::set<std::string>& hiddenTerrainViews() const;
      virtual std::set<std::string>& hiddenTerrainViews();

      virtual bool defaultObserverViewStateRecord(makArchives::DtObserverStateRecord&) const;

      virtual void showObserverView(const std::string& view, int ticksBeforeShow = 0, bool inPreTick = true,
         bool zoomToExtents = false);

      virtual void resetObserverForCommandLineTerrain(int count, bool inPreTick);


      virtual void requestSpotReports();

      virtual void requestStealthCommands();
      const DtStealthCommands& stealthCommands() const
      {
         return myStealthCommands;
      }

      const DtSimulationObjectGroupSaveInformation& simulationObjectGroupSaveInformation() const
      {
         return mySimulationObjectGroupSaveInformation;
      }

      virtual bool isScenarioFile(const DtFilename&, bool exact = false) const;

      virtual void setAsynchLoadBufferTime(double);

      virtual void setSaveScenarioToZipFile(bool);

      virtual void zoomToExtentsFromScenario(const DtScenario&) const;

      virtual void setFavorite(const DtEntityMapperKey&, bool f);

      makVrv::DtRecordSettingsBackupInterface*  scriptedTaskSettingsBackup()
      {
         return myScriptedTaskSettingsBackup;
      }

      void exportSessionSettings(const std::string& fileName);

      void importSessionSettings(const std::string& fileName);

      void exportScriptedTaskSettings(const std::string& fileName);

      void importScriptedTaskSettings(const std::string& fileName);


      virtual void setDoNotShowSessionStartupDialog(bool);
      bool showSessionStartupDialog() const;


      virtual void setUserDefinedSmoothing(bool);
      bool userDefinedSmoothing() const;

      virtual void setWindowTitle(const QString&);

      virtual void setShowSessionStatusDialogs(SessionStatusDialogs);
      SessionStatusDialogs showSessionStatusDialogs() const
      {
         return myShowSessionStatusDialogs;
      }

      virtual void setDenySystemScriptEditing(bool);
      virtual bool denySystemScriptEditing() const;

      virtual void setIndent(int);
      virtual int indent() const;

      virtual void setWarnOnSystemScriptChange(bool);
      virtual bool warnOnSystemScriptChange() const;

      virtual void setMonitorScriptedTaskFrameRates(bool);
      virtual bool monitorScriptedTaskFrameRates() const;

      virtual QString filenameToSaveUnder() const;

      virtual void setAutoSave(bool);
      virtual bool autoSave() const;

      virtual void setShowScenarioDescriptionMessageBox(bool b);
      virtual bool showScenarioDescriptionMessageBox() const;

      virtual void setCheckMissingSimTerrain(bool b);
      virtual bool checkMissingSimTerrain() const;

      virtual const DtSubMenuConfiguration& initialCreateMenuConfiguration() const;
      virtual DtSubMenuConfiguration& initialCreateMenuConfiguration();

      virtual const DtSubMenuConfiguration& initialTaskMenuConfiguration() const;
      virtual DtSubMenuConfiguration& initialTaskMenuConfiguration();

      virtual const makVrv::DtToolbarConfiguration& initialToolbarConfiguration() const;
      virtual makVrv::DtToolbarConfiguration& initialToolbarConfiguration();

      virtual const DtUnifiedControlToolbarConfiguration& unifiedControlToolbarConfiguration() const;
      virtual DtUnifiedControlToolbarConfiguration& unifiedControlToolbarConfiguration();

      virtual const makVrv::DtToolbarConfiguration& scriptModifiedToolbarConfiguration() const;
      virtual makVrv::DtToolbarConfiguration& scriptModifiedToolbarConfiguration();

      virtual const DtSubMenuConfiguration& initialSetMenuConfiguration() const;
      virtual DtSubMenuConfiguration& initialSetMenuConfiguration();

      virtual void addAdditionalSmsFile(const std::string&);
      virtual void removeAdditionalSmsFile(const std::string&);
      virtual void setAdditionalSmsFiles(const std::vector<DtString>&);

      virtual std::vector<std::string> defaultSimulationModelSetFiles() const;

      virtual void setSaveScenarioFilenameToUseOnFirstSave(const DtFilename& f);
      virtual const DtFilename& saveScenarioFilenameToUseOnFirstSave() const;

      bool quitting() const { return myQuitWhenSaved; };

   public:
      virtual void slot_onScenarioModified();

      virtual void addRecentScenario(const std::string&);

      virtual bool askAndSaveScriptsForRewind();

      virtual const DtRwHazardAreaInformation& hazardAreaInformation() const;

      virtual makVrv::DtUnicode hazardAreaAgentTypeFor(const DtEntityType&, const DtString& agentKey) const;

      virtual void setShowLoadErrors(bool);
      virtual bool showLoadErrors() const;

      virtual bool loadTerrain(const std::string& guiTerrainFilename, const std::string& simTerrainFilename = "");

      virtual bool loadSimTerrain(const std::string& simTerrainFilename, bool clearSimTerrain = false);

      virtual void resetTerrain();

      virtual time_t dateAndTimeOfDay() const;

      virtual double simulationTime() const;

      virtual void setShowQuitDialogOnClose(bool, bool saveChanges = true);
      virtual bool showQuitDialogOnClose() const;

      virtual void resetScriptModifiedToolbarConfiguration();

      virtual void setKeepOpenTerrainFromCommandLine(bool);

      virtual void slot_defaultIconListChanged();
      virtual void slot_forcesChanged();

      virtual void setShowDuplicateBackendError(bool);
      bool showDuplicateBackendError() const;

      virtual void cleanupSessionBox();

   protected:
      virtual void checkAndWarnForLoadBalance(const DtString& scheme, const DtString& userData, const QString& title);

      virtual void showDescription();

      virtual bool loadScenarioFromEvent(const DtScenarioLoadInformation& s);

      virtual bool validateScenarioForLoad(const DtScenarioExplorer& scen,
         QString& failure, QString& failureDetails);
         
      virtual int quitApplication(const QString& title, const QString& message, bool& quitBackend, bool hasCancelButton = true);

      virtual time_t initializeEnvironmentDateTimeOfDay(time_t proposedTime);

      virtual void scenarioFilenameChanged();

      virtual void scenarioJustClosed();

      virtual void errorLoadingScenario();

      virtual void scenarioClosing();

      virtual void slot_allBackendsClosed();

      virtual void loadTranslationsForModelSet(DtSimulationModelSet*);

      virtual void slot_sessionStartupComplete();

      virtual void allScenarioObjectsDiscovered();

      virtual void slot_onScenarioLoaded(const DtScenario*, bool emitScenarioLoadedSignal = true, bool isNewScenario = false);

      virtual void slot_checkBackendClosed(const DtVrfBackendState&, int);
      virtual void slot_checkSimulationState(const DtVrfBackendState&, int);

      virtual bool saveIfDirty(int* saved = 0, bool takeSnapshot = true, bool showCheckpointSaveTitle = false, bool quittingApplication = false,
         int* dialogResult = 0);

      virtual DtVrfScenarioRemapFunction* remapFunctionForCommandLineScenarioLoad() const;

      virtual void watchForScenarioObjectsDiscovered();

      virtual void connectSignals(bool);

      virtual void requestHazardAreaInformation();

      virtual void requestOrbatInformation();

      virtual void reloadScenario(const std::string& newTerrain);

      virtual void saveScenario(std::string baseName, std::string newTerrainName);

      virtual void slot_onScenarioSaved(bool checkpointSave = false);

      virtual void reloadSimulationModelSets(const std::vector<DtFilename>&, bool reverse = false);

      virtual void slot_onScenarioReloaded(std::string scenarioName);

      void setup();

      virtual void showSessionStartupDialog();

      virtual void processServerMessage(DtSimMessage*);

      virtual void processStealthCommands(DtSimMessage*);

      virtual void processHazardAreaInformation(DtSimMessage*);

      virtual void restorePreservedScripts();

      virtual void scenarioWasRewound(DtSimMessage*);

      virtual void terrainCleared();

      virtual void clearFrontEndScenariodData();

      virtual void quitAllBackends();

      virtual void checkCloseStatus();

      virtual void setScenarioTerrainReplaced(bool b);

      bool scenarioTerrainReplaced() const
      {
         return myScenarioTerrainReplaced;
      }

   protected:
      virtual void postTickSOGLoad(std::string sogFile);

      virtual void completeScenarioLoad();
      virtual void completeSimulationObjectGroupLoad();

      virtual DtVrfSimBackendManager& backendManager() const;

      virtual void loadIndirectArtilleryManager(const DtScenarioExplorer& explorer);
      virtual void loadForceFiles(const DtScenarioExplorer& explorer);
      virtual void loadCreateMenu(const DtScenarioExplorer& explorer);
      virtual bool loadInitialMenuConfiguration(makVrv::DtMenuConfiguration&, const DtFilename&);
      virtual void loadOverlayFile(const DtScenario&, bool removeAll = true);
      virtual void loadSelectionGroupFile(const DtScenario&);
      virtual void loadObserverViewFile(const DtScenario&, bool andSetDefaultView = true);

      virtual void loadGuiScenarioSettings(const DtScenario&);
      virtual void loadModelSetFiles(const DtScenarioExplorer& explorer);
      virtual void loadVisuals(const DtScenarioExplorer& explorer, bool force = false);

      virtual DtModelSetEntry* modelSetEntry(const DtEntityMapperKey& key) const;
      virtual DtVrfMenu* createMenuFromModelSetManager() const;
      virtual bool isModelSet(const DtFilename& filename) const;

      virtual void slot_onSessionUpdated(int flags);
      virtual void slot_onDuplicateBackendAddress(const DtVrfBackendState&);

      virtual void slot_backendDiscovered(const DtVrfBackendState&);
      virtual void slot_settingReceived(const std::string&, const DtVrfBackendState*);

      virtual void slot_postDeCallback();

      virtual void remapTerrainFilenames(DtScenario*);

      virtual void createTerrainFilenameRemapper();

      virtual bool sessionPrompt(const QString& message);

      virtual bool openTerrainDatabaseFromUserSelection(const std::string& simTerrainFilename = "");

      virtual bool selectReplacementTerrainFromUserSelection(QString& selectedTerrain, const DtString& previousTerrain);

      virtual bool loadSessionTerrain(const std::string& guiTerrainFilename, const std::string& simTerrainFilename = "");

      virtual bool isSameTerrain(const std::string& terrain1, const std::string& terrain2) const;

      virtual void slot_terrainModified();

      virtual void slot_propChanged();

      virtual void slot_deDestructing();

      virtual void slot_terrainToBeCleared();
      virtual void slot_terrainCleared();

      virtual bool checkWriteGdb(const std::string& gdb);

      virtual DtSessionStatusBox* createSessionStatusBox();

      virtual void setupScriptedTaskSettings();

      virtual QFileInfo findTerrainFile(const std::string& terrainFile) const;

      virtual bool blockSessionTerrainLoad() const;

      virtual QFileInfo findTerrainFile(const std::string& terrainFile, const std::vector<std::string>& searchPaths,
         const std::string& extension) const;

      virtual void slot_scenarioAboutToBeSaved(DtScenario*);

      virtual void createSessionStatusBox(const QString& title, const QString& message, int statusType);

      virtual void slot_sessionSettingsChanged();

      virtual void slot_guiSettingsChanged();

      virtual bool eventFilter(QObject*, QEvent*) override;

      virtual void slot_savedSimulationObjectGroup(const std::string&);

      virtual void postSaveQuit();
      virtual void postSaveLoad();
      virtual void postSaveClose(bool resetScenario, DtFilename databaseToOpen, bool forceCloseAll);
      virtual void postSaveImport(DtScenarioLoadInformation);
      virtual void postSaveRewind(bool preserveScripts, double simTime);

      virtual void nullSaveFunction();

      virtual void backendDiscoveryTick();

      virtual void addAdditionalCategories();

   protected slots:
      virtual void commFileMessagesReceived(const QStringList&);
      virtual void statusDialogDestroyed();

   protected:
      makVrv::DtDe&              myDe;
      DtScenario*                myScenario;
      DtVrfMenu*                 myMenu;
      DtScenarioExplorer*        myExplorer;
      QDialog*                   mySessionStatusMessageBox;
      std::vector<DtEntityMapperKey> myControlObjectTypes;
      bool                       myRewinding;
      bool                       myValidateForVrfObjects;
      bool                       myScenarioDirty;
      bool                       myScenarioTerrainReplaced;
      bool                       myAskSaveIfScenarioModified;
      bool                       myAutoJoinSession;
      bool                       myReadyToQuit;
      bool                       myJoinedToSession;
      bool                       mySessionDatabaseOpenAndNotJoined;
      bool                       myCorrelationWarned;
      std::string                myLoadedTerrain;
      std::string                myTerrainFile;
      std::string                mySimTerrainFile;
      bool                       myCorrelated;
      bool                       myDisplayExistingGdbWarningMessage;
      bool                       myTerrainClearing;
      DtScenarioLoadInformation  myLoadingScenario;
      bool                       myClosingScenario;
      bool                       myCanSimulate;
      bool                       myInitialized;
      bool                       myIsStartup;
      bool                       myAutoSave;
      bool                       myAllowEditingOnScenarioJoin;
      bool                       myInTheScenarioLoadProcess;
      bool                       myShowLoadErrors;
      bool                       myScenarioManagerInitialized;
      DtVrfScenarioRemapFunction* myRemapFunctionForCommandLineScenarioLoad;

      DtVrfScriptedTaskSettingsRecord       myScriptedTaskSettings;
      DtDeadReckoningSettings    myDeadReckoningSettings;
      makVrv::DtRecordSettingsBackupInterface*  myScriptedTaskSettingsBackup;
      DtSessionStatusBox* mySessionStatusBox;
      SessionStatusDialogs myShowSessionStatusDialogs;

      DtSubMenuConfiguration* myInitialCreateMenuConfiguration;
      DtSubMenuConfiguration* myInitialTaskMenuConfiguration;
      DtSubMenuConfiguration* myInitialSetMenuConfiguration;
      int myCreateMenuBuilderFlags;
      makVrv::DtToolbarConfiguration myInitialToolbarConfiguration;
      makVrv::DtToolbarConfiguration myScriptModifiedToolbarConfiguration;
      DtUnifiedControlToolbarConfiguration* myUnifiedControlToolbarConfiguration;

      DtTerrainFilenameRemapper* myTerrainFilenameRemapper;

      std::vector<DtString> myAdditionalSmsFiles;
      bool myHasShowSetup;
      bool myLateJoinerInit;
      int myQuitWhenSaved;

      DtRwHazardAreaInformation myHazardAreaInformation;
      makVrv::DtSignalConnectionManager mySOGConnections;
      makVrv::DtSignalConnectionManager myResetCommandLineTerrainSignals;

      QString myWindowTitle;

      std::map<std::string, QTranslator*> myTranslators;

      makVrv::DtSignalConnectionManager myConnectionManager;

      mutable DtVrfSimBackendManager* myBackendManager;
      DtStealthCommands myStealthCommands;
      bool myLoadedUserTerrain;
      bool myLoadingSessionTerrain;
      bool myKeepOpenTerrainFromCommandLine;
      int mySaveFlags;
      DtVrfObjectManipulationManager::AllowEditingOf myAllowEditingOfOnSessionJoin;
      DtSimulationObjectCategoryInformation mySimulationObjectsCategoryInformation;
      boost::function<void ()> myPostSaveFunction;

      bool myWaitingOnScenarioClose;
      DtScenarioLoadInformation* myPendingScenarioInformation;

      DtFilename mySaveScenarioFilenameToUseOnFirstSave;

      DtFileCommChannel* myFileCommChannel;
      bool mySimulationObjectGroupEditingMode;
      DtSimulationObjectGroupSaveInformation mySimulationObjectGroupSaveInformation;

      double myAsynchTimeoutWait;
      DtTimedSection myAsynchTimeoutSection;

      DtVrfScenarioRemapFunction* myDefaultRemapFunction;

      bool myImportingScenario;
      bool myFirstRun;

      DtTimedSection myBackendDiscoveryTimer;
      DtTimedSection myBackendClosingResponseTimer;
      double myTimeWaitingForBackendResponse;
      double myBackendDiscoveryTime;
      DtFilename myClosingDatabaseToOpen;
      int myCloseRetryCount;
      bool myForceCloseAll;
      bool mySimTerrainLoaded;
      bool myShowDuplicateBackendError;
      bool myRestoreObserverViewsOnObjectsDiscovered = false;

      boost::signals2::connection myPostDeTickConnection;
      boost::signals2::connection myCloseScenarioTickConnection;
   };

   class DT_DLL_VRFGUICOMMONQT DtSessionStatusBox : public QDialog
   {
      Q_OBJECT
   public:
      enum Status
      {
         None = 0x00000000,
         Loading = 0x00000001,
         Saving = 0x00000002,
         Closing = 0x00000004,
         Importing = 0x00000008,
         CreatingSimulationObjectGroup = 0x00000010,
         Reinitializing = 0x00000020
      };

      DtSessionStatusBox(makVrv::DtDe& de, DtCommonScenarioManager* manager, QWidget* parent);
      virtual ~DtSessionStatusBox() override;

      virtual void setMessage(const QString& message);

      virtual void keyPressEvent(QKeyEvent* e) override;

      virtual void terrainGeometryLoaded();

      virtual void waitingForTerrainLoad();

      virtual void setStatus(Status s);

      Status status() const
      {
         return myStatus;
      }

      virtual void accept() override;

      virtual void reject() override;

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

      virtual void resetAltKey();

   protected:
      DtCommonScenarioManager* myParent;
      Status myStatus;
      QLabel* myLabel;
      QPushButton* myCloseButton;
      makVrv::DtSignalConnectionManager mySignals;
      makVrv::DtDe& myDe;
      bool myWaitingForTerrainLoad;
      bool myTerrainLoadIsClose;
   };
}

BOOST_CLASS_VERSION(makVrf::DtVrfGuiRecentScenarios, 1)