DtSelectionManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2010 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtSelectionManager.h,v $ $Revision: 1.21 $ $State: Exp $
******************************************************************************/


#pragma once
#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtElementData.h>
#include <vrvCore/DtElementEntry.h>
#include <vrvCore/DtMouseEvent.h>
#include <vrvCore/DtUniqueID.h>
#include <set>
#include <queue>

namespace makVrv
{
   class DtDe;
   class DtDriverManager;
 
   class DT_DLL_VRVCORE DtSelectionManager : public DtVirtualBaseClass
   {
   public:
   
      typedef std::set<DtUniqueID> IdSet;

      enum SelectionMode
      {
         SelectionModeAll      = 0,
         SelectionModeEntities = 1,
         SelectionModeTerrain  = 2
      };

      enum SelectionType
      {
         NoValidSelection,
         Entity,
         Prop,
         BuoyOrBeacon,
         Terrain,
         Aggregate,
         Observer,
         ControlObject,
         OverlayObject,
         Intervisibility,
         Feature,
         Mixed 
      }; 

      enum SelectionOperation
      {
         NoOperation = 0,
         AddToSelection,
         RemoveFromSelection,
         MultipleSelection,
         SetSelection,       
         ClearSelection,
         MaintainSelectionIfSelected   
      };

      static DtSelectionManager& instance(DtDe& de);
         
      ~DtSelectionManager();
      
      void performSelectionOperation(SelectionOperation op, const IdSet& ids);

      void setCurrentSelections( const IdSet& selections );
      
      const DtSelectionManager::IdSet& currentSelections() const;
      
      void addToCurrentSelection( const IdSet& adds );

      void maintainCurrentSelectionIfSelected( const IdSet& maintain );

      void removeFromCurrentSelection( const IdSet& removes );

      void toggleFromCurrentSelection( const IdSet& toggles );

      void removeFromCurrentSelection(
         const DtElementData::UniqueIdList& removes );
     
      SelectionMode selectionMode() const;
      void setSelectionMode( SelectionMode mode );
      
      bool isSelectable( DtUniqueID id ) const;
      
      bool isSelectable( const DtElementEntry* entry ) const;

      bool isSelected( DtUniqueID id ) const;     

      SelectionType selectionType() const;
         
      virtual bool propSelectionMajorityTransparent();
      
      virtual void slot_onElementsRemoved( 
         const DtElementData::UniqueIdList& elementIds);
         
      virtual void backupCurrentSelection();

      virtual bool restoreCurrentSelection();
      
      bool selectionIsVertex( const IdSet& selection );

      bool objectIsVertex( const DtUniqueID& id );     
      DtUniqueID parentId( const DtUniqueID& id );

      virtual bool allItemsWantVertexSelection(const IdSet&) const;

      void addWantsVertexSelection(DtElementEntry::ElementType);

      void removeWantsVertexSelection(DtElementEntry::ElementType);

      bool wantsVertexSelection(DtElementID) const;

      boost::signal<void (const IdSet& selected, const IdSet& deselected, 
         SelectionType newType, 
         SelectionType oldType)> signal_currentSelectionChanged;

      boost::signal<void (const DtUniqueID& id, const DtUniqueID& parentId)> 
         signal_vertexSelected;
         
      boost::signal<void (const DtUniqueID& id, const DtUniqueID& parentId)> 
         signal_vertexDeselected;
         
      boost::signal<void (const IdSet& entityIds)> signal_entityInfoToggled;

      boost::signal<void ()> signal_selectionModeChanged;

      virtual void addSelectableObjectType(DtElementEntry::ElementType type,
         SelectionMode = SelectionModeAll);
      virtual void removeSelectableObjectType(DtElementEntry::ElementType type,
         SelectionMode);
      virtual void removeSelectableObjectTypeFromAllModes(
         DtElementEntry::ElementType type);
      virtual bool objectTypeSelectable( DtElementEntry::ElementType type,
         SelectionMode mode ) const;

      virtual bool objectTypeSelectable( DtElementEntry::ObjectType type) const;

      static SelectionOperation selectionOperationForMouseEvent(
         const DtMouseEvent& mouseEvent);

      static bool typeSupportsMultipleSelection(DtElementEntry::ObjectType type, 
         bool vertexSelectsParent );

   protected:
   
      DtSelectionManager(DtDe& de);
         
      void addToCurrentSelection( DtUniqueID id );

      void removeFromCurrentSelection( DtUniqueID id );
      
      void announceCurrentSelectionChanged( const IdSet& selected, 
         const IdSet& deselected, SelectionType oldType );
      
      void updateSelectionDisplay( const IdSet& selected, 
         const IdSet& deselected );

      void updateSelectionType();

      SelectionType elementSelectionType( DtElementEntry* entry ) const;
      
      void convertVertexIdsToParentIds( const IdSet& in, IdSet& out ); 

   protected:
      typedef std::set<DtElementEntry::ElementType> WantsVertexSelection;
      typedef std::set<DtElementEntry::ElementType> ElementTypeSet;
      typedef boost::unordered_map<SelectionMode, ElementTypeSet> 
         SelectionModeMap;
      typedef std::queue<IdSet> IdSetQueue;


      DtDe& myDe;
      IdSet myCurrentSelections;
      SelectionMode mySelectionMode;      
      bool myIgnoreSelectionChanges;
      bool myIgnoreSelectionModeChanges;     
      SelectionType mySelectionType;
      IdSetQueue myBackupSelections;
      WantsVertexSelection myWantsVertexSelection;
      SelectionModeMap mySelectionModeMap;
      DtSignalConnectionManager mySignals;
   };
}