DtIntervisibilityDriver.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtDriver.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtBaseConnection.h>

#include <vrvUtil/DtUnicode.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <boost/unordered_map.hpp>
#include <matrix/vlVector.h>

namespace makVrv
{

   class DtDe;
   class DtChannel;
   class DtCoordinateSystem;
   class DtDisplayUnitsConverter;
   class DtBasicEditingEventProcessor;
   class DtElementDefinitionManager;
   class DtIntervisibilityElement;
   class DtIntervisibilityStateListener;
   class DtIntervisibilityStateListenerCreator;
   class DtIntersectorsContainer;
   class DtCoordinateSystem;

   class DT_DLL_VRVCORE DtIntervisibilityDriver : public DtDriver
   {
   public:

      typedef boost::unordered_map<DtElementID, DtIntervisibilityElement*> 
         ElementMap;
      typedef boost::unordered_map<DtElementID, DtIntervisibilityStateListener*>
         ListenerMap;
      typedef std::pair<DtElementID, DtVector> AttachPoint;
      typedef std::vector<AttachPoint> AttachPoints;

   public:

      DtIntervisibilityDriver( DtDe&, const std::string& className );

      virtual ~DtIntervisibilityDriver();

      virtual bool autoStart() const;

      DtIntervisibilityStateListener* findListener(DtElementID id);
      DtIntervisibilityElement* findElement(DtElementID id);

      virtual DtIntervisibilityElement* createIntervisibilityLine(
         const DtVector& startPoint, const DtVector& endPoint);

      virtual DtIntervisibilityElement* createIntervisibilityLine(
         const AttachPoints& = AttachPoints());

      const DtUnicode& intervisibilityLine() const;

      virtual DtIntervisibilityElement* createIntervisibilityFan(
         const DtVector& startPoint, const DtVector& endPoint);

      virtual DtIntervisibilityElement* createIntervisibilityFan(
         const AttachPoints& = AttachPoints());

      const DtUnicode& intervisibilityFan() const;

      DtIntervisibilityElement* creatingElement() const;
      DtIntervisibilityStateListener* creatingListener() const;

      const ElementMap& intervisibilityElements() const;

      virtual DtIntervisibilityElement* createIntervisibilityEntityFan(
         const DtVector& startPoint, const DtVector& endPoint);

      virtual DtIntervisibilityElement* createIntervisibilityEntityFan(
         const AttachPoints& = AttachPoints());

      const DtUnicode& intervisibilityEntityFan() const;

      virtual DtIntervisibilityElement* createRangeLine(const DtVector& startPoint);

      virtual DtIntervisibilityElement* createRangeLine(
         const DtVector& startPoint, const DtVector& endPoint);

      virtual DtIntervisibilityElement* createRangeLine(
         const AttachPoints & = AttachPoints());

      virtual const DtUnicode& rangeLine() const;

      void addListenerCreator(const std::string&, 
         DtIntervisibilityStateListenerCreator*);

      virtual void cancelChanges();

      virtual void destroy(DtElementID id);

      virtual void destroyAll();

      virtual void setAllowCreating(bool);

      virtual void setAllowEditing(bool);

      virtual DtIntervisibilityElement* create(const DtUnicode& definition, 
         const DtVector& startPoint, const DtVector& endPoint);

      static DtIntervisibilityDriver* findDriver(DtDe& de);

      const std::string& className() const
      {
         return myClassName;
      }

      static std::string theInstanceName();

      DtBaseConnection* connection()
      {
         return myConnection;
      }

      const DtBaseConnection* connection() const
      {
         return myConnection;
      }

   protected:
      virtual DtBasicEditingEventProcessor* createEventProcessor() const;

      virtual DtIntervisibilityStateListener* createListener(
         const std::string& definition) const;

      virtual DtIntervisibilityElement* createElement(
         DtIntervisibilityStateListener*, const DtUnicode& definition) const;

      virtual DtIntervisibilityElement* create(const DtUnicode& elementDefinitionName,
         const AttachPoints& = AttachPoints());

      virtual bool onTick();

      virtual bool onStart();

      virtual bool onStop();

      virtual void completeSetup();

      virtual void slot_onCurrentSelectionChanged(
         const DtSelectionManager::IdSet& selected,
         const DtSelectionManager::IdSet& deselected);

      virtual void select(const DtSelectionManager::IdSet&, bool);

      virtual void slot_onVertexElementHasMouseCursorStateChanged( const DtElementID& parentId, 
         const DtElementID& vertexElementId, bool hasMouseCursor );

      virtual void connectProcessorSignals();

      virtual void slot_locationChanged(const DtVector&, double altAboveGround);

      virtual void slot_altitudeChanged(const DtVector&, double);

      virtual void slot_altitudeIsDragging(bool);

      virtual void slot_place(DtUniqueID, const DtVector&, double altAboveGround);

      virtual void finishEditing();

      virtual void slot_dragStart(const DtSelectionManager::IdSet& set,
         const DtVector&);

      virtual void modifyEditingObjects(const DtVector& pos, double altAboveGround);

      virtual void resetSelectionForEditableObjects();

      virtual DtVector clamp(const DtVector&, double altAboveGround) const;

      virtual void elementsRemoved(const DtElementData::UniqueIdList&);

      void installElementDefinitions(DtElementDefinitionManager& manager);

      virtual void slot_coordinateSystemChanged();

      virtual void slot_intervisibilityObjectsShown(bool show);

      virtual void slot_rangeLinesShown(bool show);

   public:

      class DtIntervisibilityConnection : public DtBaseConnection
      {
      public:

         DtIntervisibilityConnection( DtDe& de );

         virtual ~DtIntervisibilityConnection();

         virtual DtVirtualBaseClass* findInstance( const std::string& instanceName );

         virtual void registerInstance( const std::string& instanceName, DtVirtualBaseClass* instance );

         virtual const DtDisplayUnitsConverter& displayUnitsConverter() const;

         virtual const DtCoordinateSystem& coordinateSystem() const;


      protected:

         DtDe& myDe;

      };

   protected:

      struct OriginalInformation
      {

         int myMovingVertex;
         DtUniqueID myMovingVertexId;
         bool mySelected;

         DtVector myStartPosition;
         DtElementID myStartAttachedId;
         DtVector myStartOffset;

         DtVector myEndPosition;
         DtElementID myEndAttachedId;
         DtVector myEndOffset;

         bool myHatLinesEnabled;
         bool myHatLinesOnSelectionOnly;
         bool myFixedDistance;

      };

   protected:

      typedef boost::unordered_map<DtElementID, OriginalInformation> Editing;
      typedef std::map<std::string, DtIntervisibilityStateListenerCreator*> 
         ListenerCreatorMap;

      DtDe& myDe;
      ElementMap myElements;
      ListenerMap myListeners;
      DtBasicEditingEventProcessor* myProcessor;
      std::string myClassName;
      DtBaseConnection* myConnection;
      bool myAllowEditing;
      bool myAllowCreating;
      bool myDistribute;

      DtSignalConnectionManager myConnections;

      DtIntervisibilityElement* myCreatingElement;
      DtIntervisibilityStateListener* myCreationListener;
      DtSignalConnectionManager myProcessorConnections;

      Editing myEditing;
      DtVector myEditingAnchorLocation;

      ListenerCreatorMap myListenerCreatorMap;
      DtChannel* myHiddenChannel;

      DtIntersectorsContainer* myIntersectors = nullptr;

      DtCoordinateSystem* myCoordinateSystem = nullptr;
   };


   class DT_DLL_VRVCORE DtIntervisibilityDriverCreator
      : public DtVirtualBaseClass
   {
   public:

      static DtIntervisibilityDriverCreator& instance( DtDe& de );

      static void registerInstance( DtDe& de, DtIntervisibilityDriverCreator* creator );

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

      virtual DtIntervisibilityDriver* create( DtDe& de ) const;

   };

}