DtControllableShapeFacade.h

Go to the documentation of this file.

// /******************************************************************************
// ** Copyright (c) 2009 MAK Technologies, Inc.
// ** All rights reserved.
// ******************************************************************************/
// /******************************************************************************
// ** $RCSfile: DtControllableShapeFacade.h,v $ $Revision: 1.20 $ $State: Exp $
// ******************************************************************************/
// 
// //! \file DtControllableShapeFacade.h
// //! \brief Interaction makVrv::DtControllableShapeFacade class.
// //! \ingroup vrvCore
// 
// #ifndef DtControllableShapeFacade_H_
// #define DtControllableShapeFacade_H_
// 
// #include <vrvCore/vrvCore.h>
// #include <vrvCore/DtUniqueID.h>
// #include <vrvCore/DtBaseConnection.h>
// #include <vrvCore/DtTacticalGraphicStateListener.h>
// #include <vrvCore/DtObjectFacadeInterface.h>
// 
// #include <matrix/vlVector.h>
// 
// #include <boost/signal.hpp>
// 
// #include <vector>
// #include <string>
// 
// namespace makVrv
// {
//    class DtUnicode;
//    class DtMouseState;
//    class DtEnvironmentalVisualizerSet;
//    class DtAgentManagerInterface;
// 
//    //! \brief The base class for tactical graphic facades
//    //! \ingroup vrvCore
//    class DT_DLL_VRVCORE DtControllableShapeFacade : public DtObjectFacadeInterface
//    {
//    public:
// 
//       //! \brief CTOR
//       DtControllableShapeFacade(DtAgentManagerInterface& sceneInterface, int modelSet, const std::string& shape = "Route");
// 
//       //! \brief DTOR
//       virtual ~DtControllableShapeFacade();
// 
//       //! \brief Sets all the points of the line to the supplied list.  Vertices are in local database coordinates
//       virtual void setControlPoints(const std::vector<DtVector>&);
// 
//       //! \brief Add a control point to the end of the control point list
//       virtual DtUniqueID addControlPoint(const DtVector& position);
// 
//       //! \brief Insert a control point at the specified index
//       //! \retval Returns false if the index was invalid
//       virtual bool insertControlPoint(const DtVector& position, int index);
// 
//       //! \brief Remove a control point at the specified index
//       //! \retval Returns false if the index was invalid
//       virtual bool removeControlPoint(int index);
// 
//       //! \brief Returns the model set being visualized
//       int modelSet() const;
// 
//       //! \brief Move a control point at the specified index to a new position
//       //! \retval Returns false if the index was invalid
//       virtual bool moveControlPoint(const DtVector& position, int index);
// 
//       //! \brief Realize the shape with the specified model definition
//       virtual void setModelDefinition(const std::string& modelDefinition);
// 
//       //! \brief Set the color of the shape in RGBA
//       virtual void setColor(float r,float g,float b,float a);
// 
//       //! \brief Set the origin of the controllable shape
//       virtual void setOrigin(const DtVector& position);
// 
//       //! \brief Get the origin of the controllable shape
//       virtual DtVector origin() const;
// 
//       //! \brief Set the whole facade object's selection state
//       virtual void setSelected(bool selected);
//       
//       //! \brief Get the whole facade object's selection state
//       virtual bool selected() const;
// 
//       //! \brief Set the selection state for a specific control point
//       virtual void setSelected(int index, bool selected);
//       
//        //! \brief Set the selection state for a specific control point
//       virtual void setSelected(const DtUniqueID& vertex, bool selected);
// 
//       //! \brief Get the selection state for a specific control point
//       virtual bool selected(int index) const;
//       
//        //! \brief Get the selection state for a specific control point
//       virtual bool selected(const DtUniqueID& vertex) const;
//       
//       //! Set true to allow this object to be picked
//       virtual void setPickable( bool pickable );
// 
//       //! \brief Set the info text for a particular control point
//       virtual void setInfoText(int index, const DtUnicode& infoText);
// 
//       //! \brief Set the widget indicators on or off
//       virtual void setIndicatorsEnabled(bool enabled);
// 
//       //! \brief Set the widget indicators to be on only for selected objects
//       virtual void setIndicatorsOnSelect(bool enabled);
// 
//       //! \brief Set if the Height Above Terrain (HAT) line is visible.
//       void setHatLineVisible( bool visible );
// 
//       //! \brief Set whether or not the shape vertices are visible
//       virtual void setShapeVertexVisible( bool visible );
// 
//       //! Set whether the shape is visible or hidden
//       virtual void setVisible( bool visible );
// 
//       //! Enable or disable widget events for the control points
//       virtual void setWidgetEventsEnabled(bool enabled);
// 
//       virtual DtUniqueID uniqueID() const;
// 
//       virtual void setIndicatorModelDefinitions(
//          const std::string& normalTheme,
//          const std::string& activeTheme,
//          const std::string& selectedTheme,
//          const std::string& multiSelectedTheme);
// 
//       //! Returns the number of vertices in this object
//       virtual int numVertices() const;
// 
//       //! Returns the vertex at the specified position
//       virtual DtVector position(int) const;
// 
//       //! Returns the visualizer based on the name, or 0 if does not exists
//       virtual DtStateVisualizer* visualizer(const std::string&);
// 
//       DtEnvironmentalVisualizerSet* visualizer()
//       {
//          return myVisualizer;
//       }
// 
//    protected:
//       //! Vertex Indicator signal forwarders
//       void slot_vertexMouseDown( DtMouseState& mouseState,
//          const DtUniqueID& id, const std::string& displayEngineName,
//          const std::string& windowName, const std::string& channelName );
//       void slot_vertexMouseUp( DtMouseState& mouseState,
//          const DtUniqueID& id, const std::string& displayEngineName,
//          const std::string& windowName, const std::string& channelName );
//       void slot_vertexMouseDblClick( DtMouseState& mouseState,
//          const DtUniqueID& id, const std::string& displayEngineName,
//          const std::string& windowName, const std::string& channelName );
// 
//       //! \brief Copy CTOR
//       DtControllableShapeFacade(DtControllableShapeFacade&);
// 
//    protected:
//       DtEnvironmentalVisualizerSet*  myVisualizer;
//       DtBaseConnection                    myBaseConnection;
//       DtTacticalGraphicStateListener        myListener;
//    };
// }
// 
// #endif
//