legend.h

Go to the documentation of this file.

/**
 * \file gre/legend.h
 * \brief GRE LEGEND base class definitions
 *
 * \if NODOC
 * $Id: legend.h_v 1.1 2004/03/04 19:00:34 mju Exp $
 *
 * $Log: legend.h_v $
 * Revision 1.1  2004/03/04 19:00:34  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_GRE_LEGEND_H
#define  INC_GRE_LEGEND_H

#ifndef  INC_RVC_DBELEM_H
   #include <rvc/dbelem.h>
#endif

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

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

#define  GRE_LEGENDVIEW_LabelSpace  4
#define  GRE_LEGENDVIEW_ItemSpace   2

//! Legend base class.
class GRE_LEGEND {
   public:

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

      //! Constructor
      explicit GRE_LEGEND (
         GRE_LAYER *layer,
         ELEMTYPE ElemType
         );

      //! Destructor.
      virtual ~GRE_LEGEND (
         );

   #if defined(X_NATIVE) || defined(WIN32_MFC)
      //! Add element to legend 'element table' with prompt for label(s).
      virtual ERRVALUE AddElemPrompted (
         MDLGPARENT dlgparent,               //!< Parent for dialog
         const RVC::ELEMENT& element         //!< Element to add
         );
   #endif

      //! Determine if legend 'element table' contains specified element.
      bool ContainsElem (
         const RVC::ELEMENT& element         //!< Element
         ) const;

      //! Create 'element table' if don't already have one attached.
      ERRVALUE CreateElemTable (
         const RVC::OBJECTNAME& TableName,   //!< Name of table to create
         const RVC::OBJECTDESC& TableDesc    //!< Description of table to create
         );

      //! Delete all items from the legend.
      void DeleteAllItems (
         );

      //! Delete element from legend 'element table'.
      ERRVALUE DeleteElem (
         const RVC::ELEMENT& element         //!< Element
         );

      //! Draw entire legend.
      void Draw (
         const DRAWCONTEXT& dc,              //!< Legend drawing context
         LPOINT2D& origin                    //!< Origin passed / returned
         ) const;

      //! Return element type legend is for.
      ELEMTYPE GetElemType (
         ) const { return (m_ElemType); }

      //! Get legend item list.
      const ITEMLIST& GetItemList (
         ) const { return (m_ItemList); }

      //! Get "preferred" item size in millimeters.
      virtual void GetItemSizeMM (
         DPOINT2D& size                      //!< Size in millimeters returned, not including labels
         ) const;

      //! Get "preferred" item size in pixels.
      //! This is used for rendering legend in user interface (ie. LegendView).
      virtual void GetItemSizePixels (
         LPOINT2D& size                      //!< Size in pixels returned, not including labels
         ) const;

      //! Return layer legend is associated with.
      GRE_LAYER* GetLayer (
         ) const { return (m_layer); }

      //! Return flags for sample style rendering.
      //! @return Flags for sample style rendering.
      MGD::STYLESAMPLEFLAGS GetSampleFlags (
         ) const { return (m_SampleFlags); }

      //! Get size of legend given sample item height and width.
      //! @return Size of legend given sample item height and width.
      LPOINT2D GetSize (
         const DRAWCONTEXT& dc               //!< Legend drawing context
         ) const;

      //! Get reference to style object item used by legend.
      const RVC::OBJITEM& GetStyleObjItem (
         ) { return (m_StyleObjItem); }

      //! Determine if legend has associated 'element table'.
      bool HasElemTable (
         ) const { return (m_ElemTable.IsAttached()); }

      //! Determine if legend has any items.
      bool HasItems (
         ) const { return (!m_ItemList.IsEmpty()); }

      //! Determine if duplicate styles are being merged as items are added.
      bool IsMergingDuplicateStyles (
         ) const { return (m_MergeDupStyles); }

      //! Determine if legend is sorted by label strings.
      bool IsSorted (
         ) const { return (m_Sorted); }

      //! Set whether to merge duplicate styles. 
      void SetMergeDuplicateStyles (
         bool MergeDupStyles = true
         ) { m_MergeDupStyles = MergeDupStyles; }

      //! Set whether a style object is needed.
      void SetNeedStyleObject (
         bool NeedStyleObj = true
         ) { m_NeedStyleObj = NeedStyleObj; }

      //! Set sample flags.
      void SetSampleFlags (
         MGD::STYLESAMPLEFLAGS newflags
         ) { m_SampleFlags = newflags | MGD::STYLESAMPLE_ShrinkToFit; }

      //! Set whether should be sorted by labels.
      //! Must be done before adding items.
      void SetSorted (                 
         bool sorted = true
         ) { m_Sorted = sorted; }

      //! Set style object to use for legend using RVC::OBJITEM reference.
      void SetStyleObject (
         const RVC::OBJITEM& StyleObj
         );

   protected:

      ITEMLIST m_ItemList;                //!< List of legend items
      RVC::OBJITEM m_GeoObjItem;
      RVC::DBASE_ELEMENT m_DbObject;
      RVC::DBTABLE m_ElemTable;

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

      void InsertItem (
         ITEMBASE *item                         //!< Item to insert
         );

      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
      GRE_LAYER *m_layer;              //!< Layer legend is associated with
      ELEMTYPE m_ElemType;             //!< Element type legend is for
      bool m_Sorted;                   //!< Set if sorted
      bool m_NeedStyleObj;             //!< Set if need style object for patterns
      bool m_MergeDupStyles;           //!< Merge duplicate styles when adding
      bool m_HasMergedStyles;          //!< Duplicate styles have been merged
      MGD::STYLESAMPLEFLAGS m_SampleFlags;      //!< Flags for sample style drawing
      RVC::OBJITEM m_StyleObjItem;

      GRE_LEGEND (const GRE_LEGEND&);
      GRE_LEGEND& operator= (const GRE_LEGEND&);

      friend class DRAWCONTEXT;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Context for legend item drawing.
class GRE_LEGEND::DRAWCONTEXT : public GRE_ELEMSAMPLE_DC {
   public:

      //! Orientation for drawing if supported by legend type.
      //! This is used by "color scale" legend.
      enum ORIENTATION {
         ORIENTATION_Vertical =     0,    //!< Draw items in "vertical" orientation (default)
         ORIENTATION_Horizonatal =  1     //!< Draw items in "horizontal" orientation
         };

      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;     //!< Special case override for above flag.
      bool m_HasTextStyle;
      TEXTSTYLE m_TextStyle;
      ORIENTATION m_Orientation;

      //! Constructor for use in user interface
      DRAWCONTEXT (
         const GRE_LEGEND& legend,
         MGD::CONTEXT *gc,
         INT32 labelspace,                //!< Spacing between sample and label in pixels
         INT32 itemspace,                 //!< Spacing between items in pixels
         const LRECT2D& cliprect          //!< Clipping rectangle
         );

      virtual ~DRAWCONTEXT (
         );

      //! Determine if legend has vertical orientation.
      bool IsVertical (
         ) const { return (m_Orientation == ORIENTATION_Vertical); }

      //! Set whether or not to draw labels for legend items.
      void SetDrawLabels (
         bool DrawLabels
         ) { m_DrawLabels = DrawLabels; }

   }; //! End of GRE_LEGEND::DRAWCONTEXT class.


//! Base class for legend item defining virtual methods for drawing
class GRE_LEGEND::ITEMBASE {
   public:

      //! Default constructor.
      ITEMBASE (
         );

      //! Construct with no specified element
      explicit ITEMBASE (
         const MISTRING& label            //!< Label
         );

      //! Construct with element and label.
      ITEMBASE (
         const RVC::ELEMENT& element,     //!< Element from associated object
         const MISTRING& label            //!< Label
         );

      //! Destructor.
      virtual ~ITEMBASE (
         );

      //! Draw item.
      virtual void Draw (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including label
         ) const = 0;

      //! Draw label.
      void DrawLabel (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including label
         ) const;

   #ifdef WIN32_MFC
      //! Draw item with label in MFC TreeView (MFC only).
      //! Must implement in derived class when compiling for WIN32_MFC.
      virtual void DrawTreeView (
         void *hdc,                       //!< Windows device context
         const GRE_ELEMSAMPLE_DC& dc,     //!< Legend drawing context
         const CRect& rect,               //!< Bounding rectangle including label
         bool HasFocus                    //!< 'true' if item has "focus"
         ) = 0;
   #endif

      //! Get element used by item.
      const RVC::ELEMENT& GetElement (
         ) const { return (m_element); }

      //! Get element number.
      INT32 GetElemNum (
         ) const { return (m_element.GetNumber()); }

      //! Get the label.
      const MISTRING& GetLabel (
         ) const { return (m_label); }

      //! Get size of label.
      void GetLabelSize (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         LPOINT2D& size                   //!< Size in "display pixels" returned
         ) const;

      //! Determine if item requires transparency support.
      virtual bool HasTransparency (
         ) const;

      //! Merge label with current label.
      void MergeLabel (
         const MISTRING& label
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      RVC::ELEMENT m_element;
      MISTRING m_label;

      ITEMBASE (const ITEMBASE&);
      ITEMBASE& operator= (const ITEMBASE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   }; //! End of GRE_LEGEND::ITEMBASE class.


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

//! Point Feature legend subclass.
class GRE_LEGEND_POINT : public GRE_LEGEND {
   public:

      class ITEM;

      //! Construct legend for layer and element type.
      GRE_LEGEND_POINT (
         GRE_LAYER *layer,                   //!< Layer legend is for
         ELEMTYPE ElemType                   //!< Element type
         );

   #if defined(X_NATIVE) || defined(WIN32_MFC)
      //! Add element to legend 'element table' with prompt for label(s).
      virtual ERRVALUE AddElemPrompted (
         MDLGPARENT dlgparent,               //!< Parent for dialog
         const RVC::ELEMENT& element         //!< Element to add
         );
   #endif

      //! Add item to legend.
      void AddItem (
         const POINTSTYLE& style,
         const MISTRING& label
         );

      //! Add item to legend.
      void AddItem (
         const RVC::ELEMENT& element,           //!< Element to add
         const MISTRING& label
         );

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

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


//! Individual item in point legend.
class GRE_LEGEND_POINT::ITEM : public GRE_LEGEND::ITEMBASE {
   public:

      //! Constructor using POINTSTYLE and label.
      ITEM (
         const POINTSTYLE& style,
         const MISTRING& label
         );

      //! Constructor using element number and label.
      ITEM (
         const RVC::ELEMENT& element,     //!< Element
         const MISTRING& label            //!< Label
         );

      //! Destructor.
      virtual ~ITEM (
         );

      //! Draw item.
      virtual void Draw (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including label
         ) const;

   #ifdef WIN32_MFC
      //! Draw item with label in TreeView (WIN32_MFC).
      virtual void DrawTreeView (
         void *hdc,                       //!< Windows device context
         const GRE_ELEMSAMPLE_DC& dc,     //!< Legend drawing context
         const CRect& rect,               //!< Bounding rectangle including label
         bool HasFocus                    //!< 'true' if item has "focus"
         );
   #endif

      //! Get style for item.
      const POINTSTYLE& GetStyle (
         ) const { return (m_style); }

      //! Determine if this item has same style.
      bool HasSameStyle (
         const POINTSTYLE& style          //!< Style to compare
         ) const;

      //! Determine if item requires transparency support.
      virtual bool HasTransparency (
         ) const;

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


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

//! Line Feature legend subclass.
class GRE_LEGEND_LINE : public GRE_LEGEND {
   public:

      class ITEM;

      //! Construct legend for layer and element type.
      GRE_LEGEND_LINE (
         GRE_LAYER *layer,                   //!< Layer legend is for
         ELEMTYPE ElemType                   //!< Element type
         );

   #if defined(X_NATIVE) || defined(WIN32_MFC)
      //! Add element to legend 'element table' with prompt for label(s).
      virtual ERRVALUE AddElemPrompted (
         MDLGPARENT dlgparent,               //!< Parent for dialog
         const RVC::ELEMENT& element         //!< Element to add
         );
   #endif

      //! Add item to legend.
      void AddItem (
         const LINESTYLE& style,
         const MISTRING& label
         );                               

      //! Add item to legend.
      void AddItem (
         const RVC::ELEMENT& element,           //!< Element to add
         const MISTRING& label
         );

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

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

//! Individual item in line legend.
class GRE_LEGEND_LINE::ITEM : public GRE_LEGEND::ITEMBASE {
   public:

      //! Constructor.
      ITEM (
         const LINESTYLE& style,
         const MISTRING& label
         );

      //! Constructor using element number and label.
      ITEM (
         const RVC::ELEMENT& element,     //!< Element
         const MISTRING& label            //!< Label
         );

      //! Destructor.
      virtual ~ITEM (
         );

      //! Draw item.
      virtual void Draw (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including label
         ) const;

   #ifdef WIN32_MFC
      //! Draw item with label in TreeView (WIN32_MFC).
      virtual void DrawTreeView (
         void *hdc,                       //!< Windows device context
         const GRE_ELEMSAMPLE_DC& dc,     //!< Legend drawing context
         const CRect& rect,               //!< Bounding rectangle including label
         bool HasFocus                    //!< 'true' if item has "focus"
         );
   #endif

      //! Get style for item.
      const LINESTYLE& GetStyle (
         ) const { return (m_style); };

      //! Determine if this item has same style.
      bool HasSameStyle (
         const LINESTYLE& style           //!< Style to compare
         ) const;

      //! Determine if item requires transparency support.
      virtual bool HasTransparency (
         ) const;

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

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

//! Polygon/Area Feature legend subclass.
class GRE_LEGEND_POLY : public GRE_LEGEND {
   public:

      class ITEM;

      //! Construct legend for layer and element type.
      GRE_LEGEND_POLY (
         GRE_LAYER *layer,                      //!< Layer legend is for
         ELEMTYPE ElemType                      //!< Element type
         );

   #if defined(X_NATIVE) || defined(WIN32_MFC)
      //! Add element to legend 'element table' with prompt for label(s).
      virtual ERRVALUE AddElemPrompted (
         MDLGPARENT dlgparent,                  //!< Parent for dialog
         const RVC::ELEMENT& element            //!< Element to add
         );
   #endif

      //! Add item to legend.
      void AddItem (
         const POLYSTYLE& style,
         const MISTRING& label,                 //!< Label to place to right of sample
         const MISTRING& intlabel               //!< Label to place INSIDE sample (blank for none)
         );                                        

      //! Add item to legend.
      void AddItem (
         const RVC::ELEMENT& element,           //!< Element to add
         const MISTRING& label,                 //!< Label to place to right of sample
         const MISTRING& intlabel               //!< Label to place INSIDE sample (blank for none)
         );                               

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

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

//! Individual item in polygon legend.
class GRE_LEGEND_POLY::ITEM : public GRE_LEGEND::ITEMBASE {
   public:

      //! Constructor.
      ITEM (
         const POLYSTYLE& style,          //!< Item style
         const MISTRING& label,           //!< Label to place to right of sample
         const MISTRING& intlabel         //!< Label to place INSIDE sample (blank string for none)
         );

      //! Constructor using element number and label.
      ITEM (
         const RVC::ELEMENT& element,     //!< Element
         const MISTRING& label,           //!< Label to place to right of sample
         const MISTRING& intlabel         //!< Label to place INSIDE sample (blank string for none)
         );

      //! Destructor.
      virtual ~ITEM (
         );

      //! Draw item.
      virtual void Draw (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including label
         ) const;

   #ifdef WIN32_MFC
      //! Draw item with label in TreeView (WIN32_MFC).
      virtual void DrawTreeView (
         void *hdc,                       //!< Windows device context
         const GRE_ELEMSAMPLE_DC& dc,     //!< Legend drawing context
         const CRect& rect,               //!< Bounding rectangle including label
         bool HasFocus                    //!< 'true' if item has "focus"
         );
   #endif

      //! Get style for item.
      const POLYSTYLE& GetStyle (
         ) const { return (m_style); }

      //! Determine if this item has same style.
      bool HasSameStyle (
         const POLYSTYLE& style           //!< Style to compare
         ) const;

      //! Determine if item requires transparency support.
      virtual bool HasTransparency (
         ) 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;

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

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

//! Color-Sample legend subclass.
class GRE_LEGEND_COLORSAMPLE : public GRE_LEGEND {
   public:

      class ITEM;

      //! Construct legend for layer and element type.
      GRE_LEGEND_COLORSAMPLE (
         GRE_LAYER *layer                    //!< Layer legend is for
         );

      //! Add item to legend.
      void AddItem (
         const COLOR& color,
         const MISTRING& label
         );                               

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

class GRE_LEGEND_COLORSAMPLE::ITEM : public GRE_LEGEND::ITEMBASE {
   public:

      //! Constructor.
      ITEM (
         const COLOR& color,
         const MISTRING& label
         );

      //! Destructor.
      virtual ~ITEM (
         );

      //! Draw item.
      virtual void Draw (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including label
         ) const;

   #ifdef WIN32_MFC
      //! Draw item with label in TreeView (WIN32_MFC).
      virtual void DrawTreeView (
         void *hdc,                       //!< Windows device context
         const GRE_ELEMSAMPLE_DC& dc,     //!< Legend drawing context
         const CRect& rect,               //!< Bounding rectangle including label
         bool HasFocus                    //!< 'true' if item has "focus"
         );
   #endif

      //! Get color associated with item.
      const COLOR& GetColor (
         ) const { return (m_color); }

      //! Determine if this item has same style.
      bool HasSameStyle (
         const COLOR& color
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      COLOR m_color;
      ITEM (const ITEM&);
      ITEM& operator= (const ITEM&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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

//! Color-Scale legend subclass.
class GRE_LEGEND_COLORSCALE : public GRE_LEGEND {
   public:

      class ITEM;

      //! Construct legend for layer.
      GRE_LEGEND_COLORSCALE (
         GRE_LAYER *layer                    //!< Layer legend is for
         );

      //! Get "preferred" item size in pixels.
      virtual void GetItemSizePixels (
         LPOINT2D& size                      //!< Size in pixels returned, not including labels
         ) const;

      //! Set legend values.
      //! This will create or update the single legend "item".
      void SetValues (
         const SIMPLE_ARRAY<COLOR>& palette,
         const CBPARMS& ColorBalance,           //!< For adjusting color
         double MinValue,
         double MaxValue,
         bool VerticalMinAtTop
         );

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

class GRE_LEGEND_COLORSCALE::ITEM : public GRE_LEGEND::ITEMBASE {
   public:

      //! Constructor.
      ITEM (
         GRE_LEGEND_COLORSCALE& legend,   //!< Legend containing item
         const SIMPLE_ARRAY<COLOR>& palette,
         const CBPARMS& ColorBalance,     //!< For adjusting color
         double MinValue,
         double MaxValue,
         bool VerticalMinAtTop
         );

      //! Destructor.
      virtual ~ITEM (
         );

      //! Draw item.
      virtual void Draw (
         const DRAWCONTEXT& dc,           //!< Legend drawing context
         const LRECT2D& samplerect        //!< Rectangle for sample symbol, not including labels
         ) const;

   #ifdef WIN32_MFC
      //! Draw item with label in TreeView (WIN32_MFC).
      virtual void DrawTreeView (
         void *hdc,                       //!< Windows device context
         const GRE_ELEMSAMPLE_DC& dc,     //!< Legend drawing context
         const CRect& rect,               //!< Bounding rectangle including label
         bool HasFocus                    //!< 'true' if item has "focus"
         );
   #endif

      //! Convert "value" to position in legend coordinates.
      //! This accounts for whether minimum is at bottom/left or top/right.
      INT32 ValueToPosition (
         const GRE_LAYER_RASTER *layer,   //!< Raster layer
         double value,                    //!< Value to obtain position for
         INT32 size                       //!< Size of legend in pixels
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      GRE_LEGEND_COLORSCALE& m_legend;
      SIMPLE_ARRAY<COLOR> m_palette;
      double m_MinValue;
      double m_MaxValue;
      bool m_MinAtTop;

      ITEM (const ITEM&);
      ITEM& operator= (const ITEM&);

      friend class GRE_LEGEND_COLORSCALE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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

#endif   // INC_GRE_LEGEND_H

---