DtVrfSimBackEndManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2009 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: DtVrfSimBackEndManager.h,v $ $Revision: 1.2 $ $State: Exp $
*******************************************************************************/



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/DtVrfBackendState.h>
#include <vrfGuiCore/DtQueuedManager.h>

#include <vrvCore/DtSimData.h>
#include <vrvCore/DtDe.h>

#include <boost/function.hpp>
#include <boost/signal.hpp>

class DtBackend;
class DtSimulationAddress;
class DtSimMessage;
class DtIfLoadComplete;
class DtIfSaveComplete;

namespace makVrv
{
   class DtBaseSimulation;
}

const int DtSessionChangedTerrain   = 0x00000001;
const int DtSessionChangedScenario  = 0x00000002;
const int DtSessionChangedNumberBEs = 0x00000004;
const int DtSessionScenarioJustLoaded = 0x00000008;

namespace makVrf
{
   class DtVrfBackEndState;

   class DT_DLL_VRFGUICORE DtVrfSimBackendManager : public DtQueuedManager
   {
   public:
      typedef std::map<std::string, DtVrfBackendState*> DtVrfSimBackendStates;

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

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

   public:
      virtual bool backEndsPresent() const;

      virtual bool anyBackendsLoaded() const;

      virtual bool allBackendsLoaded() const;

      virtual bool backendLoaded(const DtSimulationAddress&) const;

      virtual bool backendSaving(const DtSimulationAddress&) const;

      virtual bool anyBackendsPlaying() const;

      virtual bool anyBackendsInControlState(int state) const;

      virtual bool allBackendsCanSimulate() const;

      virtual bool backendCanSimulate(const DtSimulationAddress&) const;

      virtual void duplicateBackendDiscovered(const DtSimulationAddress&);


      virtual void removeAllBackends();
      virtual void addBackend(const DtBackend*);
      virtual void backendRemoved(const DtSimulationAddress&);
      virtual void backendUpdated(const DtSimulationAddress&, const DtBackend*);

      DtVrfBackendState* stateFor(const DtSimulationAddress&) const;

      const DtSimulationAddress& selectedBackend() const
      {
         return mySelectedBackend;
      }

      void setSelectedBackend(const DtSimulationAddress&);

      virtual int numberOfBackends() const;

      virtual void clearSelectedBackend();

      virtual double simTime() const;

      virtual double simStartSimTime() const;

      const DtVrfSimBackendStates& backendStates() const
      {
         return myBackendStates;
      }

   public:
      virtual void signalWhenAllBackendsClosed();

      virtual void signalIfAllBackendsClosed();
      boost::signal<void ()> signal_allBackendsClosed;

      virtual void signalWhenAllBackendsLoaded();

      virtual void signalIfAllBackendsLoaded();
      boost::signal<void ()> signal_allBackendsLoaded;

      virtual void signalWhenAllBackendsSaved();

      virtual void signalIfAllBackendsSaved();
      boost::signal<void ()> signal_allBackendsSaved;

      const std::string& sessionScenario() const
      {
         return mySessionScenarioName;
      }

      const std::string& sessionTerrain() const
      {
         return mySessionTerrainName;
      }

   public:
      boost::signal<void (const DtVrfBackendState&)> signal_frameRatesUpdated;
      boost::signal<void (const DtVrfBackendState&)> signal_backendDiscovered;
      boost::signal<void (const DtVrfBackendState&)> signal_backendRemoved;
      boost::signal<void (const DtVrfBackendState&, int)> signal_backendUpdated;
      boost::signal<void (int)> signal_sessionUpdated;
      boost::signal<void (const DtVrfBackendState&)> signal_duplicateSimulationAddress;
      boost::signal<void (const DtSimulationAddress& old, const DtSimulationAddress& newaddr)> signal_selectedBackendChanged;
      boost::signal<void ()> signal_allBackendsAboutToBeRemoved;

   protected:
      virtual void slot_frameRatesUpdated(const DtVrfBackendState&);
      virtual void simulationBackendRemoved(DtVrfBackendState*);
      virtual void simulationBackendDiscovered(DtVrfBackendState*);
      virtual void simulationBackendUpdated(DtSimulationAddress, int);
      virtual void duplicateSimulationBackendDiscovered(DtSimulationAddress);

      virtual void processLoadCompleteCallback(DtSimMessage*);
      virtual void processSaveCompleteCallback(DtSimMessage*);

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

      virtual void setBackendSaving(const DtSimulationAddress&, bool b);

      virtual void updateSessionInformation(int sessionFlags = 0);

   protected:
      makVrv::DtBaseSimulation*   mySimulation;
      DtVrfSimBackendStates      myBackendStates;
      DtSimulationAddress        mySelectedBackend;
      bool                       mySignalWhenAllBackendsClosed;
      bool                       mySignalWhenAllBackendsLoaded;
      bool                       mySignalWhenAllBackendsSaved;
      std::map<std::string, char> myBackendsWaitingForSave;
      std::map<std::string, bool> myAlreadyDuplicateWarned;
      std::map<std::string, bool> myNeedToLoad;
      std::vector<std::string>   myNeedToSave;

      std::string                mySessionTerrainName;
      std::string                mySessionScenarioName;

      std::map<std::string, bool> myJustLoadedMap;
   };
}