vrfObjectManipulationHandlerBaseClass.h

Go to the documentation of this file.

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



#pragma once

#include <vrvUtil/signalslib.h>
#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/vrfObjectFacadeInterface.h>
#include <vrvCore/DtEntityState.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vlutil/vlPerformanceStats.h>
#include <vrfExtProtocol/simInterfaceContent.h>

#include <matrix/vlVector.h>
#include <matrix/geodeticCoord.h>
#include <vlpi/entityType.h>

namespace makVrv
{
   class DtDe;
   class DtChannel;
   class DtSimObjectEntry;
}

class DtEntityType;
class DtString;
class DtSimInterfaceContent;
class DtRwNLengthStringVector;
class DtModelSetEntry;

namespace makVrf
{
   enum DtEditingType 
   {
      Mouse = 0,
      Context,
      MousePositionOrigin,
      MousePositionVertex,
      ObjectOrigin 
   };

   enum HandlerType
   {
      Box,
      Circle,
      Entity,
      Prop,
      IndirectArtillery,
      Shape,
      Point,
      Weather,
      Vertex,
      Multi,
      SimulationObjectGroup,
      Detonation,
      CloudLayer,
      WindCorridor,
      AirTurbulence,
      User_Base = 100
   };

   enum DtCreationSignalType
   {
      DtNoCreationSignal = 0,
      DtSignalCreationAndStop,
      DtSignalCreationAndContinue,
      DtCreateFromEdit,
      DtCreateImmediately,  
      DtCreateOne 
   };

   class DtVrfObjectManipulationEventProcessor;

   typedef makVrv::DtStateView<makVrv::DtVrlinkSimulatedBaseState> DtVrlinkSimulatedBaseStateView;

   class DT_DLL_VRFGUICORE DtVrfObjectManipulationHandlerBaseClass
   {
   public:
      typedef std::vector<DtVrfObjectFacadeInterface*> VrfObjectEditFacadeList;
      typedef std::map<std::string, DtSimInterfaceContent*> ContentMessages;

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

   public:

      virtual bool createObject(const DtEntityType& entType, int force,
         DtCreationSignalType creationSignal=DtNoCreationSignal, const std::string& keywords = "");

      virtual bool createObject(const DtString& key, const DtString& associatedData,
         DtCreationSignalType creationSignal=DtNoCreationSignal, const std::string& keywords = "");

      virtual void editSelectedObjects( const makVrv::DtUniqueID& editId,
         makVrv::DtChannel& initiatingChannel, double waitTimeAfterComplete = 0.,
         const makVrv::DtSelectionManager::IdSet& editing = makVrv::DtSelectionManager::IdSet());

      virtual bool canSetActivationTime() const;

      virtual bool canShowForces() const;

      virtual void setForce(int);
      int force() const;

      virtual void monitorObjectRemoval(bool);

      virtual void setEventProcessingEnabled( bool value );

      virtual void clearEventProcessor();

      virtual bool embarkationAllowed() const;
      virtual void setEmbarkationAllowed(bool);

      virtual bool canEmbark() const;

      virtual void setCanEmbark(bool);

      virtual void setDoNotClamp(bool);
      bool doNotClamp() const;

      virtual bool needsEmbarkOnCheck() const;

      virtual void setIgnoreNextLeftButtonRelease(bool b);
      virtual void setEditStartedByDoubleClick(bool);

      virtual void setCreationEndedWithDoubleClick(bool creationEndedWithDoubleClick);

      virtual bool isCreationEndedWithDoubleClick() const;

      virtual bool isObjectValidForCreation();

      virtual makVrv::DtIntersector::IntersectProperties intersectorPickMask() const;

      virtual DtUUID uuid() const;

      virtual void setInterfaceContentMessage(const std::string& name, const DtSimInterfaceContent&);
      virtual void removeInterfaceContentMessage(const std::string&);
      const ContentMessages& contentMessages() const
      {
         return myContentMessages;
      }

      virtual HandlerType type() const = 0;

      virtual std::list<DtSimInterfaceContent*> contentMessagesToList() const;

      virtual void sendContentMessages();

      virtual VrfObjectEditFacadeList objectFacades() const;

      virtual void setAllowCreationOnMouseClick(bool flag);

      virtual void setLabel(const std::string&);
      virtual std::string label() const;

      virtual bool allowCreationOnMouseClick() const;

      virtual void setEventProcessor(DtVrfObjectManipulationEventProcessor*);

      virtual DtVector clampToGround(const DtVector&, int clampFlag = -1) const;
      virtual DtGeodeticCoord clampToGround(const DtGeodeticCoord&, int clampFlag = -1) const;

      virtual void setAttachObjectToMouse(bool);

      virtual bool attachObjectToMouse() const;

      virtual void setHeading(double value);
      virtual double heading() const;

      virtual void setPitch(double value);
      virtual double pitch() const;

      virtual void setLocation(const DtVector& loc);
      virtual void setLocation(const DtVector& loc, double altAboveGround);

      virtual void stop();

      virtual void deferredStop();

      virtual int objectCount() const;

      virtual bool createVrfObject();
      virtual bool createVrfObject(DtVrfObjectFacadeInterface* objectImage);

      virtual bool modifyVrfObjects();
      virtual bool modifyVrfObject(DtVrfObjectFacadeInterface* objectImage);

      virtual DtVrfObjectFacadeInterface* createAndAddLocalRepresentation(DtVrlinkSimulatedBaseStateView* editStateView = 0);
      virtual DtVrfObjectFacadeInterface* createLocalRepresentation(DtVrlinkSimulatedBaseStateView* editStateView = 0) = 0;

      virtual DtVrfObjectFacadeInterface* createAndAddLocalRepresentation(DtVrlinkSimulatedBaseStateView* editStateView,
         makVrv::DtUniqueID sceneObjectId, DtVrlinkSimulatedBaseStateView* principalStateView);
      virtual DtVrfObjectFacadeInterface* createLocalRepresentation(DtVrlinkSimulatedBaseStateView* editStateView,
         makVrv::DtUniqueID sceneObjectId, DtVrlinkSimulatedBaseStateView* principalStateView) = 0;

      virtual void initializeEventProcessor();

      virtual void setOverlay(const std::string& name);
      virtual std::string overlay() const;
      virtual std::string defaultOverlayForCreatingObject() const;

      virtual std::string getNextCreatingName(bool includeCurrent = false);

      virtual void setAltitudeAboveGL( double alt, bool setInProcessor = true );

      virtual void setAltitudeAboveGLForAll( double alt, bool setInProcessor = true );

      virtual void setAltitudeAboveSL( double alt, bool setInProcessor = true );

      virtual void setAltitudeAboveSLForAll( double alt, bool setInProcessor = true );

      virtual bool hasObjectFacade(makVrv::DtUniqueID) const;

      virtual void setAltitudeClampType( DtAltitudeClampType type );
      DtAltitudeClampType altitudeClampType() const
      {
         return myAltitudeClampType;
      }

      virtual void setCreating(bool b);

      bool creating() const
      {
         return myCreating;
      }

      virtual DtVrfObjectFacadeInterface* principalObjectImage() const;
      virtual makVrv::DtUniqueID principalObjectID() const;
      virtual std::set<makVrv::DtUniqueID> elementIDs() const;

      virtual void setUserData(const std::string& userData);
      virtual const std::string& userData() const;

      virtual void setExtendedLabels(const std::map<int, DtString>&);
      virtual const std::map<int, DtString>& extendedLabels() const;

      virtual void setExtendedDataMap(const std::map<std::string, std::string>& extendedData);
      virtual void setExtendedDataMap(const std::map<DtString, DtString>& extendedData);
      virtual const std::map<std::string, std::string>& extendedDataMap() const;
      virtual void setExtendedData(const std::string& key, const std::string& value);
      virtual void removeExtendedData(const std::string& key);
      virtual std::string extendedData(const std::string& key) const;

      virtual void slot_onComplete();
      virtual void slot_onPlace(makVrv::DtUniqueID, const DtVector&, double altAboveGround);
      virtual void slot_onEditComplete(makVrv::DtUniqueID, const DtVector&, double altAboveGround);
      virtual void slot_onLocationChanged( const DtVector& location, double altAboveGround );
      virtual void slot_onAltitudeIsDragging(bool);

      virtual void hideObject( const makVrv::DtUniqueID& id, bool hide );

      virtual void setPublishObject(bool);
      virtual bool publishObject() const;

      virtual void setObjectName(const std::string& name);
   
      virtual void setUUIDForCreation(const DtUUID&);
      virtual const DtUUID& uuidForCreation() const;

      virtual bool isUniqueName() const;

      virtual double groundHeight( const DtVector& localPosition, DtVector* localGround = 0,
         const std::vector<makVrv::DtUniqueID>& ignore = std::vector<makVrv::DtUniqueID>()) const;

      virtual void setAltitudeAllowed(bool);
      bool altitudeAllowed() const;

      bool pitchAllowed() const;

      virtual const std::string& objectName() const;

      virtual bool anchorMouseToOrigin() const;

      virtual bool anchorPositionIsMouse() const;

      virtual void setAnchorPosition(const DtGeodeticCoord&);

      virtual DtVector localLocation();

      virtual DtVector convertGeocentricToGround(const DtVector& geoc, double& altitude) const;

      virtual void setShowPropertiesDialogBeforeCreate(bool);
      virtual bool showPropertiesDialogBeforeCreate() const;

      virtual bool keywordsContain(const std::string&) const;
      virtual std::string keyword(const std::string&) const;
      virtual std::string value(const std::string&) const;
      virtual void addKeyword(const std::string&);
      virtual void removeKeyword(const std::string&);

      virtual bool waitingToStop() const;

      virtual void setEditingType(DtEditingType);
      DtEditingType editingType() const
      {
         return myEditingType;
      }

      virtual void setEmbarkationInformation(makVrv::DtUniqueID, bool);
      virtual makVrv::DtUniqueID embarkedOn() const;

      virtual std::vector<makVrv::DtElementID> ignoreList() const;

      virtual void setOverrideIdsToIgnore(const std::vector<makVrv::DtUniqueID>& overrideIgnore);

      virtual const std::vector<makVrv::DtElementID>& unifiedIgnoreList() const;

      virtual void slot_onAltitudeChanged(const DtVector&, double);

      virtual void cancel();

      virtual void setFacadesVisible(bool);

      virtual bool noStyle() const;

      virtual void slot_onHeadingChanged( double heading );
      virtual void slot_onPitchChanged( double heading );

      virtual void setHeadingOffset(double d);

      virtual void setPitchOffset(double d);

      virtual void disconnectPlacement();

      virtual void setGroundClampOnPlacement(bool);
      virtual bool groundClampOnPlacement() const;
      
      virtual void notifyOnFinalFacade(DtVrfObjectManipulationHandlerBaseClass*);
      virtual void removeNotifyOnFinalFacade(DtVrfObjectManipulationHandlerBaseClass*);

      virtual void connectPlacement();

      virtual DtVector centerOfMass() const;

      virtual DtVector sumOfAllLocations() const;

      virtual void updateOffsetsBasedOnMousePosition(const DtVector& centerOfMass, const DtGeodeticCoord&,
         bool usImagePoints = false);

      virtual void setSignalOnMultiSelectionComplete(bool);

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

      virtual void setSelectionCount(int);
      virtual void parseKeywords(const std::string&);

      virtual bool warpMouseToOrigin() const;
      virtual void setWarpMouseToOrigin(bool);

      boost::signals2::signal<void (bool)> signal_embarkationAllowedChanged;

      boost::signals2::signal<void (bool)> signal_showPropertiesDialog;

      boost::signals2::signal<void (bool)> signal_attachObjectToMouse;

      boost::signals2::signal<void (DtVrfObjectFacadeInterface*, DtVrlinkSimulatedBaseStateView* editStateView)> signal_preVisualization;

      boost::signals2::signal<void (DtVrfObjectFacadeInterface*, bool)> signal_objectFacadeCreated;

      boost::signals2::signal<void (const DtEntityType&, int)> signal_started;

      boost::signals2::signal<void (DtVrfObjectManipulationHandlerBaseClass*)> signal_multiSelectonCreationComplete;

      struct ObjectManipulationData
      {
         ObjectManipulationData() : myOwnsContentMessages(false), color(0), appearance(0), projected(false),
            physicalLineHeight(0.), physicalLineWidth(0.), isClosedFigure(false) , isProjected(false), embarkId(0), useSlotIfAvailable(false), initialUUID(DtUUID::nullUUID()) {};

         ObjectManipulationData(const ObjectManipulationData& omd) :
         entityType(omd.entityType)
         , createdEntityType(omd.createdEntityType)
         , objectName(omd.objectName)
         , force(omd.force)
         , positions(omd.positions)
         , heading(omd.heading)
         , pitch(omd.pitch)
         , isProjected(omd.isProjected)
         , isClosedFigure(omd.isClosedFigure)
         , clamped(omd.clamped)
         , isAggregated(omd.isAggregated)
         , userData(omd.userData)
         , isPublished(omd.isPublished)
         , extendedData(omd.extendedData)
         , extendedLabels(omd.extendedLabels)
         , myOwnsContentMessages(true)
         , color(omd.color)
         , appearance(omd.appearance)
         , overlay(omd.overlay)
         , projected(omd.projected)
         , physicalLineHeight(omd.physicalLineHeight)
         , physicalLineWidth(omd.physicalLineWidth)
         , embarkId(omd.embarkId)
         , useSlotIfAvailable(omd.useSlotIfAvailable)
         , initialUUID(omd.initialUUID)
         {
            setContentMessages(omd.myContentMessages);
         }

         virtual ~ObjectManipulationData()
         {
            if (myOwnsContentMessages)
            {
               deleteContentMessages();
            }
         }

         void deleteContentMessages()
         {
            std::list<DtSimInterfaceContent*>::iterator iter = myContentMessages.begin();
            while (iter != myContentMessages.end())
            {
               delete *iter;
               ++iter;
            }

            myContentMessages.clear();
            myOwnsContentMessages = false;
         }

         void setContentMessages(const ContentMessages& messages)
         {
            if (myOwnsContentMessages)
            {
               deleteContentMessages();
            }

            ContentMessages::const_iterator iter = messages.begin();
            while (iter != messages.end())
            {
               myContentMessages.push_back(iter->second->clone());
               ++iter;
            }
         }

         void setContentMessages(const std::list<DtSimInterfaceContent*>& messages)
         {
            if (myOwnsContentMessages)
            {
               deleteContentMessages();
            }

            std::list<DtSimInterfaceContent*>::const_iterator iter = messages.begin();
            while (iter != messages.end())
            {
               myContentMessages.push_back((*iter)->clone());
               ++iter;
            }
         }

         void addContentMessage(const DtSimInterfaceContent& message)
         {
            myContentMessages.push_back(message.clone());
         }

         DtEntityType entityType;
         DtEntityType createdEntityType;  
         std::string objectName;
         int force;
         std::vector<DtVector> positions;
         double heading;
         double pitch;
         bool clamped;
         bool isProjected;
         bool isAggregated;
         std::string userData;
         bool isPublished;
         unsigned int color;
         unsigned int appearance;
         bool projected;
         double physicalLineHeight;
         double physicalLineWidth;
         bool isClosedFigure;
         std::map<std::string, std::string> extendedData;
         std::map<int, DtString> extendedLabels;
         std::list<DtSimInterfaceContent*> myContentMessages;
         bool myOwnsContentMessages;
         std::string overlay;
         makVrv::DtUniqueID embarkId;
         bool useSlotIfAvailable;
         DtUUID initialUUID;
      };

      boost::signals2::signal<void (bool)> signal_altitudeAllowedChanged;

      boost::signals2::signal<void ( const ObjectManipulationData& )> signal_createObject;

      boost::signals2::signal<void (const DtString&, const DtString&)> signal_createTerrainProp;

      boost::signals2::signal<void (DtVrfObjectManipulationHandlerBaseClass*)> signal_stopped;

      boost::signals2::signal<void (DtVrfObjectManipulationHandlerBaseClass*)> signal_eventProcessorRemoved;

      boost::signals2::signal<void (DtVrfObjectManipulationHandlerBaseClass*)> signal_complete;

      boost::signals2::signal<void (const DtVector& )> signal_locationChanged;

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

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

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

      boost::signals2::signal<void (const DtVector&)> signal_placement;
      
      boost::signals2::signal<void (DtVrfObjectManipulationHandlerBaseClass*)> signal_restoreSelectionState;

      boost::signals2::signal<void (const makVrv::DtUniqueID&)> signal_principalStateViewUpdated;

      boost::signals2::signal<void (DtVrfObjectFacadeInterface*)> signal_objectFacadeAboutToBeRemoved;

      boost::signals2::signal<void (int)> signal_forceChanged;

   protected:
      virtual void clearConnections();

      virtual void slot_simObjectEntryToBeRemoved(const makVrv::DtSimObjectEntry&);

      virtual bool typeIsValidForEditingByHandler(const makVrv::DtElementEntry::ElementType&, const DtEntityType&) const;

      virtual void slot_onCancel(bool escPressed);

      virtual std::string stripNumbers(const std::string& base) const;

      virtual double defaultAltitudeOffsetFor(DtVrfObjectFacadeInterface* i) const;

      virtual void warpMouseToLocation( makVrv::DtChannel* channel, const DtVector& location ) const ;

      virtual void initializeEdit();

      virtual void slot_onPrincipalStateViewUpdated(DtVrlinkSimulatedBaseStateView* principalStateView,
         const makVrv::DtUniqueID& principalSceneObjectId );

      virtual void slot_onStateViewUpdated( DtVrlinkSimulatedBaseStateView* editStateView, makVrv::DtUniqueID sceneObjectId,
         DtVrlinkSimulatedBaseStateView* principalStateView);

      virtual void initializeLocationChangeConnections();

      virtual bool centerOn(const makVrv::DtUniqueID& id, DtVector* centerPos = 0, const DtVector* centerHere = 0,
         bool centerOnOnlyIfMousePositionIsOffWindow = true) const;

      virtual void setObjectImageAsAnchor(DtVrfObjectFacadeInterface* objectImage, const DtVector& geocLocation,
         bool resetOrigin = false);

      virtual void setHeading(DtVrfObjectFacadeInterface* objectImage, double heading);
      virtual void setPitch(DtVrfObjectFacadeInterface* objectImage, double heading);
      virtual std::string defaultOverlayFor(const DtRwNLengthStringVector&) const;
      virtual std::string defaultOverlayFor(const DtModelSetEntry* e) const;

      virtual bool continueWithHandlerCancelOnLastObjectRemoval();
      virtual bool isOkToStopEditing();
      virtual void handlerDisabled();

      virtual void setObjectImageRelativeToPrincipal(DtVrfObjectFacadeInterface* objectImage,
         const DtVector& thisGeocLocation, const DtTaitBryan& thisGeocOrientation,
         const DtVector& prGeocLocation, const DtTaitBryan& prGeocOrientation);

      virtual void setObjectImageRelativeTo(DtVrfObjectFacadeInterface* objectImage,
         const DtVector& thisGeocLocation, const DtVector& prGeocLocation, bool relativeOnly = false);

      virtual void setObjectImageRelativeToAltitudeOnly(DtVrfObjectFacadeInterface* objectImage,
         const DtVector& thisGeocLocation, const DtVector& prGeocLocation);

      virtual void initializeInterfaceForEdit(DtVrfObjectFacadeInterface*, makVrv::DtUniqueID,
         const makVrv::DtVrlinkSimulatedBaseState&, const DtVector& principalLocation, const DtTaitBryan& principalOrientation);
      virtual void calculateAnchor(const DtVector& localAnchor);
      virtual void calculateAnchorBasedOnMousePosition(makVrv::DtChannel& channel);

      virtual void initializeAltitudeAboveTerrainForEdit(double curAlt, const DtVector& curPos,
         DtVrfObjectFacadeInterface* iFace);

      virtual void postCreateInitialize(DtVrfObjectFacadeInterface*);

      virtual bool clampOnPlacement() const;

      virtual bool clampAtClosestPolygonOnPlacement() const;

      virtual void updateOffsetsBasedOnMousePosition();

      virtual bool setupIgnoreLists();

      virtual void removeObjectBecauseOfDeletion(DtVrfObjectFacadeInterface*);

      virtual void slot_elementsCreated(const std::vector<makVrv::DtElementID>&);

   protected:
      bool           myCreating;
      bool           myAttachObjectToMouse;
      int            myForce;
      makVrv::DtDe&  myDe;
      bool           mySignalManipulation;
      bool           myAllowCreationOnClick;
      std::string    myObjectName;
      std::string    myOverlay;

      DtVrfObjectManipulationEventProcessor* myEventProcessor;
      bool           myOwnsEventProcessor;
      bool           myAltitudeIsDragging;
      bool           myAltitudeAllowed;
      bool           myClearedProcessor;
      makVrv::DtChannel* myHiddenChannel;

      std::string    myUserData;
      std::map<std::string, std::string> myExtendedData;
      std::map<int, DtString> myExtendedLabels;

      std::string    myKey;
      std::string    myKeyData;
      DtCreationSignalType mySignalCreation;

      bool mySignalOnMultiSelectionComplete;

      makVrv::DtSelectionManager::IdSet myEditingObjects;

      boost::signals2::connection myObjectRemovalConnection;

      VrfObjectEditFacadeList myObjectImages;
      DtReferenceEllipsoid* myReferenceForConversion;
      DtAltitudeClampType myAltitudeClampType;

      bool myOverlayChanged;
      bool myIgnoreFirstMouseClick;
      bool myShowPropertiesDialogBeforeCreate;
      DtGeodeticCoord myAnchorPosition;
      DtTimedSection* myDeferredStopTimer;
      double myTotalTimeElapsed;
      double myDeferStopFor;
      bool myGroundClampOnPlacement;

      bool myPublishObject;
      std::vector<std::string> myKeywords;

      int myCursorCount;
      bool myFacadesVisible;
      DtVrlinkSimulatedBaseStateView* myPrincipalStateView;

      ContentMessages myContentMessages;
      DtEditingType myEditingType;

      int mySelectionCount;
      bool myMultiSelection;

      DtUUID myUUIDForCreation;

      typedef std::map<DtVrlinkSimulatedBaseStateView*, makVrv::DtSignalConnectionManager*> StateViewConnections;
      StateViewConnections myStateViewConnections;
      bool myShowingPropertiesDialog;
      makVrv::DtSignalConnectionManager myConnections;
      makVrv::DtSignalConnectionManager myCreateConnections;
      makVrv::DtUniqueID myEmbarkOnId;
      bool myEmbarkInSlotIfAvailable;

      bool myOverlayHasBeenSet;
      bool myWarpMouseToOrigin;

      mutable bool myCheckedEmbark;
      mutable bool myCanEmbark;
      bool myDoNotClamp;

      mutable std::vector<makVrv::DtElementID> myUnifiedIgnoreList;
      mutable std::set<makVrv::DtUniqueID> myDIGuyIdsIgnored;
      mutable std::vector<makVrv::DtUniqueID> myModelIds;

      std::vector<makVrv::DtElementID> myOverrideIdsToIgnore;
      std::vector<DtVrfObjectManipulationHandlerBaseClass*> myNotifyOnFinalFacade;

      bool myCreationEndedWithDoubleClick;
   };

   class DtVrfObjectManipulationHandlerCreatorInterface
   {
   public:
      virtual DtVrfObjectManipulationHandlerBaseClass* create() const = 0;
   };

   template <typename T>
   class DtVrfObjectManipulationHandlerCreator : public DtVrfObjectManipulationHandlerCreatorInterface
   {
   public:
      DtVrfObjectManipulationHandlerCreator(makVrv::DtDe& de)
      : myDe(de)
      {
      }

      virtual ~DtVrfObjectManipulationHandlerCreator()
      {
      }

      virtual DtVrfObjectManipulationHandlerBaseClass* create() const
      {
         return new T(myDe);
      }

   protected:
      makVrv::DtDe& myDe;
   };
   
}