DtVrfObjectManipulationHandlerBaseClass.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/DtVrfObjectFacadeInterface.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtEntityState.h>
#include <vrvCore/DtUniqueID.h>
#include <vlutil/vlPerformanceStats.h>

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

#include <boost/signal.hpp>

namespace makVrv
{
   class DtDe;
   class DtChannel;
}

class DtEntityType;
class DtString;

namespace makVrf
{
   enum DtCreationSignalType
   {
      DtNoCreationSignal = 0,
      DtSignalCreationAndStop,
      DtSignalCreationAndContinue,
      DtCreateFromEdit
   };

   class DtVrfObjectManipulationEventProcessor;

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

   class DT_DLL_VRFGUICORE DtVrfObjectManipulationHandlerBaseClass
   {
   public:
      typedef std::vector<DtVrfObjectFacadeInterface*> VrfObjectEditFacadeList;

   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. );

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

      virtual void setAllowCreationOnMouseClick(bool flag);

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

      virtual bool allowCreationOnMouseClick() const;

      virtual DtVector clampToGround(const DtVector&) const;
      virtual DtGeodeticCoord clampToGround(const DtGeodeticCoord&) const;

      virtual void setAttachObjectToMouse(bool);

      virtual bool attachObjectToMouse() const;

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

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

      virtual void stop();

      virtual void deferredStop();

      virtual bool createVrfObject() = 0;

      virtual bool modifyVrfObjects() = 0;

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

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

      virtual void initializeEventProcessor();

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

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

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

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

      virtual void setAltitudeClampType( DtAltitudeClampType type );

      void setCreating(bool b)
      {
         myCreating = b;
      }

      bool creating() const
      {
         return myCreating;
      }

      virtual DtVrfObjectFacadeInterface* principalObjectImage() const;
      virtual makVrv::DtUniqueID principalObjectID() const;

      virtual void setUserData(const std::string& userData);
      virtual const std::string& userData() 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 bool isUniqueName() const;

      virtual double groundHeight( const DtVector& localPosition, DtVector* localGround = 0 ) const;
      
      virtual void setAltitudeAllowed(bool);
      bool altitudeAllowed() const;

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

      virtual void setAnchorToOrigin(bool);
      virtual bool anchorToOrigin() const;

      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 bool waitingToStop() const;

      virtual void cancel();

      virtual bool noStyle() const;

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

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

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

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

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

      boost::signal<void ( const DtEntityType&, std::string, int, const std::vector<DtVector>&, double, bool, bool, std::string, bool )> signal_createObject;

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

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

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

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

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

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

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

      boost::signal<void ()> signal_principalStateViewUpdated;

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

   protected:

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

      virtual void slot_onAltitudeChanged(const DtVector&, double);

      virtual void slot_onHeadingChanged( double heading );

      virtual void slot_onCancel();

      virtual std::string stripNumbers(const std::string& base) 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 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 setObjectImageRelativeToPrincipal(DtVrfObjectFacadeInterface* objectImage,
         const DtVector& thisGeocLocation, const DtTaitBryan& thisGeocOrientation,
         const DtVector& prGeocLocation, const DtTaitBryan& prGeocOrientation);

      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 postCreateInitialize();

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

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

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

      std::string    myUserData;

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

      VrfObjectEditFacadeList myObjectImages;
      DtReferenceEllipsoid* myReferenceForConversion;
      DtAltitudeClampType myAltitudeClampType;

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

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

      int myCursorCount;
   };

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