rvc/legend.h

Go to the documentation of this file.

#ifndef INC_RVC_LEGEND_H
#define INC_RVC_LEGEND_H

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

#ifndef  INC_MI32_ELEMSTYL_H
   #include <mi32/elemstyl.h>
#endif

#ifndef INC_RVC_GETOBJFILTER_H
   #include <rvc/getobjfilter.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations.
namespace RVC {
   class LEGENDHANDLE;
   struct LEGENDINFO;
   struct LEGENDTEXTSTYLE;
   }
#endif


namespace RVC {

class LEGEND : public RVC::OBJECT {
   public:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class GETOBJFILTER_ISSELECTABLE;
      class LINE;
      class MAKEPARMS;
      #endif // GENERATING_DOXYGEN_OUTPUT

      LEGEND (
         );

      LEGEND (
         const RVC::LEGEND& rhs
         );

      virtual ~LEGEND (
         );

      RVC::LEGEND& operator= (               
         const RVC::LEGEND& rhs
         );
         
      ERRVALUE Clear (
         );

      ERRVALUE GetMakeParms (
         MAKEPARMS& MakeParms
         ) const;
         
      INT32 GetNumItems (
         ) const;

      ERRVALUE Make (
         const RVC::OBJECT& parent,
         const DESCRIPTOR& Descriptor,
         const MAKEPARMS& MakeParms,
         const CREDENTIALS* Credentials = 0           
         );

      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,                       
         const MAKEPARMS& MakeParms,
         const char* Source = 0,
         const CREDENTIALS* Credentials = 0           
         );
         
      ERRVALUE Read (
         MISTRING& StyleObjectPath,
         FILEPATH& StyleFilePath,
         MISTRING& DftQuery,
         MISTRING& ContabObjectPath
         ) const;

      ERRVALUE Read (
         INT32 LegendNum,
         LINE& LegendLine
         ) const;

      ERRVALUE Read (
         INT32 LegendNum,
         MISTRING& string
         ) const;

      ERRVALUE SetMakeParms (
         const MAKEPARMS& MakeParms
         );

      ERRVALUE Write (
         const MISTRING& StyleObjectPath,
         const FILEPATH& StyleFilePath,
         const MISTRING& DftQuery,
         const MISTRING& ContabObjectPath
         );

      ERRVALUE Write (
         INT32 LegendNum,
         const LINE& LegendLine
         );

      ERRVALUE Write (
         INT32 LegendNum,
         const MISTRING& string
         );

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

      static void AssignStyle (const TEXTSTYLE& TextStyle, LEGENDTEXTSTYLE& style);
      static void AssignStyle (const LEGENDTEXTSTYLE& style, TEXTSTYLE& TextStyle);
      static void SetMakeParms (const LEGENDINFO& LegendInfo, MAKEPARMS& MakeParms);
      static void SetMakeParms (const MAKEPARMS& MakeParms, LEGENDINFO& LegendInfo);

      LEGENDHANDLE* m_LegendHandle;
      mutable SIMPLE_ARRAY<MIUNICODE> m_Buffer;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class LEGEND::GETOBJFILTER_ISSELECTABLE : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISSELECTABLE ();
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_HasSelectableSubObjects (const RVC::OBJITEM& objitem);
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class LEGEND::LINE {
   public:
      enum FLAGS {
         FLAG_None = 0x00,
         FLAG_Selected = 0x01,      
         FLAG_DescFromField = 0x02, 
         FLAG_DescQuery = 0x04,     
         FLAG_DescDQuery = 0x08, 
         FLAG_DescFromTheme = 0x10,
         FLAG_TempUnselected = 0x8000
         };
         
      LINE (
         );

      LINE (
         const LINE& rhs
         );

      ~LINE (
         );

      LINE& operator=(
         const LINE& rhs
         );

      void Clear (
          );
   
      const MISTRING& GetLegendDesc (
         ) const { return (m_Desc); }

      FLAGS GetLegendFlags (
         ) const { return (m_Flags); }

      const MISTRING& GetLegendHeading (
         ) const { return (m_Heading); }

      const MISTRING& GetLegendStyle (
         ) const { return (m_Style); }

      UINT16 GetLegendType (
         ) const { return (m_Type); }

      void SetLegendDesc (
         const MISTRING& Desc
         ) { m_Desc = Desc; }

      void SetLegendFlags (
         FLAGS flags
         ) { m_Flags = flags; }

      void SetLegendHeading (
         const MISTRING& Heading
         ) { m_Heading = Heading; }

      void SetLegendStyle (
         const MISTRING& Style
         ) { m_Style = Style; }

      void SetLegendType (
         UINT16 type
         ) { m_Type = type; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT16 m_Type;                
      FLAGS m_Flags;
      MISTRING m_Style;
      MISTRING m_Heading;
      MISTRING m_Desc;
      
      friend class LEGEND;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class LEGEND::MAKEPARMS {
   public:
      MAKEPARMS (
         );
   
      ~MAKEPARMS (
         );
         
      void Clear (
          );
   
      const COLOR& GetBackgroundColor (
         ) const { return (m_BackgroundColor); }
         
      double GetColSpace (
         ) const { return (m_ColSpace); }
         
      double GetColWidth (
         ) const { return (m_ColWidth); }
         
      INT32 GetContrastType (
         ) const { return (m_ContrastType); }
         
      UINT32 GetDispFlags (
         ) const { return (m_DispFlags); }
         
      UINT16 GetElementType (
         ) const { return (m_ElementType); }
         
      const COLOR& GetLegendBorderColor (
         ) const { return (m_LegendBorderColor); }
         
      double GetLegendBorderWidth (
         ) const { return (m_LegendBorderWidth); }
         
      double GetLineSpace (
         ) const { return (m_LineSpace); }
         
      double GetMapScale (
         ) const { return (m_MapScale); }
         
      double GetMarginWidth (
         ) const { return (m_MarginWidth); }
         
      double GetMaxIndex (
         ) const { return (m_MaxIndex); }
         
      double GetMinIndex (
         ) const { return (m_MinIndex); }
         
      double GetMaxL (
         ) const { return (m_MaxL); }
         
      double GetMaxR (
         ) const { return (m_MaxR); }
         
      double GetMinL (
         ) const { return (m_MinL); }
         
      double GetMinR (
         ) const { return (m_MinR); }
         
      UINT32 GetNumCols (
         ) const { return (m_numcols); }
         
      UINT32 GetNumTicksL (
         ) const { return (m_NumTicksL); }
         
      UINT32 GetNumTicksR (
         ) const { return (m_NumTicksR); }
         
      const COLOR& GetSampleBorderColor (
         ) const { return (m_SampleBorderColor); }
         
      double GetSampleBorderWidth (
         ) const { return (m_SampleBorderWidth); }
         
      double GetSampleHeight (
         ) const { return (m_SampleHeight); }
         
      double GetSampleOffset (
         ) const { return (m_SampleOffset); }
         
      double GetSampleSpace (
         ) const { return (m_SampleSpace); }
         
      double GetSampleWidth (
         ) const { return (m_SampleWidth); }
         
      double GetSATableNum (
         ) const { return (m_SATableNum); }
         
      const TEXTSTYLE& GetTextStyle (
         int idx
         ) const { return (m_Style[idx]); }
         
      UINT32 GetUMaxIndex (
         ) const { return (m_UMaxIndex); }
         
      UINT32 GetUMinIndex (
         ) const { return (m_UMinIndex); }
         
      UINT32 GetUnits (
         ) const { return (m_units); }
         
      UINT16 GetVersion (
         ) const { return (m_version); }
         
      void SetBackgroundColor (
         const COLOR& BackgroundColor
         ) { m_BackgroundColor = BackgroundColor; }
         
      void SetColSpace (
         double ColSpace
         ) { m_ColSpace = ColSpace; }
         
      void SetColWidth (
         double ColWidth
         ) { m_ColWidth = ColWidth; }
         
      void SetContrastType (
         INT32 ContrastType
         ) { m_ContrastType = ContrastType; }
         
      void SetDispFlags (
         UINT32 DispFlags
         ) { m_DispFlags = DispFlags; }
         
      void SetElementType (
         UINT16 ElementType
         ) { m_ElementType = ElementType; }
         
      void SetLegendBorderColor (
         const COLOR& LegendBorderColor
         ) { m_LegendBorderColor = LegendBorderColor; }
         
      void SetLegendBorderWidth (
         double LegendBorderWidth
         ) { m_LegendBorderWidth = LegendBorderWidth; }
         
      void SetLineSpace (
         double LineSpace
         ) { m_LineSpace = LineSpace; }
         
      void SetMapScale (
         double MapScale
         ) { m_MapScale = MapScale; }
         
      void SetMarginWidth (
         double MarginWidth
         ) { m_MarginWidth = MarginWidth; }
         
      void SetMaxIndex (
         double MaxIndex
         ) { m_MaxIndex = MaxIndex; }
         
      void SetMinIndex (
         double MinIndex
         ) { m_MinIndex = MinIndex; }
         
      void SetMaxL (
         double MaxL
         ) { m_MaxL = MaxL; }
         
      void SetMaxR (
         double MaxR
         ) { m_MaxR = MaxR; }
         
      void SetMinL (
         double MinL
         ) { m_MinL = MinL; }
         
      void SetMinR (
         double MinR
         ) { m_MinR = MinR; }
         
      void SetNumCols (
         UINT32 NumCols
         ) { m_numcols = NumCols; }
         
      void SetNumTicksL (
         UINT32 NumTicksL
         ) { m_NumTicksL = NumTicksL; }
         
      void SetNumTicksR (
         UINT32 NumTicksR
         ) { m_NumTicksR = NumTicksR; }
         
      void SetSampleBorderColor (
         const COLOR& SampleBorderColor
         ) { m_SampleBorderColor = SampleBorderColor; }
         
      void SetSampleBorderWidth (
         double SampleBorderWidth
         ) { m_SampleBorderWidth = SampleBorderWidth; }
         
      void SetSampleHeight (
         double SampleHeight
         ) { m_SampleHeight = SampleHeight; }
         
      void SetSampleOffset (
         double SampleOffset
         ) { m_SampleOffset = SampleOffset; }
         
      void SetSampleSpace (
         double SampleSpace
         ) { m_SampleSpace = SampleSpace; }
         
      void SetSampleWidth (
         double SampleWidth
         ) { m_SampleWidth = SampleWidth; }
         
      void SetSATableNum (
         double SATableNum
         ) { m_SATableNum = SATableNum; }
         
      void SetTextStyle (
         int idx,
         const TEXTSTYLE& style
         ) { m_Style[idx] = style; }
         
      void SetUMaxIndex (
         UINT32 UMaxIndex
         ) { m_UMaxIndex = UMaxIndex; }
         
      void SetUMinIndex (
         UINT32 UMinIndex
         ) { m_UMinIndex = UMinIndex; }
         
      void SetUnits (
         UINT32 Units
         ) { m_units = Units; }
         
      void SetVersion (
         UINT16 Version
         ) { m_version = Version; }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_MapScale;                  
      double m_ColSpace;                  
      double m_ColWidth;                  
      double m_SampleSpace;               
      double m_SampleHeight;              
      double m_SampleWidth;               
      double m_LineSpace;                 
      double m_SATableNum;                
      double m_SampleOffset;              
      INT32 m_ContrastType;               
      COLOR m_BackgroundColor;            
      TEXTSTYLE m_Style[4];               
      UINT16 m_ElementType;               
      UINT16 m_version;                   
      UINT32 m_units;                     
      UINT32 m_numcols;                   
      UINT32 m_DispFlags;                 
      COLOR m_SampleBorderColor;          
      COLOR m_LegendBorderColor;          
      double m_SampleBorderWidth;         
      double m_LegendBorderWidth;         
      double m_MarginWidth;               
      double m_MinL;                      
      double m_MaxL;                      
      double m_MinR;                      
      double m_MaxR;                      
      UINT32 m_UMinIndex;                 
      UINT32 m_UMaxIndex;                 
      UINT32 m_NumTicksL;                 
      UINT32 m_NumTicksR;                 
      double m_MinIndex;                  
      double m_MaxIndex;                  
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(LEGEND::LINE::FLAGS)
#endif

}     // End of RVC namespace

#endif   // INC_RVC_LEGEND_H

---