rvc/hyperidx.h

Go to the documentation of this file.

#ifndef INC_RVC_HYPERIDX_H
#define INC_RVC_HYPERIDX_H

#ifndef INC_RVC_OBJECT_H
   #include <rvc/object.h>
#endif

#ifndef INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef INC_MI32_RECT_H
   #include <mi32/rect.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
struct HYPERLINK;
class POLYLINE;
namespace RVC {
   class DBASE_ELEMENT;
   class ELEMENT;
   class HYPERHANDLE;
   struct HYPERLINK;
   struct HYPERSHAPE;
   }
#endif


namespace RVC {

class HYPERINDEX : public RVC::OBJECT {
   public:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class LINK;
      class SHAPE;
      #endif // GENERATING_DOXYGEN_OUTPUT

      HYPERINDEX (
         );

      HYPERINDEX (
         const RVC::HYPERINDEX& obj
         );

      virtual ~HYPERINDEX (
         );

      RVC::HYPERINDEX& operator= (
         const RVC::HYPERINDEX& rhs
         );

      INT32 AddLink (
         const LINK& link                       
         );

      ERRVALUE AddLinkToShape (
         INT32 ShapeNum,                        
         INT32 LinkNum                          
         );

      INT32 AddShape (
         const SHAPE& shape                        
         );

      INT32 AddShape (
         const SHAPE& shape,                    
         const POLYLINE& Points                 
         );

      ERRVALUE ChangeShape (
         INT32 ShapeNum,                        
         const SHAPE& shape,                    
         const POLYLINE& Points                 
         );
         
      ERRVALUE ClearLink (
         INT32 LinkNum                          
         );

      ERRVALUE ClearShapePoints (
         INT32 ShapeNum                         
         );

      ERRVALUE DeleteShape (
         INT32 ShapeNum                         
         );
         
      INT32 FindShape (
         ELEMTYPE ElemType,                     
         INT32 ElemNum                          
         );

      ERRVALUE GetExtents (
         DRECT3D& rect                          
         );

      INT32 GetNumLinks (
         );

      INT32 GetNumShapes (
         );
         
      ERRVALUE Make (
         const RVC::OBJECT& parent,    
         const RVC::DESCRIPTOR& Descriptor,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,  
#ifdef RVC_CREDENTIALS_MANDATORY
         const char* Source,        
         const CREDENTIALS* Credentials 
#else
         const char* Source = 0,       
         const CREDENTIALS* Credentials = 0           
#endif
         );

      ERRVALUE ReadLink (
         INT32 LinkNum,                         
         LINK& link                             
         );

      ERRVALUE ReadShape (
         INT32 ShapeNum,                        
         SHAPE& shape                           
         );

      ERRVALUE ReadShape (
         INT32 ShapeNum,                        
         SHAPE& shape,                          
         POLYLINE& Points                       
         );
         
      ERRVALUE ReadShape (
         INT32 ShapeNum,                        
         SHAPE& shape,                          
         SIMPLE_ARRAY<INT32>& Links             
         );
         
      ERRVALUE ReadShape (
         INT32 ShapeNum,                        
         SHAPE& shape,                          
         POLYLINE& Points,                      
         SIMPLE_ARRAY<INT32>& Links             
         );
         
      ERRVALUE RemoveLinkFromShape (
         INT32 ShapeNum,                        
         INT32 LinkNum                          
         );

      ERRVALUE WriteLink (
         INT32 LinkNum,                         
         const LINK& link                       
         );

      ERRVALUE WriteShape (
         INT32 ShapeNum,                        
         const SHAPE& shape                     
         );

      ERRVALUE WriteShape (
         INT32 ShapeNum,                        
         const SHAPE& shape,                    
         const POLYLINE& Points                 
         );

      ERRVALUE WriteShape (
         INT32 ShapeNum,                        
         const SHAPE& shape,                    
         const SIMPLE_ARRAY<INT32>& Links       
         );

      ERRVALUE WriteShape (
         INT32 ShapeNum,                        
         const SHAPE& shape,                    
         const POLYLINE& Points,                
         const SIMPLE_ARRAY<INT32>& Links       
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      virtual ERRVALUE v_CloseObject ();
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent, const CREDENTIALS* Credentials);

      HYPERHANDLE* m_HyperHandle;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class HYPERINDEX::LINK {
   public:

      enum TYPE {
         TYPE_DISP2DWINDOW =  0,
//       TYPE_RasterColor           // Obsolete
         TYPE_Raster =        2,
         TYPE_Vector =        3,
         TYPE_CAD =           4,
         TYPE_Layout =        5,
         TYPE_Group =         6,
         TYPE_TIN =           7,
         TYPE_TextFile =      8,
         TYPE_ExternalFile =  9,
         TYPE_URL =           10,
         TYPE_FileByAttrib =  11,
         TYPE_URLByAttrib =   12,
         TYPE_Shape =         13,
         TYPE_SMLScript =     14,
         TYPE_LAST
         };

      enum REFTYPE {
         REFTYPE_Invalid = 0,
         REFTYPE_FilePath,       
         REFTYPE_ObjItem,        
         REFTYPE_URL,            
         REFTYPE_TableField      
         };

      enum POSITION {
         POSITION_Click = 0,     
         POSITION_Center,        
         POSITION_AsSaved,       
         POSITION_Max
         };

      enum SCALE {
         SCALE_1X = 0,           
         SCALE_FullView,         
         SCALE_AsSaved,          
         SCALE_Zoomed,           
         SCALE_ToMap,            
         SCALE_Max
         };

      LINK (
         );

      // Default copy constructor, destructor and operator=() are used

      bool CanUseScalePos (
         ) const;

      void Clear (
         );

      const MISTRING& GetDescription (
         ) const { return (m_Desc); }

      TYPE GetLinkType (
         ) const { return (m_LinkType); }
         
      double GetMapScale (
         ) const { return (m_MapScale); }

      const MISTRING& GetName (
         ) const { return (m_Name); }

      OBJTYPE GetObjType (
         ) const { return (GetObjType(m_LinkType)); }

      static OBJTYPE GetObjType (
         TYPE Type
         );

      POSITION GetPosition (
         ) const { return (m_PosnType); }
         
      const FILEPATH& GetRefFilePath (
         ) const { return (m_FilePath); }

      ERRVALUE GetRefObjItem (
         RVC::OBJITEM& ObjItem               
         ) const;

      ERRVALUE GetRefTableField (
         RVC::OBJECTNAME& TableName,         
         RVC::OBJECTNAME& FieldName          
         ) const;

      REFTYPE GetRefType (
         ) const;

      const MISTRING& GetRefURL (
         ) const { return (m_URL); }

      SCALE GetScaleType (
         ) const { return (m_ScaleType); }

      double GetZoomFactor (
         ) const { return (m_ZoomFactor); }

      bool IsValid (
         ) const;
         
      bool ReadLinkFromAttribute (
         const RVC::DBASE_ELEMENT& DBaseObj,
         const RVC::ELEMENT& Element
         );

      void SetDescription (
         const MISTRING& desc
         ) { m_Desc = desc; }
      
      void SetLinkType (
         TYPE type
         );

      void SetMapScale (
         double MapScale
         ) { m_MapScale = MapScale; }
         
      void SetPosition (
         POSITION posn
         ) { m_PosnType = posn; }

      ERRVALUE SetRefFilePath (
         const FILEPATH& filepath
         );

      ERRVALUE SetRefObjItem (
         const RVC::OBJITEM& ObjItem
         );

      ERRVALUE SetRefTableField (
         const RVC::OBJECTNAME& TableName,
         const RVC::OBJECTNAME& FieldName
         );

      ERRVALUE SetRefURL (
         const MISTRING& URL
         );
         
      void SetScaleType (
         SCALE scale
         ) { m_ScaleType = scale; }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FILEPATH m_FilePath;
      MISTRING m_Name;
      MISTRING m_Desc;
      MISTRING m_URL;
      TYPE m_LinkType;           
      POSITION m_PosnType;
      SCALE m_ScaleType;
      double m_ZoomFactor;       
      double m_MapScale;         

      void GetHyperLink (HYPERLINK& hlink, const FILEPATH& objfilepath) const;
      void SetHyperLink (const HYPERLINK& hlink, const FILEPATH& objfilepath);

      friend class HYPERINDEX;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

DEFINE_ENUM_OP_INCREMENT(HYPERINDEX::LINK::TYPE)

class HYPERINDEX::SHAPE {
   public:
      enum TYPE {
         TYPE_Deleted =       -1,   
         TYPE_Rect =          0,    
         TYPE_Circle =        1,    
         TYPE_Polygon =       2,    
         TYPE_VectPointAny =  5,    
         TYPE_VectLineAny =   6,    
         TYPE_VectPolyAny =   7,    
         TYPE_VectPoint =     8,    
         TYPE_VectLine =      9,    
         TYPE_VectPoly =      10,   
         TYPE_CAD =           11,   
         TYPE_CAD_Any =       12,   
         TYPE_ShapeElem =     13,   
         TYPE_ShapeElem_Any = 14,   
         TYPE_TIN_Node =      15,   
         TYPE_TIN_Node_Any =  16    
         };       

      static bool IsAnyElem (
         TYPE ShapeType
         );

      SHAPE ();

      // Default copy constructor, destructor and operator=() are used

      void Clear ();

      const COLOR& GetColor (
          ) const { return (m_Color); }
      
      INT32 GetElemNum (
         ) const { return (m_ElemNum); }
      
      const DRECT3D& GetExtents (
         ) const { return (m_Extents); }
         
      INT32 GetNumLinks (
         ) const { return (m_NumLinks); }
         
      TYPE GetType (
         ) const { return (m_ShapeType); }
         
      bool HasLinks (
         ) const { return (m_NumLinks > 0); }

      bool HasPoints (
         ) const { return (m_NumPoints > 0); }
         
      bool IsAnyElem (
         ) const { return (IsAnyElem(m_ShapeType)); }

      void SetColor (
         const COLOR& color
         ) { m_Color = color; }
      
      void SetElemNum (
         INT32 ElemNum
         ) { m_ElemNum = ElemNum; }
      
      void SetExtents (
         const DRECT3D& extents
         ) { m_Extents = extents; }
         
      void SetType (
         TYPE type
         ) { m_ShapeType = type; }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      DRECT3D m_Extents;                  // Extents of shape
      COLOR m_Color;                      // Color of shape
      INT32 m_ElemNum;                    // Element number for geometric links
      TYPE m_ShapeType;                   // 0 = square, 1 = Circle, 2 = polygon
      UINT32 m_NumPoints;                 // Square = 2, Circle = 2 (center, radius), poly = N
      UINT32 m_NumLinks;                  // Number of links

      void SetShape (const HYPERSHAPE& hshape);
      void GetShape (HYPERSHAPE& hshape) const;

      friend class HYPERINDEX;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     // End of RVC namespace

#endif   // INC_RVC_HYPERIDX_H

---