vrforces4.8/classref/gui_thread_vrf_remote_controller_8h_source.html

 /*******************************************************************************

 ** Copyright (c) 2019 MAK Technologies, Inc.

 ** All rights reserved.

 *******************************************************************************/


 #pragma once


 #include <vrfGuiCore/vrfGuiCore.h>

 #include <vrfGuiCore/queuedManager.h>

 #include <vrfutil/rwUUID.h>


 #include <vrfGuiCore/environmentalCreationData.h>

 #include <vrfGuiCore/entityCreationData.h>

 #include <vrfGuiCore/vrfSimBackendManager.h>

 #include <vrfGuiCore/vrfBackendSettingsManager.h>

 #include <vrfGuiCore/vrfSpotReportManager.h>

 #include <vrfGuiCore/vrfResourceManager.h>

 #include <vrfGuiCore/sharedNetworkSignaler.h>


 #include <vrvUtil/DtVirtualBaseClass.h>

 #include <vrvCore/DtSelectionManager.h>

 #include <vrvCore/DtEntityState.h>

 #include <vrvUtil/signalslib.h>


 #include <vlpi/entityType.h>

 #include <matrix/vlVector.h>


 #include <vrfmsgs/messageExecutive.h>

 #include <vrfmsgs/vrfObjectMessageExecutive.h>


 #include <boost/function.hpp>


 class DtScenarioLoadInformation;

 class DtSetDataRequest;

 class DtIfVrfObjectCreated;

 class DtSimTask;

 class DtAdminMessage;

 class DtSimInterfaceContent;

 class DtVrfOverlayObjectModify;

 class DtIfPlan;

 class DtIfIndirectArtilleryData;

 class DtIfCreateVrfObject;

 class DtIfModifyVrfObject;

 class DtObjectType;

 class DtPlan;

 class DtScenario;

 class DtChangeWeatherCommand;

 class DtScenarioLoadInformation;


 typedef boost::function<void (DtString, const DtUUID&, const DtEntityIdentifier&, const DtObjectType&)> DtVrfObjectCreatedCallbackFunction;

 typedef boost::function<void (bool, DtString, const DtUUID&, const DtEntityIdentifier&)> DtComputedRouteResponseCallbackFunction;


 namespace makVrv

 {

    class DtDe;

 }


 namespace makVrf

 {

    class DtGuiThreadNetworkCallbackManager;


    class DT_DLL_VRFGUICORE DtGuiThreadVrfRemoteController : public DtQueuedManager

    {

    public:


       DtGuiThreadVrfRemoteController(makVrv::DtDe&);

       virtual ~DtGuiThreadVrfRemoteController();


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


    public:

       DtVrfBackendSettingsManager& backendSettingsManager();


       DtVrfSimBackendManager& backendManager();


       DtVrfSpotReportManager& spotReportManager();


       DtVrfResourceManager& resourceManager();


       DtGuiThreadNetworkCallbackManager& messageHandler();


    public:


       virtual void rollbackToSnapshot(double simTime);


       virtual void newScenario(const DtScenario*, time_t startTimeOfDay = 12 * 3600, const DtChangeWeatherCommand& = DtChangeWeatherCommand());

       virtual void newScenario(const DtFilename& terrainDatabase, time_t startTimeOfDay = 12 * 3600, const DtChangeWeatherCommand& = DtChangeWeatherCommand());


       virtual void importScenarioDescriptionFile(const std::string& file, DtSimulationAddress, const std::string& description ,

          const std::map<std::string, std::string>& importData);


       virtual void createSimulationObjectGroup(const DtSimulationAddress&, const DtString& simulationObjectGroup,

          const DtVector& createPosition, double offsetRotation, int createFlags, int force, bool inZipFile = false);


       virtual bool saveSimulationObjectGroup(const DtFilename& smsDirectory, const std::string& groupName,

          const std::string& groupDescription, int creationFlags, const DtSimulationAddress& addr,

          const std::map<DtString, DtString>& additionalInformation = std::map<DtString, DtString>(),

          bool saveAsZipFile = false);


       virtual void exportScenarioDescriptionFile(const std::string& file, DtSimulationAddress, const std::string& description,

          const std::map<std::string, std::string>& importData);


       virtual bool loadScenario(const DtScenarioLoadInformation&);

       virtual bool loadScenario(const DtFilename&);

       virtual bool importScenario(const DtFilename&);


       virtual void saveScenario(const DtScenario*, DtPreserveMappingsFcn fcn = 0, void* userData = 0,

          bool saveScenarioToZipFile = false, bool queueSave = false, int putIntoPlayMode = 0);


       virtual void saveCheckpoints(const std::vector<DtScenario*>&, const DtFilename& scenarioName);


       virtual void clearSavingCheckpoints();


       virtual void takeSnapshot(DtSimulationAddress addr = DtSimSendToAll);


       virtual void takeBaseSnapshot();


       virtual void closeScenario(const DtFilename& databaseToOpen = "", bool forceCloseScenario = false);


       virtual void reinitializeScenario();


       virtual void setScenarioRunDuration(double time, bool duration = false);


       virtual void runScenario(bool useStartStopInteraction = false, DtSimulationAddress addr = DtSimSendToAll);

       virtual void pauseScenario(bool useStartStopInteraction = false, DtSimulationAddress addr = DtSimSendToAll);

       virtual void rewindScenario(DtSimulationAddress addr = DtSimSendToAll);

       virtual void exitServer(DtSimulationAddress addr = DtSimSendToAll);

       virtual void stepScenario(DtSimulationAddress addr = DtSimSendToAll);


       virtual void deleteObject(const DtUUID&, bool andDeleteFromOrbat = false, DtSimulationAddress addr = DtSimSendToAll);


       virtual void removeObjectCreatedCallback(unsigned int);


       virtual void createWaypoint(

          const DtSimulationAddress& addr,

          const DtVector& geocentricPosition,

          const std::string& uniqueName = "",

          const std::string& label = "",

          unsigned int requestId = 0);


       virtual unsigned int createWaypoint(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const DtVector& geocentricPosition,

          const std::string& uniqueName = "",

          const std::string& label = "");


       virtual void modifyWaypoint(

          const DtUUID& uuid,

          std::string* uniqueName = 0,

          std::string* label = 0,

          DtVector* geocentricPosition = 0,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void createRoute(

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "",

          unsigned int rId = 0);


       virtual unsigned int createRoute(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "");


       virtual void modifyRoute(

          const DtUUID& uuid,

          std::string* uniqueName = 0,

          std::string* label = 0,

          std::vector<DtVector>* vertices = 0,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void createPhaseLine(

          const DtSimulationAddress& addr,

          const DtVector& dbPoint1,

          const DtVector& dbPoint2,

          const std::string& uniqueName = "",

          const std::string& label = "",

          unsigned int rId = 0);


       virtual unsigned int createPhaseLine(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const DtVector& dbPoint1,

          const DtVector& dbPoint2,

          const std::string& uniqueName = "",

          const std::string& label = "");


       virtual void modifyPhaseLine(

          const DtUUID& uuid,

          std::string* uniqueName = 0,

          std::string* label = 0,

          DtVector* newDbPoint1 = 0,

          DtVector* newDbPoint2 = 0,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void createControlArea(

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "",

          unsigned int rId = 0);


       virtual unsigned int createControlArea(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "");


       virtual void modifyControlArea(

          const DtUUID& uuid,

          std::string* uniqueName = 0,

          std::string* label = 0,

          std::vector<DtVector>* newVertices = 0,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void createObstacle(

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "",

          unsigned int rId = 0);


       virtual unsigned int createObstacle(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "") ;


       virtual void modifyObstacle(

          const DtUUID& uuid,

          std::string* uniqueName = 0,

          std::string* label = 0,

          std::vector<DtVector>* newVertices = 0,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void createDisaggregationArea(

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "",

          unsigned int rId = 0);


       virtual unsigned int createDisaggregationArea(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const std::vector<DtVector>& vertices,

          const std::string& uniqueName = "",

          const std::string& label = "") ;


       virtual void modifyDisaggregationArea(

          const DtUUID& uuid,

          std::string* uniqueName = 0,

          std::string* label = 0,

          std::vector<DtVector>* newVertices = 0,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual unsigned int createOverlayObject(

          const DtSimulationAddress& addr,

          const DtEntityType& type,

          const std::vector<DtVector>& vertices,

          const DtForceType& force,

          const std::string& name,

          const std::string& label,

          int color,

          const std::string& parentName,

          bool projection,

          bool closedFigure,

          const DtAppearance& appearance = DtAppearance::nullAppearance(),

          const std::string& attachTo = "",

          char* userData = 0,

          int dataSize = 0,

          const std::map<std::string, std::string>& extendedData = std::map<std::string, std::string>(),

          const std::map<int, DtString>& extendedLabels = std::map<int, DtString>(),

          DtVrfObjectCreatedCallbackFunction fcn = 0);


       virtual void setPhysicalLineWidth(const DtSimulationAddress& addr,

          const DtUUID& entityId, double w);


       virtual void setPhysicalLineHeight(const DtSimulationAddress& addr,

          const DtUUID& entityId, double h);


       virtual void setCeiling(const DtSimulationAddress& addr,

          const DtUUID& entityId, double c);


       virtual void createIndirectArtillery(

          const DtIfIndirectArtilleryData& params,

          const std::string& overlayParent,

          const DtSimulationAddress& addr);


       virtual void createComputedRoute(

          const DtSimulationAddress& addr,

          const DtVector& sourcePoint,

          const DtVector& destPoint,

          const std::list<std::string>& obstacleTypes,

          const std::list<std::string>& pathTypes,

          const std::string& uniqueName = "",

          const std::string& label = "",

          const std::string& overlay = "",

          const int forceId = DtForceOther,

          const std::map<int, DtString>& extendedLabels = std::map<int, DtString>(),

          unsigned int requestId = 0);


       virtual void cancelCreateComputedRoute(

          const DtSimulationAddress& addr,

          unsigned int requestId);


       virtual void createComputedRoute(

          DtComputedRouteResponseCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const DtVector& sourcePoint,

          const DtVector& destPoint,

          const std::list<std::string>& obstacleTypes,

          const std::list<std::string>& pathTypes,

          const std::string& uniqueName = "",

          const std::string& label = "",

          const std::string& overlay = "",

          const int forceId = DtForceOther,

          const std::map<int, DtString>& extendedLabels = std::map<int, DtString>());


       virtual unsigned int createEntity(DtVrfObjectCreatedCallbackFunction fcn, DtSimulationAddress addr, const DtEntityCreationData&,

          const std::list<DtAdminContent*>& content = std::list<DtAdminContent*>(),

          const std::list<DtSimInterfaceContent*>& ifaceContent = std::list<DtSimInterfaceContent*>());


       virtual void createEntity(DtSimulationAddress addr, const DtEntityCreationData&,

          const std::list<DtAdminContent*>& content = std::list<DtAdminContent*>(),

          const std::list<DtSimInterfaceContent*>& ifaceContent = std::list<DtSimInterfaceContent*>());


       virtual void createEntity(

          const DtSimulationAddress& addr,

          const DtEntityType& type,

          const DtVector& geocentricPosition,

          DtForceType force,

          DtReal heading,

          const std::string& uniqueName = "",

          const std::string& label = "",

          bool groundClamp = true, const std::list<DtAdminContent*>& content = std::list<DtAdminContent*>(),

          const std::list<DtSimInterfaceContent*>& ifaceContent = std::list<DtSimInterfaceContent*>(),

          const std::map<std::string, std::string>& extendedData = std::map<std::string, std::string>(),

          const std::map<int, DtString>& extendedLabels = std::map<int, DtString>());


       virtual unsigned int createEntity(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const DtEntityType& type,

          const DtVector& geocentricPosition,

          DtForceType force,

          DtReal heading,

          const std::string& uniqueName = "",

          const std::string& label = "",

          bool groundClamp = true, const std::list<DtAdminContent*>& content = std::list<DtAdminContent*>(),

          const std::list<DtSimInterfaceContent*>& ifaceContent = std::list<DtSimInterfaceContent*>(),

          const std::map<std::string, std::string>& extendedData = std::map<std::string, std::string>(),

          const std::map<int, DtString>& extendedLabels = std::map<int, DtString>());


       virtual unsigned int createAggregate(

          DtVrfObjectCreatedCallbackFunction fcn,

          const DtSimulationAddress& addr,

          const DtEntityType& type,

          const DtVector& geocentricPosition,

          DtForceType force,

          DtReal heading,

          const std::string& uniqueName,

          const std::string& label = "",

          DtAggregateState initialAggregateState = DtDisaggregated,

          const std::list<DtAdminContent*>& content = std::list<DtAdminContent*>(),

          const std::list<DtSimInterfaceContent*>& ifaceContent = std::list<DtSimInterfaceContent*>(),

          const std::map<std::string, std::string>& extendedData = std::map<std::string, std::string>(),

          const std::map<int, DtString>& extendedLabels = std::map<int, DtString>(),

          bool createSubordinates = true);


       virtual void aggregateAs(const std::vector<DtUUID>& uuids, const DtEntityType& type,

          int force, DtAggregateState initialAggregateState, DtSimulationAddress addr, unsigned int requestId = 0);


       virtual unsigned int aggregateAs(DtVrfObjectCreatedCallbackFunction fcn,

          const std::vector<DtUUID>& uuids, const DtEntityType& type,

          int force, DtAggregateState initialAggregateState, DtSimulationAddress addr);


       virtual void addToOrganization(const DtUUID& child, const DtUUID& superior,

          DtSimulationAddress addr = DtSimSendToAll);


       virtual void addToForceLevelOrganization(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void removeFromOrganization(

          const DtUUID& uuid,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void createEnvironmentalObject(DtSimulationAddress addr, DtEntityType, int force, const std::vector<DtVector>&,

          const DtEnvironmentalCreationData& data = DtEnvironmentalCreationData(),

          const std::list<DtAdminContent*>& content = std::list<DtAdminContent*>(),

          const std::list<DtSimInterfaceContent*>& ifaceContent = std::list<DtSimInterfaceContent*>());


       virtual void sendVrfObjectModifyMsg(

          const DtSimulationAddress& addr,

          const DtUUID& uuid,

          const std::string* name = 0,

          const std::vector<DtVector>& = std::vector<DtVector>(),

          int* force = 0,

          double* heading = 0,

          const std::string* label = 0,

          DtAppearance* appearance = 0,

          const std::string* overlayParent = 0,

          const std::string* userData = 0,

          const std::map<std::string, std::string>* extendedData = 0,

          const std::map<int, DtString>* extendedLabels = 0,

          bool mergeExtendedData = true);


       virtual void sendVrfObjectCreateMsg(

          const DtSimulationAddress& addr,

          unsigned int requestId,

          const std::string& name,

          const DtObjectType& type,

          const std::vector<DtVector>& vertices,

          const std::string& label,

          const DtAppearance& appearance,

          DtForceType force,

          bool projection,

          bool closedFigure,

          DtReal heading,

          bool createSubObjects,

          const std::string& overlayParent = "",

          bool clampToGroundFlag = true,

          const std::string& initialFormation = "",

          DtAggregateState initialAggregateState = DtDisaggregated,

          const std::string& userData = "", const std::list<DtAdminContent*>& content = std::list<DtAdminContent*>(),

          const std::list<DtSimInterfaceContent*>& ifaceContent = std::list<DtSimInterfaceContent*>(),

          const std::map<std::string, std::string>& extendedData = std::map<std::string, std::string>(),

          const std::map<int, DtString>& extendedLabels = std::map<int, DtString>(),

          const DtUUID& uuidForCreation = DtUUID::nullUUID(),

          double pitch = 0.);


       virtual unsigned int addCreateCallbackFunction(DtVrfObjectCreatedCallbackFunction);


       virtual unsigned int addCreateComputedRouteCallbackFunction(DtComputedRouteResponseCallbackFunction);


       virtual void removeCreateComputedRouteCallbackFunction(int rId);


       virtual void sendVrfOverlayObjectModifyMsg(

          const DtSimulationAddress& addr,

          const DtUUID& uuid,

          int* color = 0,

          const std::string* parentName = 0,

          const DtUUID* attachTo = 0,

          const std::string* userData = 0);


       virtual void sendVrfIndirectArtilleryObjectModifyMsg(

          const DtSimulationAddress& addr,

          const DtUUID& uuid,

          const DtIfIndirectArtilleryData& mod);


       virtual void setLabel(

          const DtUUID& uuid, const std::string& label,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setExtendedLabels(

          const DtUUID& uuid, const std::map<int, DtString>& extendedLabels,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setOverlayParent(

          const DtUUID& uuid, const std::string& label,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setAltitude(

          const DtUUID& uuid, double altitude, bool aboveGroundLevel = false,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setLocation(

          const DtUUID& uuid, DtVector coord,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setAppearance(

          const DtUUID& uuid, int appearance,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setCapabilities(

          const DtUUID& uuid, int capabilities,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setHeading(

          const DtUUID& uuid, double degrees,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setForce(

          const DtUUID& uuid, DtForceType force,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setResource(const DtUUID& uuid,

          const char* resourceType, double value,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setRulesOfEngagement(

          const DtUUID& uuid, const char* rulesType,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setSectorOfResponsibility(

          const DtUUID& uuid, double center, double size,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setSpeed(

          const DtUUID& uuid, double speed,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setCurrentSpeed(

          const DtUUID& uuid, double speed,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setTarget(

          const DtUUID& uuid, const DtUUID& target,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setSuperior(

          const DtUUID& uuid, const DtUUID& superior,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setTaskedBySuperior(const DtUUID& uuid,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setConcealed(const DtUUID& uuid,

          bool yes, const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setEmitter(const DtUUID& uuid,

          int emitterId, bool on,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setEmergencyBeacon(const DtUUID& uuid,

          bool on,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setIff(const DtUUID& uuid,

          bool mode1on, int mode1code,

          bool mode2on, int mode2code,

          bool mode3on, int mode3code,

          bool mode4on, int mode4code,

          DtIffAtcNavaidsAltParm4 altParm4,

          bool modeCon, bool useAltModeC,

          bool modeSon, bool emergency,

          bool flash, bool sti, bool modeSTcasI,

          int pin, bool mode5LevelSelection,

          unsigned int messageFormatsPresent, unsigned int nationalOrigin,

          unsigned int navigationSource, unsigned int figureOfMerit,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void restore(const DtUUID& uuid,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setDestroyed(const DtUUID& uuid,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setLifeformWeaponState(

          const DtUUID& uuid, DtWeaponState weapon,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setSkillLevel(

          const DtUUID& uuid, const unsigned int level,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setLifeformPosture(

          const DtUUID& uuid, DtLifeformState posture,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void setAggregateFormation(

          const DtUUID& leader, const std::string& formationName,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void reorganizeAggregate(const DtUUID& leader,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void disaggregate(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void aggregate(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void sendSetDataMsg(

          const DtUUID& recipient, DtSetDataRequest* msg,

          const DtSimulationAddress& addr = DtSimSendToAll,

          bool updateScenario = true);


       virtual void sendSetRequest(const DtSetDataRequest& s, const DtUUID& uuid,

          const DtSimulationAddress& addr = DtSimSendToAll, bool updateScenario = true);


       virtual void sendSetRequest(const DtSetDataRequest& s, const std::vector<DtUUID>& names,

          const DtSimulationAddress& addr = DtSimSendToAll, bool updateScenario = true);


       virtual void requestIndirectArtilleryInformation(const DtUUID&);


       virtual void moveAlongRoute(

          const DtUUID& entity, const DtUUID& route,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void moveToWaypoint(

          const DtUUID& entity, const DtUUID& waypoint,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void moveToLocation(

          const DtUUID& entity, const DtVector& destinationLocation,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void patrolBetweenWaypoints(

          const DtUUID& entity,

          const DtUUID& waypoint1, const DtUUID& waypoint2,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void patrolAlongRoute(

          const DtUUID& entity, const DtUUID& route,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void followEntity(

          const DtUUID& entity,

          const DtUUID& leader, const DtVector& offset,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void wait(

          const DtUUID& entity,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void waitDuration(

          const DtUUID& entity, DtTime duration,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void waitElapsed(

          const DtUUID& entity, DtTime elapsed,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void requestCurrentTasks(const DtUUID& entity);


       virtual void subscribeForTaskInformation(const DtUUID& entity);


       virtual void unsubscribeForTaskInformation(const DtUUID& entity);


       virtual void sendTaskMsg(

          const DtUUID& recipient, DtSimTask* task,

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void sendTaskRequest(const DtSimTask& s, const std::vector<DtUUID>& names, const DtSimulationAddress& addr = DtSimSendToAll);

       virtual void sendTaskRequest(const DtSimTask& s, const DtUUID& uuid, const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void requestTasksAndSetsFor(const std::vector<DtUUID>& name);


       virtual void abandonPlan(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void skipTask(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void cancelReactiveTask(const DtUUID& uuid, std::string scriptId, DtSimulationAddress addr = DtSimSendToAll);


       virtual void restartPlan(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void assignPlanByName(const DtUUID& uuid, const DtPlan*, DtSimulationAddress addr = DtSimSendToAll);


       virtual void assignMultiplePlanByName(std::vector<DtUUID> names, const DtPlan*, DtSimulationAddress addr = DtSimSendToAll);


       virtual void requestPlan(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void subscribePlan(const DtUUID& uuid, DtSimulationAddress addr = DtSimSendToAll);


       virtual void requestMultiplePlans(std::vector<DtUUID> names, DtSimulationAddress addr = DtSimSendToAll);


       virtual void requestGlobalPlans(DtSimulationAddress addr = DtSimSendToAll);


       virtual void assignGlobalPlanByName(const DtUUID& name, const DtPlan*, DtSimulationAddress addr);


       virtual void deleteGlobalPlan(const DtUUID&, DtSimulationAddress addr);


       virtual void launchGlobalPlan(const DtUUID&, DtSimulationAddress addr);


       virtual void setTimeoutInterval(int);


       virtual void requestDIGuyAppearancesAndAnimations(const std::vector<DtUUID>& name);


       virtual void requestResourcesFor(std::vector<DtUUID> names, DtSimulationAddress addr = DtSimSendToAll);


       virtual void sendMessageToObject(const DtVrfObjectMessage&, DtSimulationAddress addr = DtSimSendToAll);


       virtual void sendObjectMessageAndDeleteContent(DtVrfObjectMessage* message, DtSimulationAddress addr = DtSimSendToAll);


       virtual void sendSensorFieldOfViewControlInteraction(const DtSensorFieldOfViewControlInteractionData& interData);


       virtual void sendSensorFieldOfViewControlInteractionAndDelete(DtSensorFieldOfViewControlInteractionData* data);


       virtual void sendDetonationInteraction(const DtDetonationInteractionData& interData);


       virtual void sendDetonationInteractionAndDelete(DtDetonationInteractionData* data);


       virtual void requestForces(DtSimulationAddress addr);


       virtual void requestDoctrines();


       virtual void requestAssignedDoctrines();


       virtual unsigned long generateRequestId();


       virtual void quitAllBackends();


       //-------------------------------------------------------

       //-------------------------------------------------------


       virtual void takeControlOf(const DtUUID&, const std::set<std::string>& functionalGroups = std::set<std::string>(),

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void releaseControlOf(const DtUUID&, const std::set<std::string>& functionalGroups = std::set<std::string>(),

          const DtSimulationAddress& addr = DtSimSendToAll);


       virtual void sendJoystickControl(const DtUUID&, const std::string& functionGroup,

          const std::string& function, double value, bool repeat = false, const DtSimulationAddress& addr = DtSimSendToAll);


    public:


       virtual void addSetCreatorFcn(const DtSetMessageType&, DtSetDataRequestCreatorFcn);


       virtual void addTaskCreatorFcn(const DtSimTaskMessageType&, DtSimTaskCreatorFcn);


       virtual void addInterfaceContentCreatorFcn(int t, DtInterfaceContentCreatorFcn);


       virtual void addAdminContentCreatorFcn(const DtAdminContentMessageType&, DtAdminContentCreatorFcn);


       virtual void addConditionCreatorFcn(std::string, int, DtCondExprCreatorFcn);


       virtual void addReportCreatorFcn(const DtSimReportMessageType&, DtSimReportCreatorFcn);


       virtual void addObjectMessageCreatorFcn(int, DtVrfObjectMessageCreatorFcn);


       virtual void addSimulationCommandCreatorFcn(const DtSimCommandMessageType&, DtSimCommandCreatorFcn);


       virtual void sendMessage(const DtSimInterfaceContent& message, DtSimulationAddress addr = DtSimSendToAll);

       virtual void sendMessageAndDeleteContent(DtSimInterfaceContent* message, DtSimulationAddress addr = DtSimSendToAll);


       virtual void embarkOn(const std::vector<DtUUID>& children, const DtUUID& parent,

          bool useSlot = true, const DtVector& overridePosition = DtVector::zero(),

          int embarkInSlot = -1, const DtString& slotName = "*", const DtString& slotType = "*",

          bool chooseAnyIfNotAvailable = true, DtSimulationAddress addr = DtSimSendToAll);


       virtual void disembark(const std::vector<DtUUID>& children, DtSimulationAddress addr = DtSimSendToAll);


       virtual void disembarkAll(const std::vector<DtUUID>& parents, DtSimulationAddress addr = DtSimSendToAll);


       virtual void attachTo(const std::vector<DtUUID>& ids, const DtUUID& parent);


       virtual void detachAll(const std::vector<DtUUID>& ids);


       virtual void logObjectConsoleToFile(const DtUUID& uuid, const std::string& filename);


       virtual void stopLoggingObjectConsoleToFile(const DtUUID& uuid);


       virtual void setObjectNotifyLevel(const DtUUID& uuid, int);


       virtual void setTimeOfDay(time_t seconds);

       virtual void setTimeOfDay(int hours, int minutes, int seconds);


       virtual void setDateAndTimeOfDay(time_t seconds);

       virtual void setDateAndTimeOfDay(int year, int month, int day, int hours, int minutes, int seconds);


       virtual void setUseDayNightIlluminationModel(bool);


       virtual void setAggregateOnCreate(bool);

       bool aggregateOnCreate() const;


       virtual void requestScenarioDescription(DtSimulationAddress);


       virtual void setScenarioDescription(const DtString&, DtSimulationAddress addr = DtSimSendToAll);


       virtual void setScenarioName(const DtString&, DtSimulationAddress addr = DtSimSendToAll);


       virtual void addContentMessagesThatModifyScenario(int);

       virtual void removeContentMessagesThatModifyScenario(int);

       const std::set<int>& contentMessagesThatModifyScenario() const { return myContentMessagesThatModifyScenario; };


    public:

       virtual void sendLoggerSetFilename(std::string filename);


       virtual void sendLoggerRecordMessage();


       virtual void sendLoggerStopMessage();


    protected:

       virtual void processObjectCreated(DtSimMessage*);


       virtual void processComputedRouteCreated(DtSimMessage*);


       virtual void setActivated(bool);


       virtual bool addStatementsAndSendPlan(const DtPlan& plan, DtIfPlan& planMsg,

          const DtSimulationAddress& addr = DtSimSendToAll,

          int *retiStatus = 0, DtString* retsStmt = 0);


       virtual void indirectArtilleryCreated(DtString, const DtUUID&, const DtEntityIdentifier&, DtIfIndirectArtilleryData);


       virtual void checkIfContentMessageShouldMarkScenarioAsModified(const DtSimInterfaceContent&);


    public:


       boost::signals2::signal<void (const DtScenario*)> signal_loadedScenario;


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


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


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


       boost::signals2::signal<void (const DtScenario*, DtPreserveMappingsFcn fcn, void* userData, bool saveToZipFile,

          bool queueSave, int putIntoPlayMode)> signal_saveScenario;


       boost::signals2::signal<void (double)> signal_rollbackToSnapshot;


       boost::signals2::signal<void (std::vector<DtScenario*>, DtFilename)> signal_saveCheckpoints;


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


       boost::signals2::signal<void (const DtUUID&, bool& shouldDelete)> signal_shouldDeleteObject;


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


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


       boost::signals2::signal<void (DtIfCreateVrfObject&)> signal_aboutToSendCreateMessage;


       boost::signals2::signal<void (DtIfModifyVrfObject&)> signal_aboutToSendModifyMessage;


    protected:

       virtual void slot_preTick(makVrv::DtDe* de);


    protected:

       bool myAggregateOnCreate;


       typedef std::map<unsigned int, DtVrfObjectCreatedCallbackFunction> CreateCallbacks;


       CreateCallbacks myCreateCallbacks;


       typedef std::map<unsigned int, DtComputedRouteResponseCallbackFunction> ComputedRouteCallbacks;


       ComputedRouteCallbacks myCreateComputedRouteCallbacks;


       std::set<int> myContentMessagesThatModifyScenario;

    };

 }

DtIfPlan
class DtIfPlan:
Definition: ifPlan.h:61

DtUUID
UUID is a unique ID wrapper class.
Definition: rwUUID.h:222

makVrf::DtGuiThreadVrfRemoteController::signal_aboutToSendCreateMessage
boost::signals2::signal< void(DtIfCreateVrfObject &)> signal_aboutToSendCreateMessage
Sent when create message is about to be sent.
Definition: guiThreadVrfRemoteController.h:1335

DtTime

makVrf::DtEnvironmentalCreationData
Definition: environmentalCreationData.h:27

makVrf::DtGuiThreadVrfRemoteController::signal_loadedScenario
boost::signals2::signal< void(const DtScenario *)> signal_loadedScenario
Called after both signal_new and signal_load scenario.
Definition: guiThreadVrfRemoteController.h:1298

DtSetDataRequestCreatorFcn
DtSetDataRequestFactory::DtCreatorFcn DtSetDataRequestCreatorFcn
Definition: setDataRequestFactory.h:41

DtScenario
Definition: scenario.h:52

makVrf::DtGuiThreadVrfRemoteController::ComputedRouteCallbacks
std::map< unsigned int, DtComputedRouteResponseCallbackFunction > ComputedRouteCallbacks
Definition: guiThreadVrfRemoteController.h:1353

queuedManager.h

makVrv::vrvTacticalGraphicUtilities::level
DT_DLL_VRVCORE DtTaitBryan level(const DtCoordinateSystem &cs, const DtVector &localOrigin, double topoHeading)
Returns a level orientation with the topographic heading.

makVrf::DtGuiThreadVrfRemoteController::signal_rollbackToSnapshot
boost::signals2::signal< void(double)> signal_rollbackToSnapshot
Signal to roll back to the give sim time.
Definition: guiThreadVrfRemoteController.h:1314

signalslib.h

size
voidpf void uLong size
Definition: ioapi.h:39

DtSelectionManager.h
Contains makVrv:DtSelectionManager class.

makVrf::DtGuiThreadVrfRemoteController::signal_communicationDriverStarted
boost::signals2::signal< void()> signal_communicationDriverStarted
Signal sent when the communication driver has been started.
Definition: guiThreadVrfRemoteController.h:1301

makVrf::DtGuiThreadVrfRemoteController::CreateCallbacks
std::map< unsigned int, DtVrfObjectCreatedCallbackFunction > CreateCallbacks
Definition: guiThreadVrfRemoteController.h:1349

DtVrfObjectMessageTypeTemplate< DtSetDataRequestMessageType >

makVrf::DtGuiThreadVrfRemoteController
This class is a thread-safe API to the DtVrfRemoteController.
Definition: guiThreadVrfRemoteController.h:93

vrfBackendSettingsManager.h

makVrf::DtVrfSpotReportManager
Definition: vrfSpotReportManager.h:54

rwUUID.h

DT_DLL_VRFGUICORE
#define DT_DLL_VRFGUICORE
Contains DLL export macros.
Definition: vrfGuiCore.h:25

makVrf::DtGuiThreadVrfRemoteController::signal_aboutToSendModifyMessage
boost::signals2::signal< void(DtIfModifyVrfObject &)> signal_aboutToSendModifyMessage
Sent when about to send modify message. Can change message to effect content.
Definition: guiThreadVrfRemoteController.h:1338

vrfObjectMessageExecutive.h

makVrf::DtGuiThreadVrfRemoteController::signal_saveScenario
boost::signals2::signal< void(const DtScenario *, DtPreserveMappingsFcn fcn, void *userData, bool saveToZipFile, bool queueSave, int putIntoPlayMode)> signal_saveScenario
Sends signal to save the specified scenario.
Definition: guiThreadVrfRemoteController.h:1311

makVrf::DtEntityCreationData
Definition: entityCreationData.h:27

DtInterfaceContentCreatorFcn
DtSimInterfaceContent *(* DtInterfaceContentCreatorFcn)()
Definition: interfaceContentFactory.h:21

DtVrfOverlayObjectModify
This class will hold information that can be used to modify a overlay object after it has been create...
Definition: vrfRemoteController.h:2458

DtAdminContentCreatorFcn
DtAdminContentFactory::DtCreatorFcn DtAdminContentCreatorFcn
Definition: adminContentFactory.h:36

DtComputedRouteResponseCallbackFunction
boost::function< void(bool, DtString, const DtUUID &, const DtEntityIdentifier &)> DtComputedRouteResponseCallbackFunction
Definition: guiThreadVrfRemoteController.h:57

DtIfModifyVrfObject
class DtIfModifyVrfObject:
Definition: ifModifyVrfObject.h:50

DtObjectType
Definition: objectType.h:27

vrfSpotReportManager.h

vrfGuiCore.h

DtSimTaskCreatorFcn
DtSimTaskFactory::DtCreatorFcn DtSimTaskCreatorFcn
Definition: simTaskFactory.h:41

makVrf::DtVrfResourceManager
Definition: vrfResourceManager.h:28

DtVector

makVrf::DtGuiThreadVrfRemoteController::myCreateCallbacks
CreateCallbacks myCreateCallbacks
Definition: guiThreadVrfRemoteController.h:1351

DtSetDataRequest
DtSetDataRequest is an abstract base class from which real setDataRequests can derive.
Definition: setDataRequest.h:40

DtUUID::nullUUID
static const DtUUID & nullUUID()

makVrf::DtGuiThreadVrfRemoteController::signal_clearSavingCheckpoints
boost::signals2::signal< void()> signal_clearSavingCheckpoints
Sends a signal to clear out all the checkpoints that have not yet been saved.
Definition: guiThreadVrfRemoteController.h:1321

DtVirtualBaseClass.h
Contains makVrv::DtVirtualBaseClass class.

makVrf::DtVrfBackendSettingsManager
The Master DtVrfBackendSettingsManager.
Definition: vrfBackendSettingsManager.h:40

DtSimReportCreatorFcn
DtSimReportFactory::DtCreatorFcn DtSimReportCreatorFcn
Definition: simReportFactory.h:38

DtSimMessage
File: simMsg.h.
Definition: simMessage.h:35

vrfSimBackendManager.h

entityCreationData.h

makVrf::DtGuiThreadVrfRemoteController::signal_scenarioModified
boost::signals2::signal< void()> signal_scenarioModified
Signal send whenever the scenario has been modified by the user.
Definition: guiThreadVrfRemoteController.h:1304

DtVrfObjectMessageCreatorFcn
DtVrfObjectMessage *(* DtVrfObjectMessageCreatorFcn)()
Creator function for DtVrfObjectMessage instances.
Definition: vrfObjectMessageFactory.h:21

makVrf::DtGuiThreadVrfRemoteController::myCreateComputedRouteCallbacks
ComputedRouteCallbacks myCreateComputedRouteCallbacks
Definition: guiThreadVrfRemoteController.h:1355

DtEntityState.h
Contains makVrv::DtEntityState class.

makVrf::DtSensorFieldOfViewControlInteractionData
The DtSensorFieldOfViewControlInteractionContents provides the data contents of a SensorFieldOfViewCo...
Definition: sensorFieldOfViewControlInteractionData.h:25

DtChangeWeatherCommand
A DtSimCommand subclass which specifies a change to the weather settings for the specified weather ar...
Definition: changeWeatherCommand.h:28

DtVrfObjectMessage
The base class for all messages to/from a specific DtVrfObject.
Definition: vrfObjectMessage.h:30

makVrf::DtDetonationInteractionData
The DtDetonationInteractionData provides the data contents of a DIS DetonationInteraction.
Definition: detonationInteractionData.h:25

makVrf::DtGuiThreadVrfRemoteController::signal_reinitializeScenario
boost::signals2::signal< void()> signal_reinitializeScenario
Signal send after signal to reinitialize scenario.
Definition: guiThreadVrfRemoteController.h:1331

DtSimCommandCreatorFcn
DtSimCommand *(* DtSimCommandCreatorFcn)()
Definition: simCommandFactory.h:20

DtPlan
class DtPlan:
Definition: plan.h:90

sharedNetworkSignaler.h
Contains makVrf::DtSharedNetworkSignaler class.

DtVrfObjectCreatedCallbackFunction
boost::function< void(DtString, const DtUUID &, const DtEntityIdentifier &, const DtObjectType &)> DtVrfObjectCreatedCallbackFunction
Definition: guiThreadVrfRemoteController.h:54

makVrf::DtGuiThreadNetworkCallbackManager
This class receives messages from the VR-Forces Simulation Engine (and other DIS/HLA messages) and in...
Definition: guiThreadNetworkCallbackManager.h:75

DtIfIndirectArtilleryData
Data container for Indirect Artillery.
Definition: ifModifyIndirectArtilleryObject.h:28

makVrf::DtQueuedManager
The class that is the interface between the GUI and the back-end.
Definition: queuedManager.h:27

DtPreserveMappingsFcn
bool(* DtPreserveMappingsFcn)(void *usr)
Used by saveScenario to determine if original (true) or new mappings should be saved.
Definition: vrfRemoteController.h:88

makVrf::DtGuiThreadVrfRemoteController::myAggregateOnCreate
bool myAggregateOnCreate
Definition: guiThreadVrfRemoteController.h:1347

DtSimTask
DtSimTask is an abstract base class from which real tasks can derive.
Definition: simTask.h:33

makVrf::DtVrfSimBackendManager
Maintains and signals state of the simulation engines that are currently connected to the GUI...
Definition: vrfSimBackendManager.h:73

makVrf::DtGuiThreadVrfRemoteController::myContentMessagesThatModifyScenario
std::set< int > myContentMessagesThatModifyScenario
Definition: guiThreadVrfRemoteController.h:1357

makVrf::DtGuiThreadVrfRemoteController::signal_closeScenario
boost::signals2::signal< void()> signal_closeScenario
Sent when the scenario is closing.
Definition: guiThreadVrfRemoteController.h:1328

DtIfVrfObjectCreated
class DtIfVrfObjectCreated:
Definition: ifVrfObjectCreated.h:32

makVrv::DtDe
The DtDe is the core component of any VR-Vantage application.
Definition: DtDe.h:69

DtSimInterfaceContent
Definition: simInterfaceContent.h:45

makVrf::DtGuiThreadVrfRemoteController::signal_shouldDeleteObject
boost::signals2::signal< void(const DtUUID &, bool &shouldDelete)> signal_shouldDeleteObject
Sent before deleting the object, set the shouldDeleteObject flag to false to not delete the specified...
Definition: guiThreadVrfRemoteController.h:1325

messageExecutive.h

DtString

offset
voidpf uLong offset
Definition: ioapi.h:42

char

DtScenarioLoadInformation
Definition: scenario.h:614

makVrf::DtGuiThreadVrfRemoteController::signal_loadScenario
boost::signals2::signal< void(const DtScenarioLoadInformation &)> signal_loadScenario
Calls down to simulation to load the scenario based on load scenario message.
Definition: guiThreadVrfRemoteController.h:1307

makVrf::DtGuiThreadVrfRemoteController::contentMessagesThatModifyScenario
const std::set< int > & contentMessagesThatModifyScenario() const
Definition: guiThreadVrfRemoteController.h:1255

environmentalCreationData.h

DtCondExprCreatorFcn
DtSimCondExpr *(* DtCondExprCreatorFcn)()
Definition: condExprFactory.h:28

vrfResourceManager.h

DtIfCreateVrfObject
class DtIfCreateVrfObject:
Definition: ifCreateVrfObject.h:84

DtAdminMessage
Definition: adminMessage.h:20