gre/legend.h

Go to the documentation of this file.

#ifndef  INC_GRE_LEGEND_H
#define  INC_GRE_LEGEND_H

#ifndef  INC_GRE_ELEMSAMPLEDC_H
   #include <gre/elemsampledc.h>
#endif

#ifndef  INC_RVC_ELEMENT_H
   #include <rvc/element.h>
#endif

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

#ifndef  INC_MI32_COLORARRAY_H
   #include <mi32/colorarray.h>
#endif

#if !defined(INC_MGUI_TREE_H) && defined(USE_MGUI)
   #include <mgui/tree.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT

struct CBPARMS;

namespace MGUI {
   class CUSTOMDRAW_TREE;
   };

namespace RVC {
   class DBASE_ELEMENT;
   class DBTABLE;
   class DBTABLE_STYLE;
   class STYLE;
   };

#endif // GENERATING_DOXYGEN_OUTPUT


namespace GRE {
//===================================================================================================================

#define  GRE_LEGENDVIEW_LabelSpace  4
#define  GRE_LEGENDVIEW_ItemSpace   2

class LEGEND {
   public:

      class DRAWCONTEXT;
      class ITEMBASE;
      typedef MILIST<ITEMBASE*> ITEMLIST;

      static void SetDftBackgroundColor (
         const COLOR& color
         ) { s_DftBackgroundColor = color; }

      explicit LEGEND (
         GRE::LAYER *layer,
         ELEMTYPE ElemType
         );

      virtual ~LEGEND ();

   #ifdef USE_MGUI
      ERRVALUE AddElemPrompted (
         MDLGPARENT dlgparent,               
         const RVC::ELEMENT& element         
         ) { return (v_AddElemPrompted(dlgparent,element)); }
   #endif

      bool ContainsElem (
         const RVC::ELEMENT& element         
         ) const;

      ERRVALUE CreateElemTable (
         const RVC::DESCRIPTOR& descriptor   
         );

      void DeleteAllItems (
         );

      ERRVALUE DeleteElem (
         const RVC::ELEMENT& element         
         );

      void Draw (
         const DRAWCONTEXT& dc,              
         LPOINT2D& origin                    
         ) const;

      const COLOR& GetBackgroundColor (
         ) const { return (m_ColorBG); }

      ELEMTYPE GetElemType (
         ) const { return (m_ElemType); }

      const ITEMLIST& GetItemList (
         ) const { return (m_ItemList); }

      void GetItemSizePixels (
         LPOINT2D& size                      
         ) const { v_GetItemSizePixels(size); }

      GRE::LAYER* GetLayer (
         ) const { return (m_layer); }

      bool GetNeedStyleObject (
         ) const { return (m_NeedStyleObj); }

      MGD::STYLESAMPLEFLAGS GetSampleFlags (
         ) const { return (m_SampleFlags); }

      LPOINT2D GetSize (
         const DRAWCONTEXT& dc               
         ) const;

      const RVC::OBJITEM& GetStyleObjItem (
         ) { return (m_StyleObjItem); }

      bool HasElemTable (
         ) const;

      bool HasItems (
         ) const { return (!m_ItemList.IsEmpty()); }

      bool IsMergingDuplicateStyles (
         ) const { return (m_MergeDupStyles); }

      bool IsSorted (
         ) const { return (m_Sorted); }

      void SetBackgroundColor (
         const COLOR& color
         ) { m_ColorBG = color; }

      void SetMergeDuplicateStyles (
         bool MergeDupStyles = true
         ) { m_MergeDupStyles = MergeDupStyles; }

      void SetNeedStyleObject (
         bool NeedStyleObj = true
         ) { m_NeedStyleObj = NeedStyleObj; }

      void SetSampleFlags (
         MGD::STYLESAMPLEFLAGS newflags
         ) { m_SampleFlags = newflags | MGD::STYLESAMPLE_ShrinkToFit; }

      void SetSorted (                 
         bool sorted = true
         ) { m_Sorted = sorted; }

      void SetStyleObject (
         const RVC::OBJITEM& StyleObj
         );

   #ifdef USE_MGUI
      MGUI::CTRL_TREE::ITEMHND TreeViewInsertItems (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hParent,
         MGUI::CTRL_TREE::ITEMHND hInsertAfter
         );
   #endif

   protected:

      ITEMLIST m_ItemList;                
      RVC::OBJITEM m_GeoObjItem;
      RVC::DBASE_ELEMENT *m_pDbObject;
      RVC::DBTABLE *m_pElemTable;

      ERRVALUE AddElemRecord (
         const RVC::ELEMENT& element,
         const MISTRING& prilabel,
         const MISTRING& seclabel
         );

      void InsertItem (
         ITEMBASE *item                         
         );

      ERRVALUE OpenElemTable (
         const RVC::OBJECTNAME& ElemTableName
         );

      ERRVALUE OpenStyle (
         RVC::DBTABLE_STYLE& StyleTable,
         const RVC::OBJITEM& StyleObjItem,
         const RVC::OBJITEM& GeoObjItem,
         RVC::STYLE& StyleObj
         );

      void SetHasMergedStyles (
         ) { m_HasMergedStyles = true; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      static COLOR s_DftBackgroundColor;
      GRE::LAYER *m_layer;             
      ELEMTYPE m_ElemType;             
      bool m_Sorted;                   
      bool m_NeedStyleObj;             
      bool m_MergeDupStyles;           
      bool m_HasMergedStyles;          
      MGD::STYLESAMPLEFLAGS m_SampleFlags;      
      RVC::OBJITEM m_StyleObjItem;
      COLOR m_ColorBG;

      LEGEND (const LEGEND&);
      LEGEND& operator= (const LEGEND&);

      friend class DRAWCONTEXT;
      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables.

   #ifdef USE_MGUI
      virtual ERRVALUE v_AddElemPrompted (
         MDLGPARENT dlgparent,               
         const RVC::ELEMENT& element         
         );
   #endif

      virtual void v_GetItemSizePixels (
         LPOINT2D& size                      
         ) const;

   };


class LEGEND::DRAWCONTEXT : public ELEMSAMPLE_DC {
   public:

      enum ORIENTATION {
         ORIENTATION_Vertical =     0,    
         ORIENTATION_Horizonatal =  1     
         };

      GRE::LAYER *m_layer;
      ELEMTYPE m_ElemType;
      INT32 m_itemheight;
      INT32 m_samplewidth;
      INT32 m_labelspace;
      INT32 m_itemspace;
      LRECT2D m_cliprect;
      bool m_DrawLabels;
      bool m_DrawLabelsOnColorScales;     
      bool m_HasTextStyle;
      TEXTSTYLE m_TextStyle;
      ORIENTATION m_Orientation;

      DRAWCONTEXT (
         const LEGEND& legend,
         MGD::CONTEXT *gc,
         INT32 labelspace,                
         INT32 itemspace,                 
         const LRECT2D& cliprect          
         );

      virtual ~DRAWCONTEXT ();

      bool IsVertical (
         ) const { return (m_Orientation == ORIENTATION_Vertical); }

      void SetDrawLabels (
         bool DrawLabels
         ) { m_DrawLabels = DrawLabels; }

   }; 


class LEGEND::ITEMBASE {
   public:

      ITEMBASE (
         LEGEND& legend
         );

      ITEMBASE (
         LEGEND& legend,
         const MISTRING& label            
         );

      ITEMBASE (
         LEGEND& legend,
         const RVC::ELEMENT& element,     
         const MISTRING& label            
         );

      virtual ~ITEMBASE ();

      void Draw (
         const DRAWCONTEXT& dc,           
         const LRECT2D& samplerect        
         ) const { v_Draw(dc,samplerect); }

      void DrawLabel (
         const DRAWCONTEXT& dc,           
         const LRECT2D& samplerect        
         ) const;

      const RVC::ELEMENT& GetElement (
         ) const { return (m_element); }

      ELEMNUM GetElemNum (
         ) const { return (m_element.GetNumber()); }

      const MISTRING& GetLabel (
         ) const { return (m_label); }

      void GetLabelSize (
         const DRAWCONTEXT& dc,           
         LPOINT2D& size                   
         ) const;

      LEGEND& GetLegend (
         ) { return (m_legend); }

      const LEGEND& GetLegend (
         ) const { return (m_legend); }

      bool HasTransparency (
         ) const { return (v_HasTransparency()); };

      void MergeLabel (
         const MISTRING& label
         );

      void SetLabel (
         const MISTRING& label
         ) { m_label = label; }

   #ifdef USE_MGUI
      MGUI::CTRL_TREE::ITEMHND TreeViewInsertItem (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CTRL_TREE::ITEMHND hndParent,
         MGUI::CTRL_TREE::ITEMHND hndInsertAfter
         );
   #endif

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      LEGEND& m_legend;
      RVC::ELEMENT m_element;
      MISTRING m_label;

   #ifdef USE_MGUI
      MGUI::CUSTOMDRAW::RETVALUE TreeViewOnCustomDraw (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CUSTOMDRAW_TREE& CustomDraw   
         );
   #endif

      ITEMBASE (const ITEMBASE&);
      ITEMBASE& operator= (const ITEMBASE&);
      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables.

      virtual void v_Draw (
         const DRAWCONTEXT& dc,           
         const LRECT2D& samplerect        
         ) const = 0;

      virtual bool v_HasTransparency (
         ) const;

   #ifdef USE_MGUI
      virtual void v_TreeViewCustomDraw (
         GRE::CTRL_TREEVIEW& TreeView,
         MGUI::CUSTOMDRAW_TREE& CustomDraw   
         ) = 0;
   #endif

   }; // End of LEGEND::ITEMBASE class.


//===================================================================================================================

class LEGEND_POINT : public LEGEND {
   public:

      class ITEM;

      LEGEND_POINT (
         GRE::LAYER *layer,                     
         ELEMTYPE ElemType                   
         );

      void AddItem (
         const POINTSTYLE& style,
         const MISTRING& label
         );

      void AddItem (
         const RVC::ELEMENT& element,           
         const MISTRING& label
         );

      ERRVALUE Setup (
         const POINTPARMS& parms,
         const RVC::OBJITEM& GeoObjItem,
         const RVC::OBJITEM& StyleObjItem
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // LEGEND overrides.
   #ifdef USE_MGUI
      virtual ERRVALUE v_AddElemPrompted (MDLGPARENT dlgparent, const RVC::ELEMENT& element);
   #endif

      LEGEND_POINT (const LEGEND_POINT&);
      LEGEND_POINT& operator= (const LEGEND_POINT&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class LEGEND_POINT::ITEM : public LEGEND::ITEMBASE {
   public:

      ITEM (
         LEGEND_POINT& legend,
         const POINTSTYLE& style,
         const MISTRING& label
         );

      ITEM (
         LEGEND_POINT& legend,
         const RVC::ELEMENT& element,     
         const MISTRING& label            
         );

      virtual ~ITEM ();

      const POINTSTYLE& GetStyle (
         ) const { return (m_style); }

      bool HasSameStyle (
         const POINTSTYLE& style          
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Overrides.
      virtual void v_Draw (const DRAWCONTEXT& dc, const LRECT2D& samplerect) const;
      virtual bool v_HasTransparency () const;
   #ifdef USE_MGUI
      virtual void v_TreeViewCustomDraw (CTRL_TREEVIEW& TreeView, MGUI::CUSTOMDRAW_TREE& CustomDraw);
   #endif

      POINTSTYLE m_style;
      ITEM (const ITEM&);
      ITEM& operator= (const ITEM&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//===================================================================================================================

class LEGEND_LINE : public LEGEND {
   public:

      class ITEM;

      LEGEND_LINE (
         GRE::LAYER *layer,                     
         ELEMTYPE ElemType                   
         );

      void AddItem (
         const LINESTYLE& style,
         const MISTRING& label
         );                               

      void AddItem (
         const RVC::ELEMENT& element,           
         const MISTRING& label
         );

      ERRVALUE Setup (
         const LINEPARMS& parm,
         const RVC::OBJITEM& GeoObjItem,
         const RVC::OBJITEM& StyleObjItem
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // LEGEND overrides.
   #ifdef USE_MGUI
      virtual ERRVALUE v_AddElemPrompted (MDLGPARENT dlgparent, const RVC::ELEMENT& element);
   #endif

      LEGEND_LINE (const LEGEND_LINE&);
      LEGEND_LINE& operator= (const LEGEND_LINE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class LEGEND_LINE::ITEM : public LEGEND::ITEMBASE {
   public:

      ITEM (
         LEGEND_LINE& legend,
         const LINESTYLE& style,
         const MISTRING& label
         );

      ITEM (
         LEGEND_LINE& legend,
         const RVC::ELEMENT& element,     
         const MISTRING& label            
         );

      virtual ~ITEM ();

      const LINESTYLE& GetStyle (
         ) const { return (m_style); };

      bool HasSameStyle (
         const LINESTYLE& style           
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Overrides.
      virtual void v_Draw (const DRAWCONTEXT& dc, const LRECT2D& samplerect) const;
      virtual bool v_HasTransparency () const;
   #ifdef USE_MGUI
      virtual void v_TreeViewCustomDraw (CTRL_TREEVIEW& TreeView, MGUI::CUSTOMDRAW_TREE& CustomDraw);
   #endif

      LINESTYLE m_style;
      ITEM (const ITEM&);
      ITEM& operator= (const ITEM&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class LEGEND_POLYGON : public LEGEND {
   public:

      class ITEM;

      LEGEND_POLYGON (
         GRE::LAYER *layer,                        
         ELEMTYPE ElemType                      
         );

      void AddItem (
         const POLYSTYLE& style,
         const MISTRING& label,                 
         const MISTRING& intlabel               
         );                                        

      void AddItem (
         const RVC::ELEMENT& element,           
         const MISTRING& label,                 
         const MISTRING& intlabel               
         );                               

      ERRVALUE Setup (
         const POLYPARMS& parm,
         const RVC::OBJITEM& GeoObjItem,
         const RVC::OBJITEM& StyleObjItem
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // LEGEND overrides.
   #ifdef USE_MGUI
      virtual ERRVALUE v_AddElemPrompted (MDLGPARENT dlgparent, const RVC::ELEMENT& element);
   #endif

      LEGEND_POLYGON (const LEGEND_POLYGON&);
      LEGEND_POLYGON& operator= (const LEGEND_POLYGON&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class LEGEND_POLYGON::ITEM : public LEGEND::ITEMBASE {
   public:

      ITEM (
         LEGEND_POLYGON& legend,
         const POLYSTYLE& style,          
         const MISTRING& label,           
         const MISTRING& intlabel         
         );

      ITEM (
         LEGEND_POLYGON& legend,
         const RVC::ELEMENT& element,     
         const MISTRING& label,           
         const MISTRING& intlabel         
         );

      virtual ~ITEM ();

      const POLYSTYLE& GetStyle (
         ) const { return (m_style); }

      bool HasSameStyle (
         const POLYSTYLE& style           
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      POLYSTYLE m_style;
      MISTRING m_intlabel;    // Label to place INSIDE sample

      // Draw the Interior label (m_intlabel) label
      void DrawInteriorLabel (
         const DRAWCONTEXT& cd,           // Legend drawing context
         const LRECT2D& samplerect        // Rectangle for sample symbol, not including label
         ) const;

      // Overrides.
      virtual void v_Draw (const DRAWCONTEXT& dc, const LRECT2D& samplerect) const;
      virtual bool v_HasTransparency () const;
   #ifdef USE_MGUI
      virtual void v_TreeViewCustomDraw (CTRL_TREEVIEW& TreeView, MGUI::CUSTOMDRAW_TREE& CustomDraw);
   #endif

      ITEM (const ITEM&);
      ITEM& operator= (const ITEM&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class LEGEND_COLORSAMPLE : public LEGEND {
   public:

      class ITEM;

      LEGEND_COLORSAMPLE (
         GRE::LAYER *layer                   
         );

      void AddItem (
         const COLOR& color,
         const MISTRING& label
         );                               

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      LEGEND_COLORSAMPLE (const LEGEND_COLORSAMPLE&);
      LEGEND_COLORSAMPLE& operator= (const LEGEND_COLORSAMPLE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class LEGEND_COLORSAMPLE::ITEM : public LEGEND::ITEMBASE {
   public:

      ITEM (
         LEGEND_COLORSAMPLE& legend,
         const COLOR& color,
         const MISTRING& label
         );

      virtual ~ITEM ();

      const COLOR& GetColor (
         ) const { return (m_color); }

      bool HasSameStyle (
         const COLOR& color
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      COLOR m_color;

      // Overrides.
      virtual void v_Draw (const DRAWCONTEXT& dc, const LRECT2D& samplerect) const;
   #ifdef USE_MGUI
      virtual void v_TreeViewCustomDraw (CTRL_TREEVIEW& TreeView, MGUI::CUSTOMDRAW_TREE& CustomDraw);
   #endif

      ITEM (const ITEM&);
      ITEM& operator= (const ITEM&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

class LEGEND_COLORSCALE : public LEGEND {
   public:

      class ITEM;

      LEGEND_COLORSCALE (
         GRE::LAYER *layer                   
         );

      void SetLabel (
         const MISTRING& label
         );

      void SetLength (
         int length
         );

      void SetValues (
         const COLOR_ARRAY& palette,
         double MinValue,
         double MaxValue,
         bool VerticalMinAtTop
         );

      void SetValues (
         const COLOR_ARRAY& palette,
         const CBPARMS& ColorBalance,           
         double MinValue,
         double MaxValue,
         bool VerticalMinAtTop
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // LEGEND overrides.
      virtual void v_GetItemSizePixels (LPOINT2D& size) const;

      LEGEND_COLORSCALE (const LEGEND_COLORSCALE&);
      LEGEND_COLORSCALE& operator= (const LEGEND_COLORSCALE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================
}  // End namespace GRE

#endif   // INC_LEGEND_H

---