vrforces5.1.1/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 <vlpi/entityType.h>

 #include <matrix/vlVector.h>


 #include <vrfmsgs/messageExecutive.h>

 #include <vrfmsgs/vrfObjectMessageExecutive.h>

 #include <vrfmsgs/ifComputeAerodrome.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&)> DtComputedRouteResponseCallbackFunction;

 typedef boost::function<void (bool, DtIfComputeAerodromeResponse::ComputeFailureInformation)> DtComputedAerodromeResponseCallbackFunction;


 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 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 void cancelComputeAerodrome(

           const DtSimulationAddress& addr,

           unsigned int requestId);


       virtual void computeAerodrome(

          const DtSimulationAddress& addr,

          const std::vector<std::string>& icaos = std::vector<std::string>(),

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

          const std::string& overlay = "",

          const int forceId = DtForceNeutral,

          unsigned int requestId = 0);


       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 unsigned int addComputeAerodromeCallbackFunction(DtComputedAerodromeResponseCallbackFunction);


       virtual void removeComputeAerodromeCallbackFunction(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 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 setUseGlobalTimeZone(bool);


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


       virtual void requestSyncMatrices(DtSimulationAddress addr = DtSimSendToAll);


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


       virtual void renameSyncMatrix(const DtUUID& uuid, const DtString& name, DtSimulationAddress addr = DtSimSendToAll);


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


       virtual void deleteSyncMatrixPhase(const DtUUID& uuid, const DtString& phaseName,

          DtSimulationAddress addr = DtSimSendToAll);


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


       virtual void addSyncMatrixObjects(const DtUUID& uuid, const std::vector<DtUUID>& objects, DtSimulationAddress addr = DtSimSendToAll);


       virtual void removeSyncMatrixObject(const DtUUID& syncMatrix, const DtUUID& object,

          DtSimulationAddress addr = DtSimSendToAll);


       virtual void requestSyncMatrixPlan(const DtUUID& syncMatrix, const DtUUID& object,

          const DtString& phaseName, DtSimulationAddress addr = DtSimSendToAll);


       virtual void linkPlan(const DtUUID& syncMatrix, const DtUUID& object,

          const DtString& phaseName, bool linkPlan, DtSimulationAddress addr = DtSimSendToAll);


       virtual void setSyncMatrixPlan(const DtUUID& syncMatrix, const DtUUID& object,

          const DtString& phaseName, const DtPlan* plan, DtSimulationAddress addr = DtSimSendToAll);


       virtual void removeSyncMatrixPlan(const DtUUID& syncMatrix, const DtUUID& object,

          const DtString& phaseName, DtSimulationAddress addr = DtSimSendToAll);


       virtual void setSyncMatrixPhaseInfo(const DtUUID& syncMatrix,

          const DtString& currentName, int phaseIndex,

          const DtString& requestedName, bool endConditionSpecified,

          const DtSimCondExpr* endCondition = NULL, DtSimulationAddress addr = DtSimSendToAll);


       virtual void activateSyncMatrixPlan(const DtUUID& syncMatrix, const DtUUID& object,

          const DtString& phaseName, bool activate, DtSimulationAddress addr = DtSimSendToAll);


    public:

       virtual void sendLoggerSetFilename(std::string filename);


       virtual void sendLoggerRecordMessage();


       virtual void sendLoggerStopMessage();


    protected:

       virtual void processObjectCreated(DtSimMessage*);


       virtual void processComputedRouteCreated(DtSimMessage*);


       virtual void processAerodromeCreated(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;


       boost::signals2::signal<void (DtSharedNetworkSignaler::EnvironmentalSignalCreationData&)> signal_aboutToSendCreateEnvironmentalMessage;


    protected:

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


    protected:

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


       CreateCallbacks myCreateCallbacks;


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


       ComputedRouteCallbacks myCreateComputedRouteCallbacks;


       typedef std::map<unsigned int, DtComputedAerodromeResponseCallbackFunction> ComputedAerodromeCallbacks;


       ComputedAerodromeCallbacks myComputedAerodromeCallbacks;


       std::set<int> myContentMessagesThatModifyScenario;

    };

 }

DtIfPlan
class DtIfPlan:
Definition: ifPlan.h:61

DtUUID
UUID is a unique ID wrapper class.
Definition: uuid.h:59

makVrf::DtGuiThreadVrfRemoteController::signal_aboutToSendCreateMessage
boost::signals2::signal< void(DtIfCreateVrfObject &)> signal_aboutToSendCreateMessage
Sent when create message is about to be sent. Can change object create message to effect content...
Definition: guiThreadVrfRemoteController.h:1374

DtTime

makVrf::DtEnvironmentalCreationData
Definition: environmentalCreationData.h:27

makVrf::DtGuiThreadVrfRemoteController::signal_loadedScenario
boost::signals2::signal< void(const DtScenario *)> signal_loadedScenario
This section represents the collection of all signals sent by the various methods listed above...
Definition: guiThreadVrfRemoteController.h:1337

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:1394

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:1353

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

makVrf::DtGuiThreadVrfRemoteController::ComputedAerodromeCallbacks
std::map< unsigned int, DtComputedAerodromeResponseCallbackFunction > ComputedAerodromeCallbacks
Definition: guiThreadVrfRemoteController.h:1398

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:1340

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

DtVrfObjectMessageTypeTemplate< DtSetDataRequestMessageType >

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

vrfBackendSettingsManager.h

makVrf::DtVrfSpotReportManager
Definition: vrfSpotReportManager.h:58

rwUUID.h
Contains the DtUUID class declaration.

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:1377

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:1350

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:2407

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

DtIfModifyVrfObject
class DtIfModifyVrfObject:
Definition: ifModifyVrfObject.h:50

vrfSpotReportManager.h

vrfGuiCore.h

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

makVrf::DtVrfResourceManager
Definition: vrfResourceManager.h:29

DtVector

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

DtSetDataRequest
DtSetDataRequest is an abstract base class from which real setDataRequests can derive. It manages the read/write capability; derived classes need only use and register read/writatble data types for derived information.
Definition: setDataRequest.h:41

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:1360

DtVirtualBaseClass.h
Contains makVrv::DtVirtualBaseClass class.

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

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

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:1343

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

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

DtEntityState.h
Contains makVrv::DtVrlinkSimulatedEntityState 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:29

DtVrfObjectMessage
The base class for all messages to/from a specific DtVrfObject. Various subclasses of this class will...
Definition: vrfObjectMessage.h:30

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

ifComputeAerodrome.h

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

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

DtPlan
class DtPlan:
Definition: plan.h:92

sharedNetworkSignaler.h
Contains makVrf::DtSharedNetworkSignaler class.

DtSimCondExpr
DtSimCondExpr is an abstract base class representing various Conditional Expressions used by the Plan...
Definition: simCondExpr.h:53

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

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

DtIfIndirectArtilleryData
Data container for Indirect Artillery. Should contain nothing but mutators, accessors and data...
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:89

DtSimTask
DtSimTask is an abstract base class from which real tasks can derive. It manages the read/write capab...
Definition: simTask.h:30

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

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

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

makVrf::DtGuiThreadVrfRemoteController::signal_aboutToSendCreateEnvironmentalMessage
boost::signals2::signal< void(DtSharedNetworkSignaler::EnvironmentalSignalCreationData &)> signal_aboutToSendCreateEnvironmentalMessage
signal sent right before an environmental object is created. The environmental goes through a differe...
Definition: guiThreadVrfRemoteController.h:1381

DtIfVrfObjectCreated
class DtIfVrfObjectCreated:
Definition: ifVrfObjectCreated.h:32

makVrv::DtDe
The DtDe is the core component of any VR-Vantage application. It owns a DtRenderer, DtDeCommunicator, as well as a DtDisplay and other things.
Definition: DtDe.h:72

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:1364

makVrf::DtGuiThreadVrfRemoteController::myComputedAerodromeCallbacks
ComputedAerodromeCallbacks myComputedAerodromeCallbacks
Definition: guiThreadVrfRemoteController.h:1400

messageExecutive.h

DtString

offset
voidpf uLong offset
Definition: ioapi.h:42

char

DtScenarioLoadInformation
Definition: scenario.h:634

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:1346

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

environmentalCreationData.h

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

DtComputedAerodromeResponseCallbackFunction
boost::function< void(bool, DtIfComputeAerodromeResponse::ComputeFailureInformation)> DtComputedAerodromeResponseCallbackFunction
Definition: guiThreadVrfRemoteController.h:59

vrfResourceManager.h

DtIfCreateVrfObject
class DtIfCreateVrfObject:
Definition: ifCreateVrfObject.h:77

DtAdminMessage
Definition: adminMessage.h:20