mi32/migrid.h

Go to the documentation of this file.

#ifndef  INC_MI32_MIGRID_H
#define  INC_MI32_MIGRID_H

#ifndef INC_MI32_MGD2_H
#include <mi32/mgd2.h>
#endif

#ifndef INC_MI32_MEMPOOL_H
#include <mi32/mempool.h>
#endif

#ifndef INC_MGUI_TOOLTIP_H
#include <mgui/tooltip.h>
#endif

#ifndef INC_MGUI_MENU_H
#include <mgui/menu.h>
#endif

#ifndef INC_MI32_UCSTRING_H
#include <mi32/ucstring.h>
#endif

#ifndef INC_MI32_XDEFNS_H
#include <mi32/xdefns.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class MIGRIDCELL;
class MIGRIDCTRL;
class MIGRIDEDITHANDLE;
class DBEDIT;
class DBEDIT_TDATA;
namespace MGUI {
   class IMAGELIST;
   class CTRL_TOOLTIP;
   }
namespace MGD {
   class IMAGELIST;
   class DEVICE_X;
   }
#endif



class MIGRIDCELL {
public:
   enum ALIGNMENT {
      ALIGN_Left      = 0,
      ALIGN_Right,
      ALIGN_Center
      };
   
   enum BORDER {
      BORDER_None       = 0x0000,      
      BORDER_LThin      = 0x0001,
      BORDER_TThin      = 0x0002,
      BORDER_RThin      = 0x0004,
      BORDER_BThin      = 0x0008,
      BORDER_Thin       = 0x000F,
      BORDER_LMedium    = 0x0010,
      BORDER_TMedium    = 0x0020,
      BORDER_RMedium    = 0x0040,
      BORDER_BMedium    = 0x0080,
      BORDER_Medium     = 0x00FF,
      BORDER_LThick     = 0x0100,
      BORDER_TThick     = 0x0200,
      BORDER_RThick     = 0x0400,
      BORDER_BThick     = 0x0800,
      BORDER_Thick      = 0x0FFF,
      BORDER_Left       = 0x0111,      
      BORDER_Top        = 0x0222,      
      BORDER_Right      = 0x0444,      
      BORDER_Bottom     = 0x0888,      
      BORDER_Recessed   = 0x1000,
      BORDER_Raised     = 0x2000
      }; 


   enum PROPERTY {
      PROP_None         = 0x00000000,
      PROP_Text         = 0x00000001,
      PROP_FGColor      = 0x00000002,
      PROP_BGColor      = 0x00000004,
      PROP_BorderStyle  = 0x00000008,
      PROP_Alignment    = 0x00000010,
      PROP_DecimalPlaces= 0x00000020,
      PROP_ReadOnly     = 0x00000040,
      PROP_DataType     = 0x00000080,
      PROP_Param        = 0x00000100,
      PROP_CellType     = 0x00000200,
      PROP_CellTypeEx   = 0x00000400,
      PROP_Label        = 0x00000800,
      PROP_FGHColor     = 0x00001000,
      PROP_BGHColor     = 0x00002000,
      PROP_Bool         = 0x00004000,
      PROP_MaxLen       = 0x00008000,
      PROP_Icon         = 0x00010000,
      PROP_All          = 0xFFFFFFFF   
      };

   enum DATATYPE {
      DATATYPE_String,
      DATATYPE_Number,
      DATATYPE_Bool,
      DATATYPE_Time,
      DATATYPE_Currency,
      DATATYPE_Color
      };

   enum CELLTYPE {
      CELLTYPE_Text = 0,               
      CELLTYPE_Button = 1,             
      CELLTYPE_DropDown = 2,           
      CELLTYPE_Icon = 3,                  
      CELLTYPE_IconButton = 4,
      CELLTYPE_BigText = 5,            
      CELLTYPE_PopUp = 6,              
      CELLTYPE_Color = 7               
      };

   enum {
      CELLTYPEEX_Toggle    = 0x00000001,     
      CELLTYPEEX_Disabled  = 0x00000002      
      };

   // CONSTRUCTION / DESTRUCTION
   
   MIGRIDCELL (
      );

   MIGRIDCELL (
      const MIGRIDCELL&
      );

   ~MIGRIDCELL(
      );

   // OPERATORS

   MIGRIDCELL& operator=(
      const MIGRIDCELL&
      );

   // METHODS

   void ClearAll (
      );

   void ClearProperty (
      PROPERTY p
      );

   ALIGNMENT GetAlignment (
      ) const {
      return (m_set & PROP_Alignment) ? m_Alignment : ALIGN_Left;
      }

   const COLOR& GetBackColor (
      ) const {
      return (m_set & PROP_BGColor) ? m_BGColor : s_black;
      }
      
   const COLOR& GetBackColorHilighted (
      ) const  {
      return (m_set & PROP_BGHColor) ? m_BGHColor : GetBackColor();
      }

   bool GetBool (
      ) const 
      {
      return (m_set & PROP_Bool) ? m_bState : false;
      }
      
   BORDER GetBorder (
      ) const {
      return (m_set & PROP_BorderStyle) ? m_BorderStyle : BORDER_Thin;
      }

   CELLTYPE GetCellType (
      ) const {
      return (m_set & PROP_CellType) ? m_CellType : CELLTYPE_Text;
      }

   int GetCellTypeEx (
      ) const {
      return (m_set & PROP_CellTypeEx) ? m_nCellTypeEx : 0;
      }

   DATATYPE GetDataType (
      ) const {
      return (m_set & PROP_DataType) ? m_DataType : DATATYPE_String;
      }

   const COLOR& GetForeColor (
      ) const {
      return (m_set & PROP_FGColor) ? m_FGColor : s_black;
      }

   const COLOR& GetForeColorHilighted (
      ) const {
      return (m_set & PROP_FGHColor) ? m_FGHColor : GetBackColor();
      }

   int GetIconIndex (
      ) const {
      return (m_set & PROP_Icon) ? m_IconIndex : -1;
      }

   const MIUNICODE* GetLabelText (
      ) const {
      return (m_set & PROP_Label) ? m_Label : NULL;
      }


   int GetMaxLen (
      ) const {
      return (m_set & PROP_MaxLen) ? m_nMaxLen : -1;
      }

   double GetNumber (
      ) const;

   int GetNumberPlaces (
      ) const {
      return (m_set & PROP_DecimalPlaces) ? m_nPlaces : 0;
      }


   void* GetParam (
      ) const {
      return (m_set & PROP_Param) ? m_pParam : NULL;
      }

   bool GetReadOnly (
      ) const {
      return (m_set & PROP_ReadOnly) ? m_bReadOnly : false;
      }

   const MIUNICODE* GetText (
      ) const {
      static MIUNICODE EmptyString = 0;
      return ((m_set & PROP_Text) && m_str) ? m_str : &EmptyString;
      }

   MIUNICODE* GetTextCopy (
      ) const {
      return ((m_set & PROP_Text) && m_str) ? ucstrdup(m_str) : strtoucdup("");
      }

   bool IsEmpty (
      ) const {
      if (!(m_set & PROP_Text)) return (false);
      return (m_str[0] == 0);
      }


   bool HasProperty (
      PROPERTY property
      ) const {
      return ((m_set & property) != PROP_None);
      }

   void SetAlignment (
      ALIGNMENT alignment
      );

   void SetBackColor (
      const COLOR& color
      );

   void SetBackColorHilighted (
      const COLOR& color
      );

   void SetBool (
      bool state
      );

   void SetBorder (
      BORDER border
      );

   void SetCellType (
      CELLTYPE type
      );

   void SetCellTypeEx (
      INT32 val
      );

   void SetDataType (
      DATATYPE type
      );

   void SetForeColor (
      const COLOR& color
      );

   void SetForeColorHilighted (
      const COLOR& color
      );

   void SetIconIndex (
      int icon
      );

   void SetLabelText (
      const MIUNICODE*
      );

   void SetLabelText (
      const char*
      );

   void SetMaxLen (
      int num
      );

   void SetNumber (
      double num
      );

   void SetNumberDecimals (
      int num
      );

   void SetParam (
      void* ptr
      );

   void SetReadOnly (
      bool state
      );

   void SetText (
      const MIUNICODE*
      );

   void MergeProperties (
      const MIGRIDCELL& cell,
      bool bBlendColors = false,
      PROPERTY mask = PROP_All
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   
   // METHODS

   void SetProperty (
      PROPERTY prop
      ) {
      m_set = static_cast<PROPERTY>((UINT32)prop | (UINT32)m_set);
      }


   PROPERTY m_set;      
   MIUNICODE* m_str;
   MIUNICODE* m_Label;
   COLOR m_BGColor;
   COLOR m_FGColor;
   COLOR m_BGHColor;    
   COLOR m_FGHColor;    
   BORDER m_BorderStyle;
   ALIGNMENT m_Alignment;
   DATATYPE m_DataType;
   CELLTYPE m_CellType;
   INT32 m_nCellTypeEx;
   bool m_bReadOnly;
   bool m_bState;       
   int m_nPlaces;
   void* m_pParam;
   int m_nMaxLen;
   int m_IconIndex;

   static const COLOR s_black;   
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MIGRIDCELL::BORDER)
DEFINE_ENUM_OP_BITWISE(MIGRIDCELL::PROPERTY)
#endif


struct MIGRIDCUSTOMDRAW {
   MIGRIDCUSTOMDRAW (
      const MIGRIDCELL&, 
      const LRECT2D&, 
      MIGRIDCTRL&,
      MGD::CONTEXT* 
      );

   MIGRIDCUSTOMDRAW (
      const MIGRIDCUSTOMDRAW& rhs
      );

   LRECT2D rect;
   COLOR BackgroundColor;
   COLOR TextColor;
   const MIGRIDCELL& cell;
   bool ChangedBackgroundColor;  
   bool ChangedTextColor;  
   MGD::CONTEXT* gc;
   bool bSelected;
   bool bHasFocus;
   MIGRIDCTRL* pCtrl;
   };



class MIGRIDCELLTYPE {
public:

// CONSTRUCTION / DESTRUCTION

   MIGRIDCELLTYPE (
      ) :
      m_bDeleteWithGrid(false)
      {
      }

   virtual ~MIGRIDCELLTYPE (
      ) {
      }

   // METHODS

   
   virtual void v_Draw (
      int row,
      int col,
      MIGRIDCUSTOMDRAW& dd
      ); 

   virtual MIGRIDEDITHANDLE* v_StartEdit (
      MIGRIDCTRL* pCtrl,
      int col,
      int row,
      const LRECT2D& rect,
      const LPOINT2D* point,           
      const MIGRIDCELL& cell,
      int key = 0
      );

   virtual void v_OnDClicked (
      int col,
      int row,
      const LRECT2D& rect,
      const LPOINT2D& point,
      bool* pbProcessed,
      MIGRIDCTRL* pCtrl,
      UINT32 state      
      );

   virtual void v_OnLClicked (
      int col,
      int row,
      bool bIsDown,
      const LRECT2D& rect,
      const LPOINT2D& point,           
      bool* pbProcessed,
      MIGRIDCTRL* pCtrl,
      UINT32 state      
      );

   virtual void v_OnRClicked (
      int col,
      int row,
      bool bIsDown,
      const LRECT2D& rect,
      const LPOINT2D& point,
      bool* pbProcessed,
      MIGRIDCTRL* pCtrl,
      UINT32 state      
      );

   bool GetDeleteWithGrid (
      ) const {
      return (m_bDeleteWithGrid);
      }

   void SetDeleteWithGrid (
      bool state
      ) {
      m_bDeleteWithGrid = state;
      }

   static void SetDefaultColors (
      MGD::PIXEL ShadowPixelLight,
      MGD::PIXEL ShadowPixelDark,
      MGD::PIXEL FocusRectPixel,
      MGD::PIXEL BackgroundPixel
      ) {
      s_ShadowPixelLight = ShadowPixelLight;
      s_ShadowPixelDark = ShadowPixelDark;
      s_FocusRectPixel = FocusRectPixel;
      s_BackgroundPixel = BackgroundPixel;
      }

protected:
   virtual void v_DrawBackground (
      const MIGRIDCUSTOMDRAW&  drawdata
      );

   virtual void v_DrawBorder (
      const MIGRIDCUSTOMDRAW&  drawdata
      );

   void DrawBorder (
      const MIGRIDCUSTOMDRAW&  drawdata,
      MIGRIDCELL::BORDER border
      );

   virtual void v_DrawButton (
      const MIGRIDCUSTOMDRAW&  drawdata,
      bool bPressed,
      bool bTracking = false           
      );

   virtual void v_DrawText (
      const MIGRIDCUSTOMDRAW&  drawdata,
      const MIUNICODE* str = 0
      );

   void TrackButton (
      MIGRIDCTRL* pCtrl,
      int col,
      int row,
      const MIGRIDCELL& cell,
      const LRECT2D& rect,
      const LPOINT2D& point,
      bool bInitialState
      );

   virtual void v_OnButtonPress (
      MIGRIDCTRL* pCtrl,
      int col,
      int row,
      const MIGRIDCELL& cell,
      const LRECT2D& rect
      );

   static MGD::PIXEL s_ShadowPixelLight;
   static MGD::PIXEL s_ShadowPixelDark;
   static MGD::PIXEL s_FocusRectPixel;
   static MGD::PIXEL s_BackgroundPixel;

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
#ifdef X_NATIVE
   static void EH_TrackButtonEventHndler (
      Widget da, 
      void *ehdata, 
      XEvent *event,
      Boolean *ContToDispatch    
      );
#endif

   bool m_bDeleteWithGrid;    
   friend class MIGRIDCTRL;
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


class MIGRIDEDITHANDLE : public MIGRIDCELL {
public:

// CONSTRUCTION / DESTRUCTION

   MIGRIDEDITHANDLE (
      MIGRIDCTRL* pCtrl,
      int col,
      int row,
      const LRECT2D& rect,
      const MIGRIDCELL& cell
      ) :
      MIGRIDCELL(cell),
      m_pCtrl(pCtrl),
      m_rect(rect),
      m_col(col),
      m_row(row)
      {
      }

   virtual ~MIGRIDEDITHANDLE (
      );

   // METHODS
                  
   MDLGPARENT GetTextControl (
      ) const { return v_GetTextControl(); }

   bool Update (
      ) { return v_Update(); }

   void Move (
      const LRECT2D&  rect
      ) { v_Move(rect); }
   
protected:

   virtual MDLGPARENT v_GetTextControl (
      ) const {
      return NULL;
      }

   virtual void v_Move (
      const LRECT2D& // rect
      ) {
      }

   virtual bool v_Update (
      ) {
      return true;
      }

   void SendMouseEvent (
      Widget widget,
      int EventCode,
      const LPOINT2D* point
      );

   MIGRIDCTRL* m_pCtrl;
   LRECT2D m_rect;
   int m_col;
   int m_row;
   };



class MIGRIDCTRL {
   public:

      enum SECTION {
         SECTION_None   = 0,
         SECTION_Grid   =1,
         SECTION_TopHeading,
         SECTION_SideHeading,
         SECTION_CornerButton,
         SECTION_HScroll,
         SECTION_VScroll,
         SECTION_Tab,
         SECTION_ColBorder,
         SECTION_RowBorder
         };

      enum SCROLLMODE {
         SCROLLMODE_Normal,            
         SCROLLMODE_Tracking           
         };

      enum CELLSTATE {
         CELLSTATE_None    = 0x0000,   
         CELLSTATE_Button  = 0x0001,   
         CELLSTATE_Shift   = 0x0002,   
         CELLSTATE_Control = 0x0004    
         };

      enum MOVEMENT {
         MOVE_Increment = 0,
         MOVE_Decrement,
         MOVE_PageUp,
         MOVE_PageDown,
         MOVE_Top,
         MOVE_Bottom
         };
         
      struct SORTDATA {
         MIGRIDCTRL* m_this;
         int* m_cols;
         int m_NumCols;
         int m_bAscending;
         };

      static void Test (
         DBEDIT* ddata,
         DBEDIT_TDATA* tdata
         );

      // CONSTRUCTION / DESTRUCTION

      MIGRIDCTRL (
         );

      // Copy constructor goes here?

      virtual ~MIGRIDCTRL (
         );

      // METHODS

      MIGRIDCELL::CELLTYPE AddCellType (
         MIGRIDCELLTYPE* ptype,
         bool bDeleteInGridsDestructor = false
         );

      int AppendCol (
         );

      int AppendRow (
         );

      int ClearSelections (
         );

#ifdef X_NATIVE
      int Create (
         Widget parent,
         Arg *arg,
         int n
         );
#endif

      void DeleteAllItems (
         ) {
         // Used by MGUI::LIST
         SetNumberRows(0);
         }
      
      int DeleteCol (
         int col
         );

      void DeleteItem (    
         int row
         ) {
         // Used by MGUI::LIST
         DeleteRow(row);
         }

      int DeleteRow (
         int row
         );

      int EditCancel (
         );

      void EditFinish (
         MIGRIDEDITHANDLE* handle = NULL,
         bool bAborting = false
         );

      void EditFinish (
         int col,
         int row,
         const MIGRIDCELL& cell
         );

      int EnableColSwapping (
         bool bEnable = true
         );

      int EnableMenu (
         bool bEnable = true
         );

      void EnableUpdate (
         bool enable = true
         );

      void EnsureVisible (
         int row,
         int col,
         bool bPartialOK = false
         );

      int FindItemByData (
         PTRINT data
         ) const {
         return (FindItemByData((const void*)data));
         }

      int FindItemByData (
         const void* data
         ) const;

      int GetAbsoluteCellFromPoint (
         int x,                        
         int y,                        
         int* ptcol,                   
         int* ptrow                    
         ) const;

      int GetBottomRow (
         ) const;

      int GetCell (
         int col,
         int row,
         MIGRIDCELL* pCell
         ) const;


      int GetCell (
         int col,
         int row,
         MIGRIDCELL** ppCell
         ) const;

      int GetCellIndirect (
         int col,
         int row,
         MIGRIDCELL* pCell,
         MIGRIDCELL::PROPERTY properties = MIGRIDCELL::PROP_All
         ); 
         
      int GetCellRect (
         int col,
         int row,
         LRECT2D* rect
         ) const;

      int GetColDefault (
         int col,
         MIGRIDCELL* pCell
         ) const;

      int GetColTranslation (
         int VisualColumnNumber
         ) const;


      ERRVALUE GetColumnOrderArray (
         SIMPLE_ARRAY<INT32>&
         ) const;

      int GetColWidth (
         int col,
         int* width
         ) const;

      int GetColWidth (
         int col
         ) const;

      int GetColumnWidth (
         int col
         ) const {
         return (GetColWidth(col));
         }

      int GetCountPerPage (
         ) const;

      int GetCurrentCol (
         ) const;

      int GetCurrentRow (
         ) const;

      int GetCurrentTab (
         ) const {
         return 0;
         }

#ifdef X_NATIVE
      Widget GetForm() const {
         return (m_wMainForm);
         }
#endif

      int GetGridDefault (
         MIGRIDCELL* pCell
         ) const;

      int GetHeadingDefault (
         MIGRIDCELL* pCell
         ) const;

      int GetHSHeight (
         ) const;


      const MGUI::IMAGELIST* GetImageList() const {
         return (m_ImageList);
         }

      PTRUINT GetItemData (
         int row,
         int col = 0
         ) const {
         return (reinterpret_cast<PTRUINT>(GetItemDataPtr(row, col)));
         }

      void* GetItemDataPtr (
         int row,
         int col = 0
         ) const;

      int GetLeftCol (
         ) const;

      int GetNextSelectedItem (
         int row
         ) const;
         
      int GetNumberCols (
         ) const;

      int GetNumberRows (
         ) const;

      int GetItemCount (
         ) const {
         return (GetNumberRows());
         }

      int GetRightCol (
         ) const;

      int GetRowHeight (
         int row
         ) const;

      int GetSelectedCount() const {
         return (m_SelectedCells.GetNumItems());
         }

      const SIMPLE_ARRAY<LPOINT2D>& GetSelectedItems (
         ) const {
         return (m_SelectedCells);
         }

      int GetSideHeadingWidth (
         ) const;

      void GetSize (
         LPOINT2D& size
         ) const;

      int GetTopHeadingHeight (
         ) const;
   
      int GetTopRow (
         ) const;

      int GetVSWidth (
         ) const;

      int GotoCell (
         int col,
         int row
         );

      int GotoCol (
         int col
         ) {
         return (GotoCell(col, GetCurrentRow()));
         }

      int GotoRow (
         int row
         ) {
         return (GotoCell(GetCurrentCol(), row));
         }  

      int HideCurrentCell (
         ) {
         return (GotoCell(-1,-1));
         }

      int InsertCol (
         int col
         );

      int InsertColumn (
         int col,
         const MIUNICODE* string,
         MIGRIDCELL::ALIGNMENT alignment,
         int width = -1
         );

      int InsertRow (
         int row
         );

      bool IsSelected (
         int col,
         int row
         ) const;

      int LockColumns (
         int cols
         );

      int LockRows (
         int rows
         );

      int MoveColPosition (
         int fromCol,
         int toCol,
         bool insertBefore
         );

      int MoveCurrentCol (
         MOVEMENT movement
         );

      int MoveCurrentRow (
         MOVEMENT movement
         );

      virtual bool v_OnCanColSwap (
         int fromCol,                  
         int toCol                     
         );

      virtual bool v_OnCanMove (
         int oldcol,
         int oldrow,
         int newcol, 
         int newrow
         );

      virtual bool v_OnCanSizeCol (
         int col
         );

      virtual bool v_OnCanSizeRow (
         int row
         );

      virtual bool v_OnCanSizeSideHdg (
         );

      virtual bool v_OnCanSizeTopHdg (
         );

      virtual void v_OnCellChange (
         int oldcol,
         int oldrow,
         int newcol,
         int newrow
         );

      virtual bool v_OnCellTypeNotify (
         MIGRIDCELL::CELLTYPE celltype,
         int col,
         int row, 
         INT32 msg,
         CELLSTATE param   
         );

      virtual void v_OnColChange (
         int oldcol,
         int newcol
         );

      virtual void v_OnColSized (
         int col,
         int* width
         );

      virtual void v_OnColSizing (
         int col,
         int* width
         );

      virtual void v_OnDClicked (
         int col,
         int row,
         LRECT2D* rect,
         LPOINT2D* point,
         bool* pbProcessed,
         UINT32 state      
         );

      virtual bool v_OnDrawItem (
         int row,
         int col,
         MIGRIDCUSTOMDRAW& drawdata
         );

      virtual bool v_OnEditContinue (
         int oldcol,
         int oldrow,
         int* newcol,
         int* newrow
         );
         
      virtual bool v_OnEditFinish (
         int col,
         int row,
         MDLGPARENT TextControl,
         const MIUNICODE* string
         );

      virtual bool v_OnEditFinish (
         int col,
         int row,
         const MIGRIDCELL& cell
         );

      virtual bool v_OnEditStart (
         int col,
         int row
         );

      virtual bool v_OnEditVerify (
         int col,
         int row,
         MDLGPARENT TextControl,
         const MIUNICODE* str
         );

      virtual void v_OnGetCell (
         int col,
         int row,
         MIGRIDCELL* cell,
         MIGRIDCELL::PROPERTY mask = MIGRIDCELL::PROP_All
         );


      virtual bool v_OnHint (
         int col,
         int row,
         SECTION section,
         MGUI::CTRL_TOOLTIP& tooltip
         );

      virtual bool v_OnHScrollHint (
         int col,
         MISTRING&
         );
         
      virtual int v_OnItemCompare (
         UINT32 item1,
         UINT32 item2,
         const SORTDATA* sortdata
         );
      
      virtual bool v_OnItemSelect (
         int row,
         int col
         );

      virtual bool v_OnItemUnselect (
         int row,
         int col
         );

      virtual void v_OnKillFocus (
         SECTION section
         );
      
      virtual void v_OnLClicked (
         int col,
         int row,
         bool bIsMouseDown,
         LRECT2D* rect,
         LPOINT2D* point,
         bool* pbProcessed,
         UINT32 state      
         );

      virtual void v_OnLeftColChange (
         int oldcol,
         int newcol
         );

      virtual void v_OnMenuCommand (
         int col,
         int row,
         SECTION section,
         int item
         );

      virtual bool v_OnMenuStart (
         int col,
         int row,
         SECTION section,
         MGUI::MENU& menu
         );
      
      virtual void v_OnRClicked (
         int col,
         int row,
         bool bIsMouseDown,
         LRECT2D* rect,
         LPOINT2D* point,
         bool* pbProcessed,
         UINT32 state      
         );

      virtual void v_OnRowChange (
         int oldrow,
         int newrow
         );
      
      virtual void v_OnRowSized (
         int row,
         int* height
         );

      virtual void v_OnRowSizing (
         int row,
         int* height
         );

      virtual void v_OnSetCell (
         int col,
         int row,
         MIGRIDCELL* pCell
         );

      virtual void v_OnSetFocus (
         SECTION section
         );

      virtual void v_OnSetup (
         );

      virtual void v_OnSideHeadingDClicked (
         int col,
         int row,
         LRECT2D* pRect,
         LPOINT2D* pPoint,
         bool* pbProcessed
         );

      virtual void v_OnSideHeadingLClicked (
         int col,
         int row,
         bool bIsMouseDown,
         LRECT2D* pRect,
         LPOINT2D* pPoint,
         bool* pbProcessed
         );

      virtual void v_OnSideHeadingRClicked (
         int col,
         int row,
         bool bIsMouseDown,
         LRECT2D* pRect,
         LPOINT2D* pPoint,
         bool* pbProcessed
         );

      virtual void v_OnSize (
         int ntype,                    
         int width,
         int height
         );
   

      virtual void v_OnTopHeadingDClicked (
         int col,
         int row,
         LRECT2D* pRect,
         LPOINT2D* pPoint,
         bool* pbProcessed
         );

      virtual void v_OnTopHeadingLClicked (
         int col,
         int row,
         bool bIsMouseDown,
         LRECT2D* pRect,
         LPOINT2D* pPoint,
         bool* pbProcessed
         );

      virtual void v_OnTopHeadingRClicked (
         int col,
         int row,
         bool bIsMouseDown,
         LRECT2D* pRect,
         LPOINT2D* pPoint,
         bool* pbProcessed
         );

      virtual bool v_OnVScrollHint (
         int row,
         MISTRING&
         );
         
      int RedrawAll (
         );

      int RedrawCell (
         int col,
         int row
         );

      int RedrawCol (
         int col
         );
         
      int RedrawRow (
         int row
         );

      int Select (
         int col,       
         int row
         );

      int Unselect (
         int col,       
         int row
         );

      int SelectRange (
         int startcol,
         int startrow,
         int endcol,
         int endrow
         );

      int Set3DHeight (
         int height
         );

      int SetBallisticDelay (
         int millsec
         );

      int SetCell (
         int col,
         int row,
         const MIGRIDCELL& pCell
         );

      int SetColDefault (
         int col,
         const MIGRIDCELL& Cell
         );

      int SetColTranslation (
         int VisualColumnNumber,
         int RealColumnNumber
         );

      int SetColWidth (
         int col,
         int width
         );

      int SetDefColWidth (
         int width
         );

      int SetDefRowHeight (
         int height
         );

      int SetGridDefault (
         const MIGRIDCELL& Cell
         );

      int SetHeadingDefault (
         const MIGRIDCELL& Cell
         );

      int SetHighlightRow (
         bool bWholeRow
         );

      int SetHScrollMode (
         SCROLLMODE mode
         );

      int SetHSHeight (
         int height
         );

      void SetImageList (
         MGUI::IMAGELIST* ImageList,
         bool MakeACopy = true   
         );


      void SetItemData (
         int row,
         int col,
         PTRUINT data
         ) {
         SetItemDataPtr(row, col, (void*)data);
         }

      void SetItemData (
         int row,
         PTRUINT data
         ) {
         SetItemDataPtr(row, 0, (void*)data);
         }

      void SetItemDataPtr (
         int row,
         int col,
         void* data
         );

      void SetItemDataPtr (
         int row,
         void* data
         ) {
         SetItemDataPtr(row, 0, data);
         }

      int SetLeftCol (
         int col
         );

      int SetMargin (
         int pixels
         );

      int SetMultiSelectMode (
         bool bEnable
         );

      int SetNumberCols (
         int cols
         );

      int SetNumberRows (
         int rows
         );
      
      int SetRowDefault (
         int col,
         const MIGRIDCELL& Cell
         );

      int SetRowHeight (
         int row,
         int height
         );

      int SetSideHeadingColWidth (
         int col,
         int width
         );
      
      int SetSideHeadingNumCols (
         int cols
         );

      int SetSideHeadingWidth (
         int width
         );

      void SetSize (
         const LPOINT2D& size
         );


      int SetTopHeadingRowHeight (
         int row,
         int height
         );
      
      int SetTopHeadingNumRows (
         int rows
         );

      int SetTopHeadingHeight (
         int height
         );

      int SetTopRow (
         int row
         );

      int SetUniformRowHeight (
         bool bUniform
         );

      int SetUserSizingMode (
         bool bAllowResize
         );

      int SetVScrollMode (
         SCROLLMODE mode
         );

      int SetVSWidth (
         int width
         );

      int SortBy (
         int* pCols,
         int num,
         bool bAscending
         );

      int SortBy (
         int col,
         bool bAscending
         ) {
         return (SortBy(&col, 1, bAscending));
         }

      int StartEdit (
         );

      int StartEdit (
         int key
         );

      int StartEdit (
         int col,
         int row,
         int key
         );

      int StartMenu (
         int col,
         int row,
         LPOINT2D* point,
         SECTION section
         );

      void SwapRows (
         INT32 row1,
         INT32 row2
         );

      int UseHints (
         bool bUseHints = true
         );

      int UseHScrollHints (
         bool bUseHints = true
         );

      int UseVScrollHints (
         bool bUseHints = true
         );

#ifdef X_NATIVE
      Widget GetDA (
         int col,
         int row
         ) const {
         return GetDrawingAreaData(col, row).m_widget;
         }
#endif

      MGD::CONTEXT* GetGC (
         int col,
         int row
         ) const {
         return GetDrawingAreaData(col, row).m_gc;
         }

      MGD::CONTEXT* GetDAGC (
         int col,
         int row
         ) const {
         return GetDrawingAreaData(col, row).m_dagc;
         }

      void SetGCExclusive (
         MGD::CONTEXT* gc
         ) {
         m_GCExclusive = gc;
         }

      void SetHideFocus (
         bool hide
         ) {
         m_bHideFocus = hide;
         };


private:
   #ifndef GENERATING_DOXYGEN_OUTPUT


   enum DRAGACTION {
      DRAG_None = 0,
      DRAG_ColBorder,
      DRAG_RowBorder,
      DRAG_ColHeading,
      DRAG_RowHeading,
      DRAG_MultiSelect
      };

   static int HeapSortSwap (
      INT32 rec1, 
      INT32 rec2, 
      void *vdata
      );

   static int HeapSortCompare (
      INT32 rec1, 
      INT32 rec2, 
      void *vdata
      );

   MIGRIDCTRL (
      const MIGRIDCTRL&
      );

   MIGRIDCTRL& operator=(
      const MIGRIDCTRL&
      );


   class ROWDATA {
   public:
      int m_height;                    
      int m_ystart;                    
      MIGRIDCELL* m_pStyle;            
      MIGRIDCELL** m_pHeading;         
      MIGRIDCELL** m_pCellData;
      };

   class COLDATA {
   public:
      int m_width;
      int m_xstart;
      int m_orderVtoR;                 
      int m_orderRtoV;                 
      MIGRIDCELL** m_pHeading;         
      MIGRIDCELL* m_pStyle;            
      };

   class TOOLTIPDATA : public MGUI::CTRL_TOOLTIP {
      public:
      TOOLTIPDATA();
      ~TOOLTIPDATA();

      MIGRIDCTRL *m_pCtrl;
      bool m_bDataTipShowing;
      bool m_bEnabled;
#ifdef X_NATIVE
      Widget m_widget;
#endif
      private:
         virtual bool v_OnShowRequest(int x, int y);
      };

   struct DADATA {
      DADATA();
      ~DADATA();

      void CBExpose(MIGRIDCTRL*);
      void CBResize(MIGRIDCTRL*);
      void DrawLineToDA(int x1, int y1, int x2, int y2);
      void DrawRectToDA(const LRECT2D&);
      void EraseDirtyArea();

      MGD::DEVICE_X* m_gdisp;
      MGD::CONTEXT* m_gc;
      MGD::DEVICE_X* m_dagdisp;
      MGD::CONTEXT* m_dagc;
      TOOLTIPDATA m_tip;
      int m_height;
      int m_width;
      bool m_bDirty;
      LRECT2D m_DirtyArea;             
#ifdef X_NATIVE
      Widget m_widget;
      Display* m_xdisp;                
      GC m_xgc;
      Pixmap m_pixmap;
#endif
      };

   void OnContextMenuCommand(MGUI::ID, bool);

#ifdef X_NATIVE
   static void CBT_ToolTipPopUp(void *cbdata, XtIntervalId *IntervalID);
   static void CB_ContextMenu(Widget, void*, void*);
   static void CB_Expose(Widget, MIGRIDCTRL*, void*);
   static void CB_Resize(Widget, MIGRIDCTRL*, void*);
   static void CB_HSB(Widget, MIGRIDCTRL*, void*);
   static void CB_VSB(Widget, MIGRIDCTRL*, void*);
   static void EH_MouseDown(Widget, MIGRIDCTRL*, XEvent*, Boolean*);
   static void EH_MouseUp(Widget, MIGRIDCTRL*, XEvent*, Boolean*);
   static void EH_MouseMove(Widget, MIGRIDCTRL*, XEvent*, Boolean*);
   static void EH_KeyPress(Widget, MIGRIDCTRL*, XEvent*, Boolean*);
   static void EH_SBTip(Widget, MIGRIDCTRL*, XEvent*, Boolean*);
   static void EH_DATip(Widget, MIGRIDCTRL*, XEvent*, Boolean*);
   static void EH_Resize(Widget, MIGRIDCTRL*, XEvent*, Boolean*);
#endif

   void BeginUpdate();     
   void EndUpdate();       
   void Blit();            

#ifdef X_NATIVE
   int GetAbsoluteCellFromPoint (
      Widget widget,    
      int x,      
      int y,      
      int* ptcol, 
      int* ptrow  
      ) const;
#endif

   int GetPrevCol (        
      int col              
      ) const;

   int GetNextCol (        
      int col              
      ) const;

   MIGRIDCELLTYPE* GetCellType (
      int col,
      int row
      ); 

#ifdef X_NATIVE
   DADATA* GetDrawingAreaData (
      Widget widget
      );
#endif

   DADATA* GetDrawingAreaData (
      int col,
      int row
      );

   const DADATA& GetDrawingAreaData (
      int col,
      int row
      ) const;



   LPOINT2D m_CurFocus;
   LPOINT2D m_DataSize;                
   LPOINT2D m_UpperLeft;               
   LPOINT2D m_DefaultCellSize;         

   SIMPLE_ARRAY<LPOINT2D> m_SelectedCells;         
   int m_nLeftCol;                     
   int m_nRightCol;                    
   int m_nBottomRow;                   
   int m_nTopRow;                      
   int m_nRows;                        
   int m_nCols;                        
   MGUI::MENU *m_pMenu;       
   SECTION m_ContextMenuSection;
   LPOINT2D m_ContextMenuCell;
   LPOINT2D m_MouseDownPoint;          
   LPOINT2D m_MouseLastPoint;          
   int m_nDrag;                        
   int m_CurrentCursor;

   ROWDATA* m_pRowData;
   COLDATA* m_pColData;

#ifdef X_NATIVE
   Time m_MouseDownTime;
   int m_MultiClickTime;
#endif

   bool m_bRecomputeSizesH;
   bool m_bRecomputeSizesV;
   bool m_bAllowColSwapping;
   bool m_bAllowContextMenu;
   bool m_bAllowCellResize;
   bool m_bHilightRow;
   bool m_bMultiSelect;
   bool m_bUniformRowHeight;
   int m_nInternalUpdate;              
   int m_nDisableUpdates;
   bool m_bNeedUpdate;                 
   bool m_bHideFocus;
   bool m_bInButton1Event;

   int m_nTopHeadings;
   int* m_nTopHeadingHeight;
   int m_nTopHeadingTotalHeight;

   int m_nSideHeadings;
   int* m_nSideHeadingWidth;
   int m_nSideHeadingTotalWidth;
   MIGRIDCELL** m_pSideHeadingStyle;
   MIGRIDCELL** m_pTopHeadingStyle;

   int m_n3Dheight;
   DRAGACTION m_DragAction;

   MIGRIDCELL m_GridDefault;
   MIGRIDCELL m_HeadingDefault;

   MGD::PIXEL m_ShadowPixelLight;
   MGD::PIXEL m_ShadowPixelDark;
   MGD::PIXEL m_FocusRectPixel;
   MGD::PIXEL m_BackgroundPixel;
#ifdef X_NATIVE
   Widget m_wMainForm;                 
   Widget m_wVSB;                      
   Widget m_wHSB;                      
   Widget m_wPopup;                    
#endif

   MIGRIDEDITHANDLE* m_pEditHandle;
   MIGRIDCELLTYPE** m_pCellTypes;      
   int m_nCellTypes;                   

   TOOLTIPDATA m_VSBTip;               
   TOOLTIPDATA m_HSBTip;               

   DADATA m_DAGrid;
   DADATA m_DATop;
   DADATA m_DASide;
   MGD::CONTEXT* m_GCExclusive;                 
   LRECT2D m_GridClipRect;
   bool m_bClipGrid;

   SCROLLMODE m_VScrollMode;
   SCROLLMODE m_HScrollMode;

   MGUI::IMAGELIST* m_ImageList;
   bool m_bWeOwnImageList;
   MEMPOOL m_MemPool;

   friend struct DADATA;
   #endif // GENERATING_DOXYGEN_OUTPUT
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(MIGRIDCTRL::CELLSTATE)
#endif



#endif   // INC_MI32_MIGRID_H

---