vrfScriptedTaskManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfutil/vrfScriptedTasksConstants.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/signalslib.h>
#include <vrvCore/DtUniqueID.h>
#include <vrfutil/scriptedTaskMetaData.h>
#include <vrvCore/DtDe.h>
#include <vlpi/simulationAddress.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <boost/function.hpp>

class DtSimMessage;

class QWidget;

namespace makVrf
{
   class DtVrfBackendState;

   class DT_DLL_VRFGUICORE DtVrfScriptedTaskManager : public makVrv::DtVirtualBaseClass
   {
   public:
      typedef std::map<int, makVrv::DtUnicode> ScriptedTaskTypeNames;
      typedef std::map<bool, std::string> IconType;
      typedef std::map<int, std::string> DoctrinesByForce;

      struct ScriptedTaskDialogInformation
      {
         makVrv::DtUnicode name;
         IconType icon;
      };

      typedef std::map<int, ScriptedTaskDialogInformation> ScriptedTaskTypeInformation;

      struct ScenarioSystemPair
      {
         ScenarioSystemPair() : scenarioScript(0), systemScript(0) {};
         ScenarioSystemPair(DtScriptedTaskMetaData* sc, DtScriptedTaskMetaData* sy) : scenarioScript(sc), systemScript(sy) {};

         DtScriptedTaskMetaData* scenarioScript;
         DtScriptedTaskMetaData* systemScript;
         std::string scriptError;                
         bool modified;
      };

      typedef std::map<std::string, ScenarioSystemPair> ScriptedTasks;
      typedef std::pair<std::string, bool> ActionCategory;
      typedef std::set<std::string> Doctrines;
      typedef std::map<std::string, ActionCategory> ActionCategories;

      struct PreservedScript
      {
         DtScriptedTaskMetaData scriptedTask;
         std::string scriptError;
      };

      typedef std::map<std::string, PreservedScript> PreservedScripts;

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

      static DtVrfScriptedTaskManager& instance(makVrv::DtDe& de);
      static void registerInstance(makVrv::DtDe&, DtVrfScriptedTaskManager*);

      virtual void clear(bool andSetting = true, bool reset = true, bool signal = true);

      virtual void removeScriptedTaskMetaData(const std::string& scriptedTaskId, bool signal = true);

      virtual DtScriptedTaskMetaData scriptedTaskMetaData(const std::string& scriptId, bool system) const;

      virtual DtScriptedTaskMetaData scriptedTaskMetaData(const std::string& scriptId) const;

      virtual void addScriptedTaskMetaDataToScenario(const DtScriptedTaskMetaData&, bool addScript = false);

      virtual void duplicateScriptedTaskMetaDataToScenario(const DtScriptedTaskMetaData&, const std::string& sourceId);

      virtual void updateScriptedTaskMetaDataToScenario(const DtScriptedTaskMetaData&, const std::string& originalId = "");

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

      virtual void addScriptedTaskMetaData(const DtScriptedTaskMetaData&, bool signal = true);

      virtual void requestScriptedTasks();

      virtual bool isSystemScript(const std::string&) const;

      virtual bool appearsOnMenu(const std::string&) const;

      virtual bool appearsOnToolbar(const std::string&) const;

      virtual bool systemScriptAvailable(const std::string&) const;

      virtual void setSystemScriptAvailable(const std::string& id, bool);

      virtual void removeSystemScript(const std::string& id, bool signal = true);

      virtual const ScriptedTasks& scriptedTaskMetaData() const;
      
      virtual bool hasScriptedTaskMetaData(const std::string&) const;
      virtual bool hasScenarioScriptedTaskMetaData(const std::string&) const;
      virtual bool hasSystemScriptedTaskMetaData(const std::string&) const;

      virtual bool hasDoctrine(const std::string&) const;

      virtual std::string uniqueScriptIdFrom(const std::string&,
         std::set<std::string> additionalToCheck = std::set<std::string>()) const;

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

      virtual void assignScriptError(const std::string& scriptId, const std::string& error);

      virtual void clearScriptError(const std::string& scriptId);

      virtual bool scriptHasError(const std::string& scriptId, std::string* error = 0) const;

      virtual bool scriptIsModified(const std::string& scriptId) const;

      virtual void setScriptModified(const std::string& scriptId, bool);

      virtual void clearModifiedScripts();

      virtual void setScript(const std::string& scriptId, const std::string& script, bool setAsModified = true);

      virtual bool hasModifiedScripts() const;

      virtual void preserveModifiedScripts();

      virtual void restorePreservedScripts();

      virtual int mapScriptToAction(const DtScriptedTaskMetaData& script, bool addIfMissing = true);

      virtual void unmapScript(const DtScriptedTaskMetaData&);

      virtual void setMonitorFrameRates(const std::string& scriptId, bool monitor);

      virtual const ActionCategories& actionCategories() const;

      virtual const Doctrines& doctrines() const;

      virtual void requestScriptsIfNeeded();

      virtual void addScriptedTaskType(int, const makVrv::DtUnicode& name);
      virtual void addScriptedTaskTypeIcon(int, bool isSystemIcon, const std::string&);
      virtual makVrv::DtUnicode getScriptedTaskTypeName(int) const;
      virtual std::string getScriptedTaskTypeIcon(int, bool isSystemScrript) const;
      virtual ScriptedTaskTypeNames getScriptedTaskTypes() const;
      virtual void removeScriptedTaskType(int);

      virtual std::vector<std::string> scriptedTasksValidFor(const DtEntityType&, int force = -1) const;

      virtual std::vector<std::string> scriptedSetsValidFor(const DtEntityType&, int force = -1) const;

      virtual std::vector<std::string> reactiveTasksValidFor(const DtEntityType&, int force = -1) const;

      virtual std::vector<std::string> backgroundProcessesValidFor(const DtEntityType&, int force = -1) const;

      virtual std::vector<std::string> scriptedTasksValidFor(makVrv::DtUniqueID) const;

      virtual std::vector<std::string> reactiveTasksValidFor(makVrv::DtUniqueID) const;

      virtual std::vector<std::string> backgroundProcessesValidFor(makVrv::DtUniqueID) const;
      
      virtual std::vector<std::string> scriptsValidFor(const DtEntityType&, int scriptType, int force = -1) const;

      virtual std::vector<std::string> scriptsThatSupportDoctrine(const std::string&) const;

      virtual int scriptedTaskTypeFor(const makVrv::DtUnicode&) const;

      virtual std::string formatScript(const std::string& script, int scriptType, const std::string& commentBlock) const;

      const DoctrinesByForce& doctrinesByForce() const
      {
         return myDoctrinesByForce;
      }

      virtual const std::set<DtString>& scriptedTasksToShowOnTopLevelRightClickMenu() const;

      virtual std::string doctrineForForce(int) const;

      virtual void setResponseTimeout(int);
      virtual int responseTimeout() const;

   protected:
      virtual std::string language() const;

      virtual void receiveScriptedTaskList(DtSimMessage* msg);

      virtual void receiveActionCategories(DtSimMessage* msg);

      virtual void receiveDoctrines(DtSimMessage* msg);

      virtual void processDoctrinesOperation(DtSimMessage* msg);

      virtual void receivedScriptedTaskUpdateMessage(DtSimMessage* msg);

      virtual void slot_backendRemoved(const DtVrfBackendState&);

   public:
      boost::signal<void ()> signal_scriptedTaskManagerAboutToChange;
      boost::signal<void ()> signal_aboutToClearScriptedTasks;
      boost::signal<void (std::string)> signal_scriptedTaskAboutToBeRemoved;
      boost::signal<void (std::string)> signal_scriptedTaskAdded;
      boost::signal<void ()> signal_receivedScriptedTasks;
      boost::signal<void (int)> signal_scriptedTaskTypeAdded;
      boost::signal<void (int)> signal_scriptedTaskTypeRemoved;
      boost::signal<void ()> signal_doctrinesReceived;

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

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

      boost::signal<void ()> signal_scriptModifiedCleared;

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

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

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

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

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

   protected:
      virtual void responseTick();

      virtual void addToCreatorFactory(const DtScriptedTaskMetaData& md);
      virtual void removeFromFactory(const DtScriptedTaskMetaData& script);

   protected:
      makVrv::DtDe& myDe;
      makVrv::DtSignalConnectionManager myConnectionManager;
      ScriptedTasks myScriptedTasks;
      PreservedScripts myPreservedScripts;

      unsigned int myRequestId;

      typedef std::map<std::string, int> ScriptIdToActionIdMap;
      ScriptIdToActionIdMap myScriptIdToActionIdMap;

      DtSimulationAddress myScriptMonitorAddress;
      std::map<std::string, int> myMonitoring;

      ActionCategories myActionCategories;
      Doctrines myDoctrines;
      bool myRequestScriptsIfNeeded;

      ScriptedTaskTypeInformation myScriptedTaskTypeInformation;

      DoctrinesByForce myDoctrinesByForce;

      time_t mySendTime;
      int myResponseTimeout;

      std::set<DtString> myScriptsToShowOnTopLevelRightClickMenu;

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