vrfScenarioManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCoreQt/vrfGuiCoreQt.h>

#include <vrfGuiCore/vrfGuiApplicationSettings.h>
#include <vrfGuiCoreQt/vrfSimulationObjectGroupHandler.h>
#include <vrfGuiCore/menu.h>
#include <vrfGuiCore/entityMapperKey.h>
#include <vrfGuiCore/vrfObjectManipulationManager.h>
#include <vrfGuiCore/vrfScriptedTaskSettingsRecord.h>
#include <vrvCore/DtMenuConfiguration.h>
#include <vrvCore/DtUniqueID.h>
#include <vrfGuiCore/createMenuBuilder.h>
#include <makArchives/DtObserverStateRecordsList.h>
#include <vrfutil/simulationObjectCategoryInformation.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/signalslib.h>
#include <vrvCore/DtDe.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>

#include <boost/signal.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 QWidget;
class QDialog;
class DtSimMessage;
class DtIfServerMessage;
class DtModelSetEntry;
class QTranslator;
class DtSimulationModelSet;
class DtTerrainFilenameRemapper;

namespace makArchives
{
   class DtTerrainOperationRecord;
   class DtTerrainRecord;
}

namespace makVrv
{
   class DtRecordSettingsBackupInterface;
}

#define DtFavoritesTopLevelIconRank 99999
#define DtRecentTopLevelIconRank 99998

namespace makVrf
{
   class DtFileCommChannel;
   class DtVrfScenarioRemapFunction;
   class DtVrfSimBackendManager;
   class DtVrfBackendState;
   class DtJoinSessionDialog;
   class DtHostilityMatrixDialog;
   class DtLoadScenarioDialog;
   class DtNeverAskAgainMessageBox;
   class DtScenarioSettingsDialog;
   class DtSessionStatusBox;
   class DtSessionStartupDialog;
   class DtScenarioDescriptionDialog;
   class DtSubMenuConfiguration;
   class DtVrfModelSetManager;

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

      virtual ~DtVrfGuiRecentScenarios();

      virtual DtVrfGuiApplicationSetting* clone() const;

      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;

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

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

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

   class DT_DLL_VRFGUICOREQT DtVrfScenarioManager : public QObject, public makVrv::DtVirtualBaseClass
   {
      Q_OBJECT

   public:
      friend class DtSessionStatusBox;

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

      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();
         DtScenarioLoadInformation myInformation;
      };

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

         DtString myScenario;
         bool myUseDefault;
      };

   public:
      DtVrfScenarioManager(makVrv::DtDe&);
      virtual ~DtVrfScenarioManager();

      static DtVrfScenarioManager& 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 bool mapUUIDToScenarioDataFromOobInScenario(const DtFilename& scenarioFile,
               DtScenario::ScenarioDataMap& scenarioDataMap) const;

      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 bool rewindScenario(double toSimTime = -1);

      virtual void setCreateMenuBuilderFlags(DtCreateMenuBuilder::Flags);
      virtual DtCreateMenuBuilder::Flags createMenuBuilderFlags() const;

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

      virtual void tickedNewScenario();

      virtual void loadScenarioFromDialog(QWidget* p);
      virtual DtLoadScenarioDialog* createLoadScenarioDialog(QWidget*);
      virtual void importScenarioFromDialog(QWidget* p);

      virtual void loadScenarioFromSessionDialog(QWidget* p);

      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 std::string language() const;

      virtual void loadTaskMenu(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 DtScenarioSettingsDialog* createNewScenarioDialog(QWidget* p);
      virtual void newScenarioFromDialog(QWidget* p);

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

      virtual void loadBatchScenario(QWidget*);

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

      DtMenu* 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 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 setAggregateOnCreate(bool);
      bool aggregateOnCreate() 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 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 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 editHostilityMatrix(QWidget* parent);

      virtual DtHostilityMatrixDialog* createHostilityMatrixDialog(
         QWidget* p, const Qt::WindowFlags& flags) const;

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

   public:

      boost::signal<void ()> signal_forcesChanged;
      boost::signal<void ()> signal_waitingForScenarioObjectsToBeDiscovered;
      boost::signal<void ()> signal_defaultIconListChanged;
      boost::signal<void ()> signal_observerViewSetFromScenario;
      boost::signal<void (const std::set<std::string>&)> signal_terrainViewsHidden;
      boost::signal<void (const DtScenario&)> signal_scenarioInitialized;
      boost::signal<void (DtSessionStartupDialog*)> signal_sessionDialogBoxAboutToShow;
      boost::signal<void (bool)> signal_requestingSaveOnScenarioModified;
      boost::signal<void (DtSessionStatusBox*)> signal_sessionStatusDialogCreated;
      boost::signal<void ()> signal_allScenarioObjectsDiscovered;
      boost::signal<void ()> signal_scenarioRewound;
      boost::signal<void ()> signal_scenarioReinitialized;
      boost::signal<void ()> signal_setMenuConfigurationLoaded;
      boost::signal<void ()> signal_taskMenuConfigurationLoaded;
      boost::signal<void ()> signal_createMenuConfigurationLoaded;
      boost::signal<void (const std::string&)> signal_scenarioLoadError;
      boost::signal<void (const std::string&)> signal_scenarioSaveError;
      boost::signal<void (DtSessionStartupDialog*)> signal_sessionStartupBoxCreated;
      boost::signal<void (DtHostilityMatrixDialog*)> signal_hostilityMatrixDialogCreated;
      boost::signal<void (const DtDeadReckoningSettings&)> signal_deadReckoningSettingsChanged;
      boost::signal<void (const DtScenarioExplorer&)> signal_scenarioLoaded;
      boost::signal<void (bool)> signal_sessionStatusChanged;
      boost::signal<void ()> signal_allBackendsClosed;
      boost::signal<void ()> signal_rewinding;
      boost::signal<void ()> signal_rewindMessageSent;
      boost::signal<void ()> signal_scenarioManagerInitialized;

      boost::signal<void (std::string, std::string)> signal_defaultObserverViewChanged;

      boost::signal<void (const DtScenarioLoadInformation&)> signal_preLoadScenario;

      boost::signal<void (const DtScenarioLoadInformation&)> signal_scenarioLoadRequest;

      boost::signal<void (const DtScenarioLoadInformation&)> signal_postLoadScenario;

      boost::signal<void (const std::string&)> signal_preLoadBaseTerrain;

      boost::signal<void (const std::string&)> signal_preLoadSimTerrain;

      boost::signal<void (const std::string&)> signal_preLoadTerrain;

      boost::signal<void (const std::string&)> signal_postLoadTerrain;

      boost::signal<void (const std::string&)> signal_postLoadSimTerrain;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadForceFiles;

      boost::signal<void (const DtScenarioExplorer&)> signal_postLoadForceFiles;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadArtilleryManager;

      boost::signal<void (const DtScenarioExplorer&)> signal_postLoadArtilleryManager;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadModelSetFiles;

      boost::signal<void (const DtScenarioExplorer&)> signal_postLoadModelSetFiles;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadVisuals;

      boost::signal<void (const DtScenarioExplorer&)> signal_postLoadVisuals;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadCreateMenu;

      boost::signal<void (const DtScenarioExplorer&, DtMenu*)> signal_postLoadCreateMenu;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadTaskMenu;

      boost::signal<void (const DtFilename&)> signal_modelSetLoaded;

      boost::signal<void (const DtScenarioExplorer&)> signal_postLoadTaskMenu;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadSimulationObjectGroupRemovalFile;

      boost::signal<void (const DtScenarioExplorer&)> signal_postLoadSimulationObjectGroupRemovalFile;

      boost::signal<void (const DtScenarioExplorer&)> signal_preLoadSetMenu;

      boost::signal<void (const DtScenarioExplorer&)> signal_postLoadSetMenu;

      boost::signal<void (const DtScenario&)> signal_preLoadOverlayFile;

      boost::signal<void (const DtScenario&)> signal_postLoadOverlayFile;

      boost::signal<void (const DtScenario&)> signal_preLoadSelectionGroupFile;

      boost::signal<void (const DtScenario&)> signal_postLoadSelectionGroupFile;

      boost::signal<void (const DtScenario&)> signal_preLoadObserverViewsFile;

      boost::signal<void (const DtScenario&)> signal_postLoadObserverViewsFile;

      boost::signal<void (const DtScenarioExplorer&)> signal_createMenuLoaded;

      boost::signal<void ()> signal_recreateCreateMenu;

      boost::signal<void ()> signal_recreateTaskMenu;

      boost::signal<void ()> signal_recreateSetMenu;

      boost::signal<void (const DtVrfScriptedTaskSettingsRecord&)> signal_scriptedTaskSettingsChanged;

      boost::signal<void (DtVrfGuiRecentScenarios*)> signal_recentScenariosChanged;

      boost::signal<void (const DtScenario&)> signal_preLoadGuiScenarioSettings;

      boost::signal<void (const DtScenario&)> signal_postLoadGuiScenarioSettings;

      boost::signal<void ()> signal_scenarioClosed;

      boost::signal<void ()> signal_scenarioClosing;

      boost::signal<void ()> signal_scenarioJustLoaded;

      boost::signal<void (QString&)> signal_windowTitleAboutToBeSet;

      boost::signal<void (QString)> signal_windowTitleSet;

      boost::signal<void (const DtRwHazardAreaInformation&)> signal_hazardAreaInformationReceived;

      boost::signal<void ()> signal_unspecifiedScenarioLoadingError;

      boost::signal<void (const std::string&)> signal_scenarioFilenameChanged;

   protected:
      virtual bool loadScenarioFromEvent(const DtScenarioLoadInformation& s);
         
      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 cleanupSessionBox();

      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 DtJoinSessionDialog* createJoinSessionDialog(QWidget* parent, const Qt::WindowFlags& flags);

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

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

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

      virtual void postSaveLoadFromSession(QWidget*);
      virtual void postSaveLoadFromDialog(QWidget*);
      virtual void postSaveNew(QWidget*);
      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;
      DtMenu*                    myMenu;
      DtScenarioExplorer*        myExplorer;
      QDialog*                   mySessionStatusMessageBox;
      std::vector<DtEntityMapperKey> myControlObjectTypes;
      bool                       myRewinding;
      bool                       myValidateForVrfObjects;
      bool                       myScenarioDirty;
      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;
      DtVrfScenarioRemapFunction* myRemapFunctionForCommandLineScenarioLoad;

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

      DtSubMenuConfiguration* myInitialCreateMenuConfiguration;
      DtSubMenuConfiguration* myInitialTaskMenuConfiguration;
      DtSubMenuConfiguration* myInitialSetMenuConfiguration;
      DtCreateMenuBuilder::Flags myCreateMenuBuilderFlags;
      makVrv::DtToolbarConfiguration myInitialToolbarConfiguration;
      makVrv::DtToolbarConfiguration myScriptModifiedToolbarConfiguration;

      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;

      boost::signalslib::connection myPostDeTickConnection;
      boost::signalslib::connection myCloseScenarioTickConnection;
   };

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

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

      virtual void setMessage(const QString& message);

      virtual void keyPressEvent(QKeyEvent *e);

      virtual void terrainGeometryLoaded();

      virtual void waitingForTerrainLoad();

      virtual void setStatus(Status s);

      Status status() const
      {
         return myStatus;
      }

      virtual void accept();

      virtual void reject();

      boost::signal<void ()> signal_closeScenario;

      virtual void resetAltKey();

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

BOOST_CLASS_VERSION(makVrf::DtVrfGuiRecentScenarios, 1)