grid.h

Go to the documentation of this file.

/**
 * \file mgui/grid.h
 * \brief MGUI::CTRL_GRID class definitions
 *
 * \if NODOC
 * $Id: grid.h_v 1.53 2005/06/29 17:44:31 mju Exp $
 *
 * $Log: grid.h_v $
 * Revision 1.53  2005/06/29 17:44:31  mju
 * Template ctor needs to init onUserResizeColumnFunc.
 *
 * Revision 1.52  2005/05/23 23:12:16  dfriberg
 * Added virtual methods for column resize and order change
 *
 * Revision 1.51  2005/03/31 16:57:08  fileserver!dwilliss
 * Rename one of our types to MIUNICODE because it conflicted with a Microsoft #define
 *
 * Revision 1.50  2005/02/14 17:45:10  dwilliss
 * Changed parameters to method that I just added. Use const MISTRING& instead
 * of const MIUNICODE*
 *
 * Revision 1.49  2005/02/14 16:59:54  dwilliss
 * Added a new method
 *
 * Revision 1.48  2004/11/08 15:41:39  mju
 * Change lpoint2d to struct so matches previous defns.
 *
 * Revision 1.47  2004/11/04 20:31:49  dwilliss
 * added lpoint2D to OnRightClickItem
 *
 * Revision 1.46  2004/05/28 21:44:28  mju
 * Add methods using mistring.
 *
 * Revision 1.45  2004/05/25 15:09:50  mju
 * OnEndLabelEdit now uses non-const string.
 *
 * Revision 1.44  2003/10/27 21:22:32  mju
 * Remove SetItemFocus as done automatically by SetItemSelected.
 *
 * Revision 1.43  2003/10/03 19:58:19  linux32build!build
 * Doxygen
 *
 * Revision 1.42  2003/09/15 13:49:32  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.41  2003/09/11 16:59:18  mju
 * Specify namespace for ID in case ambiguous
 *
 * Revision 1.40  2003/09/10 21:30:48  mju
 * Use MGUI::ID for "item data".
 *
 * Revision 1.39  2003/07/24 20:13:09  dwilliss
 * Added a STYLE type
 *
 * Revision 1.38  2003/04/09 20:50:59  dwilliss
 * Don't use _T in tmplates. Mac's ctype.h defines a global _T
 *
 * Revision 1.37  2003/01/27 18:54:28  mju
 * Add GetHeadingHeight.
 *
 * Revision 1.36  2003/01/24 21:05:28  mju
 * Add InsertItem methods taking position.
 *
 * Revision 1.35  2003/01/24 20:41:10  mju
 * Add EditItem methods.
 *
 * Revision 1.34  2003/01/23 20:18:07  mju
 * Make all methods referencing wrapped control non-inline.
 *
 * Revision 1.33  2003/01/15 18:29:51  mju
 * Remove #ifdefed-out methods.
 *
 * Revision 1.32  2003/01/06 18:15:30  dwilliss
 * Typo in template
 *
 * Revision 1.31  2003/01/06 17:47:59  dwilliss
 * Added members to keep track of previously selected item so that we can
 * implement multiselect
 *
 * Revision 1.30  2003/01/06 15:45:14  dwilliss
 * Revert back to Mike's fix.  I didn't realize he had "fixed" it for me in
 * a way counter to the way I would have done it.
 *
 * Revision 1.28  2003/01/06 14:08:24  mju
 * Fix template to use correct signature for onitemselect/unselect.
 *
 * Revision 1.27  2003/01/03 23:09:11  dwilliss
 * almost right...
 *
 * Revision 1.26  2003/01/03 23:04:11  dwilliss
 * OnItemSelect/Unselect need to return bool on the actual control used in X
 *
 * Revision 1.25  2002/12/11 15:20:35  mju
 * Move contrib stuff here.
 *
 * Revision 1.24  2002/10/24 21:51:46  dwilliss
 * Had broken something in MFC-only code
 *
 * Revision 1.23  2002/10/24 20:52:19  dwilliss
 * Fixed sorting issues
 *
 * Revision 1.22  2002/10/11 14:50:15  dwilliss
 * Moved KEYSTATE enum out of this control and into ctrl.h
 *
 * Revision 1.21  2002/10/10 19:49:40  dwilliss
 * Took out a method that shouldn't be there
 *
 * Revision 1.20  2002/10/10 17:57:14  dwilliss
 * Made the KEYSTATE enum ORable.  The MIGRID that the X version is implemented
 * on now passes keyboard state through the OnLClicked methods
 *
 * Revision 1.19  2002/10/10 17:15:10  dwilliss
 * Added a KEYSTATE enum and parameter to all the OnClickXxx methods
 *
 * Revision 1.18  2002/10/09 16:35:29  mju
 * Rename as 'grid.h'.
 *
 * Revision 1.17  2002/10/09 16:07:48  mju
 * Moved to 'mgui' folder.
 *
 * Revision 1.16  2002/10/09 14:18:43  dwilliss
 * Change CUSTOMDRAW to call the HDC "gc" so it's the same name in X and MFC
 *
 * Revision 1.14  2002/06/07 15:58:26  dwilliss
 * OnGetDispInfo now returns bool
 *
 * Revision 1.13  2002/05/17 15:28:07  dwilliss
 * OnClickColumn defined inconsistantly between base and derived class - FIXED
 * Constructor had stupid compile error that only the Mac caught.
 *
 * Revision 1.12  2002/04/05 21:40:28  dwilliss
 * SetExtendedStyle() shouldn't be private
 *
 * Revision 1.11  2002/03/15 22:32:20  dwilliss
 * If not BeginLabelEditFunc() set in template, default should depend on
 * STYLE_EditLabels flag, not just always true
 *
 * Revision 1.10  2002/02/19 20:21:31  dwilliss
 * OnEditStart actually cancels the edit for X now
 *
 * Revision 1.6  2002/02/14 17:15:25  dwilliss
 * Added methods to delete columns
 *
 * Revision 1.5  2002/02/12 17:03:46  dwilliss
 * X implementation almost done
 *
 * Revision 1.3  2002/02/08 23:16:16  dwilliss
 * OnDrawItem now takes a struct with parameters instead of a bunch of parms
 *
 * Revision 1.2  2002/02/08 22:16:51  dwilliss
 * Compiles for both X and MFC now.  Renamed to CTRL_GRID (was CTRL_LIST)
 *
 * Revision 1.1  2002/02/04 18:48:22  dwilliss
 * Initial revision
 *
 * 
 * 2     12/13/01 10:55a Mju
 * MGUI unificiation with X.
 * 
 * 1     12/03/01 9:41a Mju
 * \endif
**/

#ifndef  INC_MGUI_GRID_H
#define  INC_MGUI_GRID_H

#ifndef  INC_MGUI_CTRL_H
#include <mgui/ctrl.h>
#endif

namespace MGD {
   class CONTEXT;
   }

struct LPOINT2D;

namespace MGUI {

class IMAGELIST;

//------------------------------------------------------------------------------------------------
//! Grid user interface class.
//! There is also a MGUI::CTRL_GRID_T template which helps eliminate the need for subclassing.  See
//! the description for MGUI::CTRL for more information on using templates.
//! There are two general ways to work with lists, "standard" and "owner-data" (virtual).  In the
//! standard configuration the list control itself contains all of the data (strings, icons, states)
//! for each list entry.  In the "owner-data" configuration, the data is stored outside the list
//! and the OnGetDispInfo and OnOwnerDataCacheHint methods are overridden (or set when using the
//! template) and will be called by the list control when data is needed to be displayed in the list.
class CTRL_GRID : public MGUI::CTRL {
   public:

      // Note: enum constants are the same values as the MFC #defines but hard-coded since they're not defined in the X case (alternative was ugly repetition)
      enum FORMAT {
         FORMAT_Left =           0, //!< LVCFMT_LEFT,
         FORMAT_Right =          1, //!< LVCFMT_RIGHT
         FORMAT_Center =         2  //!< LVCFMT_CENTER,
         };

      enum STYLE {
         STYLE_AlignLeft =       0x0800,  //!<LVS_ALIGNLEFT,
         STYLE_AlignTop =        0x0000,  //!<LVS_ALIGNTOP,
         STYLE_AutoArrange =     0x0100,  //!<LVS_AUTOARRANGE,
         STYLE_EditLabels =      0x0200,  //!<LVS_EDITLABELS,
         STYLE_NoColumnHeader =  0x4000,  //!<LVS_NOCOLUMNHEADER,
         STYLE_NoLabelWrap =     0x0080,  //!<LVS_NOLABELWRAP,
         STYLE_NoScroll =        0x2000,  //!<LVS_NOSCROLL,
         STYLE_NoSortHeader =    0x8000,  //!<LVS_NOSORTHEADER,
         STYLE_OwnerData =       0x1000,  //!<LVS_OWNERDATA,
         STYLE_ShowSelAlways =   0x0008,  //!<LVS_SHOWSELALWAYS,
         STYLE_NoGridLines =     0x0001,  //!<
         STYLE_SingleSel =       0x0004,  //!<LVS_SINGLESEL,
         STYLE_SortAscending =   0x0010,  //!<LVS_SORTASCENDING,
         STYLE_SortDescending =  0x0020   //!<LVS_SORTDESCENDING
         };

      enum VIEWMODE {
         VIEWMODE_Icon =         0,    //!<LVS_ICON,           NOTE: Not implemented in X case
         VIEWMODE_Report =       1,    //!<LVS_REPORT,         
         VIEWMODE_SmallIcon =    2,    //!<LVS_SMALLICON    NOTE: Not implemented in X case
         VIEWMODE_List =         3     //!<LVS_LIST,           
         };

      enum IMAGELISTTYPE {
         IMAGELISTTYPE_Normal =  0,    //!< LVSIL_NORMAL
         IMAGELISTTYPE_Small  =  1,    //!< LVSIL_SMALL
         IMAGELISTTYPE_State  =  2     //!< LVSIL_STATE
         };

      //! Structure passed to OnGetDispInfo
      //! Note: for the present, only the m_text member is supported by X
      struct DISPINFO {
         DISPINFO () :
            m_indent(0),
            m_IconIndex(-1),
            m_StateImageIndex(-1),
            m_OverlayImageIndex(-1),
            m_bSelected(false) 
            {}
            
         ~DISPINFO() {}

         MISTRING m_text;  //!< String to display
         int m_indent;     //!< Number of icon widths to indent (default == 0)
         int m_IconIndex;  //!< 0-based Index into IMAGELIST set by SetImageList(), -1 == none
         int m_StateImageIndex;  //!< Displayed next to the item's icon -1 = none.  
         int m_OverlayImageIndex;   //!< Drawn on top of item's icon. -1 = none.
         bool m_bSelected; 
         };
      
      //! Structure passed to OnDrawItem()
      struct CUSTOMDRAW {
         int row;
         int col;
         LRECT2D rect;
         COLOR BackgroundColor;
         COLOR TextColor;
         bool ChangedBackgroundColor;
         bool ChangedTextColor;
      #ifdef WIN32_MFC
         HDC gc;
      #else
         MGD::CONTEXT* gc;
      #endif
         };
            
      //! Constructor.
      CTRL_GRID (
         );

      //! Destructor.
      virtual ~CTRL_GRID (
         );

      //! Create the control.
      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    //!< Parent pane
         int height = 10,                       //!< Height in rows,
         int width = 40,                        //!< Width in 'em' characters
         VIEWMODE viewmode = VIEWMODE_Report,   //!< Initial viewing mode
         STYLE style = STYLE_AlignTop,          //!< List style
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_Expand
         );

      //! Delete all columns.
      void DeleteAllColumns (
         );

      //! Delete all items.
      void DeleteAllItems (
         );

      //! Delete specified column.
      void DeleteColumn (
         int col
         );

      //! Delete specified item.
      void DeleteItem (
         int itemnum
         );

      //! Delete specified item given assigned data value.
      void DeleteItemByData (
         ID id
         );

      //! Deselect all items.
      void DeselectAllItems (
         );

      //! Begin editing specified item, starting with currently displayed value.
      //! @return true if successful, false if not.
      bool EditItem (
         int itemnum,
         int column = 0,
         bool selectall = true                  //!< Select all existing text so typing will replace
         );

      //! Begin editing specified item, starting with specified string.
      //! @return true if successful, false if not.
      bool EditItem (
         int itemnum,
         int column,
         const MIUNICODE *initstr,                 //!< String to replace with prior to editing
         bool selectall = true                  //!< Select all existing text so typing will replace
         );

      //! Ensures that an item is visible.
      void EnsureVisible (
         int itemnum,
         bool PartialOK = false
         );

      //! Find item by matching specified data value as pointer.
      //! @return Item number or -1 if none found.
      int FindItemByData (
         const void* value
         ) const;

      //! Find item by matching specified data value as ID.
      //! @return Item number or -1 if none found.
      int FindItemByData (
         ID data
         ) const { return (FindItemByData((void*)data)); }

      //! Get the index (row number) of the bottom-most visible item.
      //! Note: Return value may be greater than number of rows of data
      //! if more rows are visible than there are data for.
      int GetBottomRow (
         ) const { return (GetTopRow() + GetCountPerPage()); }

      //! Get the bounding rectangle of a single cell.
      bool GetCellRect (
         int itemnum,
         int col,
         LRECT2D& rect
         ) const;

      //! Get number of columns in the list.
      int GetColumnCount (
         ) const;

      //! Get the label for a column.
      //! @return true if successful, false otherwise
      bool GetColumnLabel (
         int column,
         MISTRING& label
         ) const;

      //! Get the order of columns in the list.  
      //! Columns can be reordered by dragging them around if you call
      //! SetExtendedStyle() with LVS_EX_HEADERDRAGDROP
      ERRVALUE GetColumnOrderArray (
         SIMPLE_ARRAY<INT32>& array
         );

      //! Get the width of a column in pixels.
      int GetColumnWidth (
         int column
         ) const;

      //! Get number of items that can fit vertically in the visible area of control (in report mode only).
      int GetCountPerPage (
         ) const;

      //! Get height of heading in pixels.
      int GetHeadingHeight (
         ) const;

      //! Get number of items in list.
      int GetItemCount (
         ) const;

      //! Get data value associated with item.
      MGUI::ID GetItemData (
         int itemnum
         ) const;

      //! Get next selected item in list.
      //! @return Index of next item or -1 if no more items.
      int GetNextSelectedItem (
         int startitem = -1                     //!< Starting item for search, starting item is excluded
         ) const;

      //! Get number of selected items.
      int GetSelectedCount (
         ) const;

   #ifdef WIN32_MFC
      //! Return the rectangle (in client coordinates) of a given row/column in the list
      //! Only exists in MFC version because it returns an MFC CRect
      BOOL GetSubItemRect (
         int item,
         int colnum,
         CRect& rect
         );
   #endif

      //! Get the index (row number) of the top-most visible item
      int GetTopRow (
         ) const;

      //! Insert new column with label from resource or ASCII string.
      int InsertColumn (
         int colnum,                            //!< Column number and subitem
         const char *string,                    //!< String for resource lookup or to set
         FORMAT format = FORMAT_Left,           //!< Column format
         int width = -1,                        //!< Width of column in PIXELS
         bool lookup = true                     //!< 'true' to perform resource lookup, false to use string as-is
         );

      //! Insert new column with label from MIUNICODE* string.
      int InsertColumn (
         int colnum,                            //!< Column number and subitem
         const MIUNICODE *string,                  //!< String for column heading
         FORMAT format = FORMAT_Left,           //!< Column format
         int width = -1                         //!< Width of column in PIXELS
         );

      //! Insert new column with label from MISTRING;
      int InsertColumn (
         int colnum,                            //!< Column number and subitem
         const MISTRING& string,                //!< String for column heading
         FORMAT format = FORMAT_Left,           //!< Column format
         int width = -1                         //!< Width of column in PIXELS
         ) { return (InsertColumn(colnum,static_cast<const MIUNICODE*>(string),format,width)); }

      //! Insert new column with label from MIUNICODE* string.
      //! Every cell in the column is a combo box.
      //! The menu parameter is an MISTRING of newline-seperated entries to
      //! use when populating the drop down menu.  Note that other than having
      //! a fixed set of options in a dropdown menu, this column type still
      //! returns its current value as text, not as anything numeric. 
      //!
      //! @note This column type is only implemented in X, not MFC.
      int InsertColumnComboBox (
         int colnum,                            //!< Column number and subitem
         const MISTRING& label,                 //!< String for column heading
         const MISTRING& menu,
         int width = -1                         //!< Width of column in PIXELS
         );

      //! Insert new item from resource or ASCII string.
      //! @return Item number of inserted item if successful, < 0 if error.
      int InsertItem (
         const char *string,                    //!< String for resource lookup or to set
         bool lookup = true                     //!< 'true' to perform resource lookup, false to use string as-is
         );

      //! Insert new item with Unicode string.
      //! @return Item number of inserted item if successful, < 0 if error.
      int InsertItem (
         const MIUNICODE *string                //!< Item string
         );

      //! Insert new item with Unicode string.
      //! @return Item number of inserted item if successful, < 0 if error.
      int InsertItem (
         const MISTRING& string                 //!< Item string
         ) { return (InsertItem(static_cast<const MIUNICODE*>(string))); }

      //! Insert new item at specified position from resource or ASCII string.
      //! @return Item number of inserted item if successful, < 0 if error.
      int InsertItem (
         int pos,                               //!< Item position in list
         const char *string,                    //!< String for resource lookup or to set
         bool lookup = true                     //!< 'true' to perform resource lookup, false to use string as-is
         );

      //! Insert new item at specified position with Unicode string.
      //! @return Item number of inserted item if successful, < 0 if error.
      int InsertItem (
         int pos,                               //!< Item position in list
         const MIUNICODE *string                //!< Item string
         );

      //! Determine if specified item is currently "selected".
      //! @return 'true' if selected, 'false' if not.
      bool IsItemSelected (
         int itemnum
         ) const;

      //! Force the control to repaint all items.
      void Redraw (
         bool updatenow = true
         );

      //! Force the control to repaint a range of items.
      void RedrawItems (
         int firstitemnum,
         int lastitemnum,
         bool updatenow = true
         );

      //! Set column label.
      //! @return true if successful, false otherwise
      bool SetColumnLabel (
         int column,
         const MIUNICODE* label
         );

      //! Set the order of columns within the list.
      void SetColumnOrderArray (
         SIMPLE_ARRAY<INT32>& array
         );

      //! Set the width of a column.  The width can be in pixels or one of the
      //! constants LVSCW_AUTOSIZE or LVSCW_AUTOSIZE_USE_HEADER as described in
      //! LVM_SETCOLUMNWIDTH in the Platform SDK documentation.
      void SetColumnWidth (
         int column,
         int width
         );

   #ifdef WIN32_MFC
      //! Set extended styles.    (MFC version only)
      void SetExtendedStyle (
         UINT32 exstyles,                       //!< LVS_EX_...
         UINT32 mask = 0                        //!< Mask for styles to change, 0 to set all specified
         );
   #endif

      //! Set image list.
      void SetImageList (
         IMAGELIST& imagelist,                  //!< Image list
         IMAGELISTTYPE listtype = IMAGELISTTYPE_Small,            //!< Type of image list, IMAGELISTTYPE_Normal, IMAGELISTTYPE_Small or IMAGELISTTYPE_State
         bool shared = false                    //!< 'true' if image list is shared, 'false' if control should take ownership
         );

      //! Set number of items in list.
      int SetItemCount (
         int NumItems
         );

      //! Set application-specific data to associate with list item.
      void SetItemData (
         int itemnum,                           //!< Item number
         ID value                         //!< Value to associate with item
         );

      //! Set the image index to use for a givem item.
      //! This only handles column 0, and currently only for MFC
      //! Pass -1 for imageindex to have no icon
      //! imageindex is a 0-based index into the IMAGELIST set via
      //! SetImageList()
      void SetItemImage (
         int itemnum,
         int imageindex
         );

      //! Set whether item is 'selected or not.
      void SetItemSelected (
         int itemnum,                           //!< Item number
         bool selected = true
         );

      //! Set item or subitem text from resource or ASCII string.
      void SetItemText (
         int itemnum,                           //!< Item number
         int subitem,                           //!< Sub item, 0 for item
         const char *string,                    //!< String for resource lookup or to set
         bool lookup = true                     //!< 'true' to perform resource lookup, false to use string as-is
         );

      //! Set item or subitem text from Unicode string.
      void SetItemText (
         int itemnum,                           //!< Item number
         int subitem,                           //!< Sub item, 0 for item
         const MIUNICODE *string                //!< Item or subitem string
         );

      //! Sort the data in the list on a given column.
      void SortItems (
         int column = 0,         //!< Column to sort on
         bool bAscending = true
         );

      //! Force the control to repaint a specified item
      void Update (
         int itemnum
         );

   protected:

      STYLE GetStyle (
         ) const { return m_style; }

      //! Called when user clicks on label to begin editing.
      //! @return 'false' if editing is NOT allowed or 'true' if editing is allowed.
      //! Default implementation always returns 'true' if the grid was
      //! created with STYLE_EditLabels or 'false' if not.
      virtual bool OnBeginLabelEdit (
         int itemnum,
         int subitemnum
         );

      //! Called when the order of the columns are changed.
      virtual void OnChangeColumnOrder (
         int fromCol,
         int toCol
         );

      //! Called when user clicks on column heading.
      virtual void OnClickColumn (
         int itemnum,
         int column,
         KEYSTATE state
         );

      //! Called when user left-clicks on a list item.
      virtual void OnClickItem (
         int itemnum,                                             
         int column,
         KEYSTATE state
         );

      //! Called when user double-left-clicks on a list item.
      virtual void OnDoubleClickItem (
         int itemnum,
         int column,
         KEYSTATE state
         );
      
      //! Called before an item is drawn.
      //! Override if you want to do the drawing yourself. 
      //! Should return true if you did all the drawing.  Return false to let the base class draw the item.
      virtual bool OnDrawItem (
         CUSTOMDRAW& drawinfo
         );

      //! Called when user clicks on label to begin editing.
      //! @return 'true' if to accept changes or 'false' to reject changes.
      //! Default implementation always returns 'true' if the grid was
      //! created with STYLE_EditLabels or 'false' if not.
      virtual bool OnEndLabelEdit (
         int row,
         int col,
         MISTRING& string
         );

      //! Called by list to request information stored by owner rather than list.
      //!
      //! Derived implementation should return true if it actually filled in
      //! anything.  Return false to behave as if OnGetDispInfo wasn't overridden.
      virtual bool OnGetDispInfo (
         int row,
         int col,
         CTRL_GRID::DISPINFO& dispinfo 
         );

      //! Called when an item is "activated" (normally via a double click).
      virtual void OnItemActivate (
         );

      //! Called by SortItems() to compare items.
      //! Should return < 0 if rowitem1 should precede rowitem2 and > 0 if rowitem1 should follow rowitem2
      //! and 0 if the two items are equivalent.
      //! XXX DEPRECATED. Don't override this, override the one that takes
      //! a column number and direction
      virtual int OnItemCompare (
         UINT32 rowitem1,
         UINT32 rowitem2
         );

      //! Called by SortItems() to compare items.
      //! Should return < 0 if rowitem1 should precede rowitem2 and > 0 if rowitem1 should follow rowitem2
      //! and 0 if the two items are equivalent.
      //! if bAscending is false, you should reverse the order.
      virtual int OnItemCompare (
         UINT32 rowitem1,
         UINT32 rowitem2,
         int colnum,
         bool bAscending
         );

      //! Called when an item is "selected".
      virtual void OnItemSelect (
         int itemnum,
         int subitemnum
         );

      //! Called when an item is "unselected".
      virtual void OnItemUnselect (
         int itemnum,
         int subitemnum
         );

      //! Called for owner-data list to provide hints about what to cache.
      virtual void OnOwnerDataCacheHint (
         int from,
         int to
         );

      //! Called when user right-clicks on a list item.
      virtual void OnRightClickItem (
         int itemnum,
         int column,
         const LPOINT2D&,
         KEYSTATE state
         );

      //! Called when user release mouse after dragging column header.
      virtual void OnUserResizeColumn (
         int column,
         int width
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class MyListCtrl;
      friend class MyListCtrl;

      MyListCtrl *m_pCtrl;
      STYLE m_style;
      int m_PrevSelRow;
      int m_PrevSelCol;

      // UNIMPLEMENTED / UNSUPPORTED
      CTRL_GRID (const CTRL_GRID&);
      CTRL_GRID& operator= (const CTRL_GRID&);

   #ifdef WIN32_MFC
      static int CALLBACK CompareCallback (LPARAM rowitem1, LPARAM rowitem2, LPARAM cbdata);
   #endif
      #endif // GENERATING_DOXYGEN_OUTPUT


   };

DEFINE_ENUM_OPERATORS(MGUI::CTRL_GRID::STYLE);


//------------------------------------------------------------------------------------------------
//! List control template.
template <class _CT> class CTRL_GRID_T : public MGUI::CTRL_GRID {
   public:
      //! Constructor.
      CTRL_GRID_T (
         ):
         m_pContainer(0),
         m_OnBeginLabelEditFunc(0),
         m_OnClickColumnFunc(0),
         m_OnClickItemFunc(0),
         m_OnDoubleClickItemFunc(0),
         m_OnEndLabelEditFunc(0),
         m_OnGetDispInfoFunc(0),
         m_OnItemActivateFunc(0),
         m_OnItemDrawFunc(0),
         m_OnItemCompareFunc(0),
         m_OnItemSelectFunc(0),
         m_OnItemUnselectFunc(0),
         m_OnOwnerDataCacheHintFunc(0),
         m_OnRightClickItemFunc(0),
         m_OnUserResizeColumnFunc(0)
         { }

      //! Destructor.
      virtual ~CTRL_GRID_T (
         ) { }

      //! Create list box control with no label.
      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    //!< Parent pane
         _CT *pContainer,                       //!< Pointer to callback container class
         int height = 10,                       //!< Height in rows,
         int width = 40,                        //!< Width in 'em' characters
         VIEWMODE viewmode = VIEWMODE_Report,   //!< Initial viewing mode
         STYLE style = STYLE_AlignTop,          //!< List style
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_Expand
         ) {
         m_pContainer = pContainer;
         CTRL_GRID::Create(ParentPane,height,width,viewmode,style,sizealign);
         return;
         }

      //! Set method to call when user clicks on label to begin editing.
      void SetBeginLabelEditFunc (
         bool (_CT::*BeginLabelEditFunc)(int row, int col)
         ) { m_OnBeginLabelEditFunc = BeginLabelEditFunc; };

      //! Set method to call when user changes order of columns.
      void SetChangeColumnOrderFunc (
         void (_CT::*ChangeColumnOrderFunc)(int fromCol, int toCol)
         ) { m_OnChangeColumnOrderFunc = ChangeColumnOrderFunc; };

      //! Set method to call when user clicks on a column heading.
      void SetClickColumnFunc (
         void (_CT::*ClickColumnFunc)(int itemnum, int column, KEYSTATE state)
         ) { m_OnClickColumnFunc = ClickColumnFunc; };

      //! Set method to call when user left-clicks on an item.
      void SetClickItemFunc (
         void (_CT::*ClickItemFunc)(int itemnum, int column, KEYSTATE state)
         ) { m_OnClickItemFunc = ClickItemFunc; };

      //! Set method to call when user double-left-clicks on an item.
      void SetDoubleClickItemFunc (
         void (_CT::*DoubleClickItemFunc)(int itemnum, int column, KEYSTATE state)
         ) { m_OnDoubleClickItemFunc = DoubleClickItemFunc; };

      //! Set method to call when user clicks on label to end editing.
      void SetEndLabelEditFunc (
         bool (_CT::*EndLabelEditFunc)(int row, int col, MISTRING& string)
         ) { m_OnEndLabelEditFunc = EndLabelEditFunc; };

      //! Set method to call when user activates or deactivates item.
            //! XXX NMLVDISPINFO& is meaningless in X case
      void SetGetDispInfoFunc (
         bool (_CT::*GetDispInfoFunc)(int row, int col, DISPINFO& info)
         ) { m_OnGetDispInfoFunc = GetDispInfoFunc; };

      //! Set method to call when user activates or deactivates item.
      void SetItemActivateFunc (
         void (_CT::*ItemActivateFunc)()
         ) { m_OnItemActivateFunc = ItemActivateFunc; };

      //! Set method to call for compare two items for sorting
      //! Should return < 0 if rowitem1 should precede rowitem2 and > 0 if rowitem1 should follow rowitem2
      //! and 0 if the two items are equivalent.
      void SetItemCompareFunc (
         int (_CT::*ItemCompareFunc)(UINT32 rowitem1, UINT32 rowitem2, int ColNum, bool bAscending)
         ) { m_OnItemCompareFunc = ItemCompareFunc; };

      //! Set method to call for custom item drawing.
            //! XXX NMLVCUSTOMDRAW& is meaningless in X case
      void SetItemDrawFunc (
         bool (_CT::*ItemDrawFunc)(CUSTOMDRAW&)
         ) { m_OnItemDrawFunc = ItemDrawFunc; };

      //! Set method to call when item is selected
      void SetItemSelectFunc (
         void (_CT::*ItemSelectFunc)(int itemnum, int subitemnum)
         ) { m_OnItemSelectFunc = ItemSelectFunc; };

      //! Set method to call when item is unselected
      void SetItemUnselectFunc (
         void (_CT::*ItemUnselectFunc)(int itemnum, int subitemnum)
         ) { m_OnItemUnselectFunc = ItemUnselectFunc; };

      //! Set method to call when user activates or deactivates item.
      void SetOwnerDataCacheHintFunc (
         void (_CT::*OwnerDataCacheHintFunc)(int from, int to)
         ) { m_OnOwnerDataCacheHintFunc = OwnerDataCacheHintFunc; };

      //! Set method to call when user right-clicks on an item.
      void SetRightClickItemFunc (
         void (_CT::*RightClickItemFunc)(int itemnum, int column, const LPOINT2D&, KEYSTATE state)
         ) { m_OnRightClickItemFunc = RightClickItemFunc; };

      //! Set method to call when user resizes column and releases mouse button.
      void SetUserResizeColumnFunc (
         void (_CT::*OnUserResizeColumnFunc)(int column, int width)
         ) { m_OnUserResizeColumnFunc = OnUserResizeColumnFunc; };

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      virtual bool OnBeginLabelEdit (
         int row,
         int col
         ) { 
         if (m_OnBeginLabelEditFunc != 0) {
            return (m_pContainer->*m_OnBeginLabelEditFunc)(row, col);
            }
         else {
            return ((GetStyle() & STYLE_EditLabels) != 0);
            }
         }

      virtual void OnChangeColumnOrder (
         int fromCol,
         int toCol
         ) { if (m_OnChangeColumnOrderFunc != 0) (m_pContainer->*m_OnChangeColumnOrderFunc)(fromCol, toCol); }

      virtual void OnClickColumn (
         int itemnum,
         int column,
         KEYSTATE state
         ) { if (m_OnClickColumnFunc != 0) (m_pContainer->*m_OnClickColumnFunc)(itemnum,column,state); }

      virtual void OnClickItem (
         int itemnum,
         int column,
         KEYSTATE state
         ) { if (itemnum >= 0 && m_OnClickItemFunc != 0) (m_pContainer->*m_OnClickItemFunc)(itemnum,column,state); 
            else CTRL_GRID::OnClickItem(itemnum, column, state); 
         }

      virtual void OnDoubleClickItem (
         int itemnum,
         int column,
         KEYSTATE state
         ) { if (m_OnDoubleClickItemFunc != 0) (m_pContainer->*m_OnDoubleClickItemFunc)(itemnum,column, state); }

      virtual int OnItemCompare (
         UINT32 rowitem1,
         UINT32 rowitem2,
         int colnum,
         bool bAscending
         ) { if (m_OnItemCompareFunc != 0) return ((m_pContainer->*m_OnItemCompareFunc)(rowitem1, rowitem2, colnum, bAscending)); else return (0); }

      virtual bool OnDrawItem (
         CUSTOMDRAW& drawinfo
         ) { if (m_OnItemDrawFunc != 0) return ((m_pContainer->*m_OnItemDrawFunc)(drawinfo)); else return (false); }

      virtual bool OnEndLabelEdit (
         int row,
         int col,
         MISTRING& string
         ) { return ((m_OnEndLabelEditFunc != 0) ? (m_pContainer->*m_OnEndLabelEditFunc)(row, col, string) : true); }

      virtual bool OnGetDispInfo (
         int row,
         int col,
         DISPINFO& info
         ) { if (m_OnGetDispInfoFunc != 0) return((m_pContainer->*m_OnGetDispInfoFunc)(row, col, info)); 
         return (false);
         }

      virtual void OnItemActivate (
         ) { if (m_OnItemActivateFunc != 0) (m_pContainer->*m_OnItemActivateFunc)(); }

      virtual void OnItemSelect (
         int itemnum,
         int subitemnum
         ) { if (m_OnItemSelectFunc != 0) (m_pContainer->*m_OnItemSelectFunc)(itemnum, subitemnum);
            else CTRL_GRID::OnItemSelect(itemnum, subitemnum);
         }

      virtual void OnItemUnselect (
         int itemnum,
         int subitemnum
         ) { if (m_OnItemUnselectFunc != 0) (m_pContainer->*m_OnItemUnselectFunc)(itemnum, subitemnum);
            else CTRL_GRID::OnItemUnselect(itemnum, subitemnum);
         }

      virtual void OnOwnerDataCacheHint (
         int from,
         int to
         ) { if (m_OnOwnerDataCacheHintFunc != 0) (m_pContainer->*m_OnOwnerDataCacheHintFunc)(from,to); };

      virtual void OnRightClickItem (
         int itemnum,
         int column,
         const LPOINT2D& pt,
         KEYSTATE state
         ) { if (m_OnRightClickItemFunc != 0) (m_pContainer->*m_OnRightClickItemFunc)(itemnum,column,pt,state); }

      virtual void OnUserResizeColumn (
         int column,
         int width
         ) { if (m_OnUserResizeColumnFunc != 0) (m_pContainer->*m_OnUserResizeColumnFunc)(column, width); }

      _CT *m_pContainer;
      bool (_CT::*m_OnBeginLabelEditFunc)(int row, int col);
      void (_CT::*m_OnChangeColumnOrderFunc)(int fromCol, int toCol);
      void (_CT::*m_OnClickColumnFunc)(int row, int column, KEYSTATE state);
      void (_CT::*m_OnClickItemFunc)(int row, int column, KEYSTATE state);
      void (_CT::*m_OnDoubleClickItemFunc)(int row, int column, KEYSTATE state);
      bool (_CT::*m_OnEndLabelEditFunc)(int row, int col, MISTRING& string);
      bool (_CT::*m_OnGetDispInfoFunc)(int row, int col, CTRL_GRID::DISPINFO&info);
      void (_CT::*m_OnItemActivateFunc)();
      void (_CT::*m_OnItemSelectFunc)(int item, int subitem);
      void (_CT::*m_OnItemUnselectFunc)(int item, int subitem);
      int (_CT::*m_OnItemCompareFunc)(UINT32 rowitem1, UINT32 rowitem2, int col, bool bAscending);
      bool (_CT::*m_OnItemDrawFunc)(CUSTOMDRAW& drawinfo);
      void (_CT::*m_OnOwnerDataCacheHintFunc)(int from, int to);
      void (_CT::*m_OnRightClickItemFunc)(int itemnum, int column, const LPOINT2D&, KEYSTATE state);
      void (_CT::*m_OnUserResizeColumnFunc)(int column, int width);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//------------------------------------------------------------------------------------------------

}  // End of MGUI namespace

#endif   // INC_MGUI_GRID_H

---