Applied rowspan patch #15276 (dghart)

[wxWidgets.git] / include / wx / generic / grid.h

diff --git a/include/wx/generic/grid.h b/include/wx/generic/grid.h
index 43befd01724c4e2c4bef7ef5f8d86bccacec5efc..74888b96fdf061427bdc29826a1a839dcb2d22fe 100644 (file)
--- a/include/wx/generic/grid.h
+++ b/include/wx/generic/grid.h
@@ -16,6 +16,8 @@
 
 #if wxUSE_GRID
 
 
 #if wxUSE_GRID
 

+#include "wx/hashmap.h"
+

 #include "wx/scrolwin.h"
 
 // ----------------------------------------------------------------------------
 #include "wx/scrolwin.h"
 
 // ----------------------------------------------------------------------------


@@ -42,11 +44,11 @@ extern WXDLLIMPEXP_DATA_ADV(const char) wxGridNameStr[];
 #define WXGRID_DEFAULT_SCROLLBAR_WIDTH        16
 
 // type names for grid table values
 #define WXGRID_DEFAULT_SCROLLBAR_WIDTH        16
 
 // type names for grid table values

-#define wxGRID_VALUE_STRING     _T("string")
-#define wxGRID_VALUE_BOOL       _T("bool")
-#define wxGRID_VALUE_NUMBER     _T("long")
-#define wxGRID_VALUE_FLOAT      _T("double")
-#define wxGRID_VALUE_CHOICE     _T("choice")
+#define wxGRID_VALUE_STRING     wxT("string")
+#define wxGRID_VALUE_BOOL       wxT("bool")
+#define wxGRID_VALUE_NUMBER     wxT("long")
+#define wxGRID_VALUE_FLOAT      wxT("double")
+#define wxGRID_VALUE_CHOICE     wxT("choice")

 
 #define wxGRID_VALUE_TEXT wxGRID_VALUE_STRING
 #define wxGRID_VALUE_LONG wxGRID_VALUE_NUMBER
 
 #define wxGRID_VALUE_TEXT wxGRID_VALUE_STRING
 #define wxGRID_VALUE_LONG wxGRID_VALUE_NUMBER


@@ -63,6 +65,20 @@ enum wxGridDirection
     wxGRID_ROW
 };
 
     wxGRID_ROW
 };
 

+// Flags used with wxGrid::Render() to select parts of the grid to draw.
+enum wxGridRenderStyle
+{
+    wxGRID_DRAW_ROWS_HEADER = 0x001,
+    wxGRID_DRAW_COLS_HEADER = 0x002,
+    wxGRID_DRAW_CELL_LINES = 0x004,
+    wxGRID_DRAW_BOX_RECT = 0x008,
+    wxGRID_DRAW_SELECTION = 0x010,
+    wxGRID_DRAW_DEFAULT = wxGRID_DRAW_ROWS_HEADER |
+                          wxGRID_DRAW_COLS_HEADER |
+                          wxGRID_DRAW_CELL_LINES |
+                          wxGRID_DRAW_BOX_RECT
+};
+

 // ----------------------------------------------------------------------------
 // forward declarations
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // forward declarations
 // ----------------------------------------------------------------------------


@@ -85,6 +101,8 @@ class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
 class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
 #endif
 
 class WXDLLIMPEXP_FWD_CORE wxSpinCtrl;
 #endif
 

+class wxGridFixedIndicesSet;
+

 class wxGridOperations;
 class wxGridRowOperations;
 class wxGridColumnOperations;
 class wxGridOperations;
 class wxGridRowOperations;
 class wxGridColumnOperations;


@@ -106,18 +124,12 @@ class wxGridDirectionOperations;
 //     class is not documented and is not public at all
 // ----------------------------------------------------------------------------
 
 //     class is not documented and is not public at all
 // ----------------------------------------------------------------------------
 

-class WXDLLIMPEXP_ADV wxGridCellWorker : public wxClientDataContainer
+class WXDLLIMPEXP_ADV wxGridCellWorker : public wxClientDataContainer, public wxRefCounter

 {
 public:
 {
 public:

-    wxGridCellWorker() { m_nRef = 1; }
-
-    // this class is ref counted: it is created with ref count of 1, so
-    // calling DecRef() once will delete it. Calling IncRef() allows to lock
-    // it until the matching DecRef() is called
-    void IncRef() { m_nRef++; }
-    void DecRef() { if ( --m_nRef == 0 ) delete this; }
+    wxGridCellWorker() { }

 
 

-    // interpret renderer parameters: arbitrary string whose interpretatin is
+    // interpret renderer parameters: arbitrary string whose interpretation is

     // left to the derived classes
     virtual void SetParameters(const wxString& params);
 
     // left to the derived classes
     virtual void SetParameters(const wxString& params);
 


@@ -127,8 +139,6 @@ protected:
     virtual ~wxGridCellWorker();
 
 private:
     virtual ~wxGridCellWorker();
 
 private:

-    size_t m_nRef;
-

     // suppress the stupid gcc warning about the class having private dtor and
     // no friends
     friend class wxGridCellWorkerDummyFriend;
     // suppress the stupid gcc warning about the class having private dtor and
     // no friends
     friend class wxGridCellWorkerDummyFriend;


@@ -182,11 +192,11 @@ class WXDLLIMPEXP_ADV wxGridCellEditor : public wxGridCellWorker
 public:
     wxGridCellEditor();
 
 public:
     wxGridCellEditor();
 

-    bool IsCreated() { return m_control != NULL; }
-    wxControl* GetControl() { return m_control; }
+    bool IsCreated() const { return m_control != NULL; }
+    wxControl* GetControl() const { return m_control; }

     void SetControl(wxControl* control) { m_control = control; }
 
     void SetControl(wxControl* control) { m_control = control; }
 

-    wxGridCellAttr* GetCellAttr() { return m_attr; }
+    wxGridCellAttr* GetCellAttr() const { return m_attr; }

     void SetCellAttr(wxGridCellAttr* attr) { m_attr = attr; }
 
     // Creates the actual edit control
     void SetCellAttr(wxGridCellAttr* attr) { m_attr = attr; }
 
     // Creates the actual edit control


@@ -203,7 +213,9 @@ public:
 
     // Draws the part of the cell not occupied by the control: the base class
     // version just fills it with background colour from the attribute
 
     // Draws the part of the cell not occupied by the control: the base class
     // version just fills it with background colour from the attribute

-    virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
+    virtual void PaintBackground(wxDC& dc,
+                                 const wxRect& rectCell,
+                                 const wxGridCellAttr& attr);

 
 
     // The methods called by wxGrid when a cell is edited: first BeginEdit() is
 
 
     // The methods called by wxGrid when a cell is edited: first BeginEdit() is


@@ -218,8 +230,10 @@ public:
     // new value in its string form in the newval output parameter.
     //
     // This should also store the new value in its real type internally so that
     // new value in its string form in the newval output parameter.
     //
     // This should also store the new value in its real type internally so that

-    // it could be used by ApplyEdit().
-    virtual bool EndEdit(const wxString& oldval, wxString *newval) = 0;
+    // it could be used by ApplyEdit() but it must not modify the grid as the
+    // change could still be vetoed.
+    virtual bool EndEdit(int row, int col, const wxGrid *grid,
+                         const wxString& oldval, wxString *newval) = 0;

 
     // Complete the editing of the current cell by storing the value saved by
     // the previous call to EndEdit() in the grid
 
     // Complete the editing of the current cell by storing the value saved by
     // the previous call to EndEdit() in the grid


@@ -281,7 +295,88 @@ protected:
     // no friends
     friend class wxGridCellEditorDummyFriend;
 
     // no friends
     friend class wxGridCellEditorDummyFriend;
 

-    DECLARE_NO_COPY_CLASS(wxGridCellEditor)
+    wxDECLARE_NO_COPY_CLASS(wxGridCellEditor);
+};
+
+// ----------------------------------------------------------------------------
+// wxGridHeaderRenderer and company: like wxGridCellRenderer but for headers
+// ----------------------------------------------------------------------------
+
+// Base class for corner window renderer: it is the simplest of all renderers
+// and only has a single function
+class WXDLLIMPEXP_ADV wxGridCornerHeaderRenderer
+{
+public:
+    // Draw the border around the corner window.
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const = 0;
+
+    // make the dtor of a class with virtual functions virtual to avoid g++
+    // warnings, even though this class is not supposed to be used
+    // polymorphically
+    virtual ~wxGridCornerHeaderRenderer() { }
+};
+
+
+// Base class for the row/column header cells renderers
+class WXDLLIMPEXP_ADV wxGridHeaderLabelsRenderer
+    : public wxGridCornerHeaderRenderer
+{
+public:
+    // Draw header cell label
+    virtual void DrawLabel(const wxGrid& grid,
+                           wxDC& dc,
+                           const wxString& value,
+                           const wxRect& rect,
+                           int horizAlign,
+                           int vertAlign,
+                           int textOrientation) const;
+};
+
+// Currently the row/column/corner renders don't need any methods other than
+// those already in wxGridHeaderLabelsRenderer but still define separate classes
+// for them for future extensions and also for better type safety (i.e. to
+// avoid inadvertently using a column header renderer for the row headers)
+class WXDLLIMPEXP_ADV wxGridRowHeaderRenderer
+    : public wxGridHeaderLabelsRenderer
+{
+};
+
+class WXDLLIMPEXP_ADV wxGridColumnHeaderRenderer
+    : public wxGridHeaderLabelsRenderer
+{
+};
+
+// Also define the default renderers which are used by wxGridCellAttrProvider
+// by default
+class WXDLLIMPEXP_ADV wxGridRowHeaderRendererDefault
+    : public wxGridRowHeaderRenderer
+{
+public:
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const;
+};
+
+// Column header cells renderers
+class WXDLLIMPEXP_ADV wxGridColumnHeaderRendererDefault
+    : public wxGridColumnHeaderRenderer
+{
+public:
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const;
+};
+
+// Header corner renderer
+class WXDLLIMPEXP_ADV wxGridCornerHeaderRendererDefault
+    : public wxGridCornerHeaderRenderer
+{
+public:
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const;

 };
 
 
 };
 
 


@@ -291,7 +386,7 @@ protected:
 // class may be returned by wxGridTable::GetAttr().
 // ----------------------------------------------------------------------------
 
 // class may be returned by wxGridTable::GetAttr().
 // ----------------------------------------------------------------------------
 

-class WXDLLIMPEXP_ADV wxGridCellAttr : public wxClientDataContainer
+class WXDLLIMPEXP_ADV wxGridCellAttr : public wxClientDataContainer, public wxRefCounter

 {
 public:
     enum wxAttrKind
 {
 public:
     enum wxAttrKind


@@ -309,8 +404,7 @@ public:
     {
         Init(attrDefault);
 
     {
         Init(attrDefault);
 

-        // MB: args used to be 0,0 here but wxALIGN_LEFT is 0
-        SetAlignment(-1, -1);
+        SetAlignment(wxALIGN_INVALID, wxALIGN_INVALID);

     }
 
     // VZ: considering the number of members wxGridCellAttr has now, this ctor
     }
 
     // VZ: considering the number of members wxGridCellAttr has now, this ctor


@@ -330,12 +424,6 @@ public:
     wxGridCellAttr *Clone() const;
     void MergeWith(wxGridCellAttr *mergefrom);
 
     wxGridCellAttr *Clone() const;
     void MergeWith(wxGridCellAttr *mergefrom);
 

-    // this class is ref counted: it is created with ref count of 1, so
-    // calling DecRef() once will delete it. Calling IncRef() allows to lock
-    // it until the matching DecRef() is called
-    void IncRef() { m_nRef++; }
-    void DecRef() { if ( --m_nRef == 0 ) delete this; }
-

     // setters
     void SetTextColour(const wxColour& colText) { m_colText = colText; }
     void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; }
     // setters
     void SetTextColour(const wxColour& colText) { m_colText = colText; }
     void SetBackgroundColour(const wxColour& colBack) { m_colBack = colBack; }


@@ -360,10 +448,13 @@ public:
     void SetKind(wxAttrKind kind) { m_attrkind = kind; }
 
     // accessors
     void SetKind(wxAttrKind kind) { m_attrkind = kind; }
 
     // accessors

-    bool HasTextColour() const { return m_colText.Ok(); }
-    bool HasBackgroundColour() const { return m_colBack.Ok(); }
-    bool HasFont() const { return m_font.Ok(); }
-    bool HasAlignment() const { return (m_hAlign != -1 || m_vAlign != -1); }
+    bool HasTextColour() const { return m_colText.IsOk(); }
+    bool HasBackgroundColour() const { return m_colBack.IsOk(); }
+    bool HasFont() const { return m_font.IsOk(); }
+    bool HasAlignment() const
+    {
+        return m_hAlign != wxALIGN_INVALID || m_vAlign != wxALIGN_INVALID;
+    }

     bool HasRenderer() const { return m_renderer != NULL; }
     bool HasEditor() const { return m_editor != NULL; }
     bool HasReadWriteMode() const { return m_isReadOnly != Unset; }
     bool HasRenderer() const { return m_renderer != NULL; }
     bool HasEditor() const { return m_editor != NULL; }
     bool HasReadWriteMode() const { return m_isReadOnly != Unset; }


@@ -374,6 +465,15 @@ public:
     const wxColour& GetBackgroundColour() const;
     const wxFont& GetFont() const;
     void GetAlignment(int *hAlign, int *vAlign) const;
     const wxColour& GetBackgroundColour() const;
     const wxFont& GetFont() const;
     void GetAlignment(int *hAlign, int *vAlign) const;

+
+    // unlike GetAlignment() which always overwrites its output arguments with
+    // the alignment values to use, falling back on default alignment if this
+    // attribute doesn't have any, this function will preserve the values of
+    // parameters on entry if the corresponding alignment is not set in this
+    // attribute meaning that they can be initialized to default alignment (and
+    // also that they must be initialized, unlike with GetAlignment())
+    void GetNonDefaultAlignment(int *hAlign, int *vAlign) const;
+

     void GetSize(int *num_rows, int *num_cols) const;
     bool GetOverflow() const
         { return m_overflow != SingleCell; }
     void GetSize(int *num_rows, int *num_cols) const;
     bool GetOverflow() const
         { return m_overflow != SingleCell; }


@@ -413,9 +513,6 @@ private:
     void Init(wxGridCellAttr *attrDefault = NULL);
 
 
     void Init(wxGridCellAttr *attrDefault = NULL);
 
 

-    // the ref count - when it goes to 0, we die
-    size_t   m_nRef;
-

     wxColour m_colText,
              m_colBack;
     wxFont   m_font;
     wxColour m_colText,
              m_colBack;
     wxFont   m_font;


@@ -435,7 +532,7 @@ private:
     wxAttrKind m_attrkind;
 
     // use Clone() instead
     wxAttrKind m_attrkind;
 
     // use Clone() instead

-    DECLARE_NO_COPY_CLASS(wxGridCellAttr)
+    wxDECLARE_NO_COPY_CLASS(wxGridCellAttr);

 
     // suppress the stupid gcc warning about the class having private dtor and
     // no friends
 
     // suppress the stupid gcc warning about the class having private dtor and
     // no friends


@@ -475,12 +572,20 @@ public:
     void UpdateAttrRows( size_t pos, int numRows );
     void UpdateAttrCols( size_t pos, int numCols );
 
     void UpdateAttrRows( size_t pos, int numRows );
     void UpdateAttrCols( size_t pos, int numCols );
 

+
+    // get renderers for the given row/column header label and the corner
+    // window: unlike cell renderers, these objects are not reference counted
+    // and are never NULL so they are returned by reference
+    virtual const wxGridColumnHeaderRenderer& GetColumnHeaderRenderer(int col);
+    virtual const wxGridRowHeaderRenderer& GetRowHeaderRenderer(int row);
+    virtual const wxGridCornerHeaderRenderer& GetCornerRenderer();
+

 private:
     void InitData();
 
     wxGridCellAttrProviderData *m_data;
 
 private:
     void InitData();
 
     wxGridCellAttrProviderData *m_data;
 

-    DECLARE_NO_COPY_CLASS(wxGridCellAttrProvider)
+    wxDECLARE_NO_COPY_CLASS(wxGridCellAttrProvider);

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -649,7 +754,7 @@ private:
     wxGridCellAttrProvider *m_attrProvider;
 
     DECLARE_ABSTRACT_CLASS(wxGridTableBase)
     wxGridCellAttrProvider *m_attrProvider;
 
     DECLARE_ABSTRACT_CLASS(wxGridTableBase)

-    DECLARE_NO_COPY_CLASS(wxGridTableBase)
+    wxDECLARE_NO_COPY_CLASS(wxGridTableBase);

 };
 
 
 };
 
 


@@ -694,7 +799,7 @@ private:
     int m_comInt1;
     int m_comInt2;
 
     int m_comInt1;
     int m_comInt2;
 

-    DECLARE_NO_COPY_CLASS(wxGridTableMessage)
+    wxDECLARE_NO_COPY_CLASS(wxGridTableMessage);

 };
 
 
 };
 
 


@@ -719,14 +824,13 @@ class WXDLLIMPEXP_ADV wxGridStringTable : public wxGridTableBase
 public:
     wxGridStringTable();
     wxGridStringTable( int numRows, int numCols );
 public:
     wxGridStringTable();
     wxGridStringTable( int numRows, int numCols );

-    virtual ~wxGridStringTable();

 
     // these are pure virtual in wxGridTableBase
     //
 
     // these are pure virtual in wxGridTableBase
     //

-    int GetNumberRows();
-    int GetNumberCols();
-    wxString GetValue( int row, int col );
-    void SetValue( int row, int col, const wxString& s );
+    virtual int GetNumberRows() { return static_cast<int>(m_data.size()); }
+    virtual int GetNumberCols() { return m_numCols; }
+    virtual wxString GetValue( int row, int col );
+    virtual void SetValue( int row, int col, const wxString& s );

 
     // overridden functions from wxGridTableBase
     //
 
     // overridden functions from wxGridTableBase
     //


@@ -746,6 +850,12 @@ public:
 private:
     wxGridStringArray m_data;
 
 private:
     wxGridStringArray m_data;
 

+    // notice that while we don't need to store the number of our rows as it's
+    // always equal to the size of m_data array, we do need to store the number
+    // of our columns as we can't retrieve it from m_data when the number of
+    // rows is 0 (see #10818)
+    int m_numCols;
+

     // These only get used if you set your own labels, otherwise the
     // GetRow/ColLabelValue functions return wxGridTableBase defaults
     //
     // These only get used if you set your own labels, otherwise the
     // GetRow/ColLabelValue functions return wxGridTableBase defaults
     //


@@ -761,6 +871,39 @@ private:
 //  Grid view classes
 // ============================================================================
 
 //  Grid view classes
 // ============================================================================
 

+// ----------------------------------------------------------------------------
+// wxGridSizesInfo stores information about sizes of the rows or columns.
+//
+// It assumes that most of the columns or rows have default size and so stores
+// the default size separately and uses a hash to map column or row numbers to
+// their non default size for those which don't have the default size.
+// ----------------------------------------------------------------------------
+
+// hash map to store positions as the keys and sizes as the values
+WX_DECLARE_HASH_MAP_WITH_DECL( unsigned, int, wxIntegerHash, wxIntegerEqual,
+                               wxUnsignedToIntHashMap, class WXDLLIMPEXP_ADV );
+
+struct WXDLLIMPEXP_ADV wxGridSizesInfo
+{
+    // default ctor, initialize m_sizeDefault and m_customSizes later
+    wxGridSizesInfo() { }
+
+    // ctor used by wxGrid::Get{Col,Row}Sizes()
+    wxGridSizesInfo(int defSize, const wxArrayInt& allSizes);
+
+    // default copy ctor, assignment operator and dtor are ok
+
+    // Get the size of the element with the given index
+    int GetSize(unsigned pos) const;
+
+
+    // default size
+    int m_sizeDefault;
+
+    // position -> size map containing all elements with non-default size
+    wxUnsignedToIntHashMap m_customSizes;
+};
+

 // ----------------------------------------------------------------------------
 // wxGrid
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGrid
 // ----------------------------------------------------------------------------


@@ -777,6 +920,15 @@ public:
         wxGridSelectRowsOrColumns = wxGridSelectRows | wxGridSelectColumns
     };
 
         wxGridSelectRowsOrColumns = wxGridSelectRows | wxGridSelectColumns
     };
 

+    // Different behaviour of the TAB key when the end (or the beginning, for
+    // Shift-TAB) of the current row is reached:
+    enum TabBehaviour
+    {
+        Tab_Stop,   // Do nothing, this is default.
+        Tab_Wrap,   // Move to the next (or previous) row.
+        Tab_Leave   // Move to the next (or previous) control.
+    };
+

     // creation and destruction
     // ------------------------
 
     // creation and destruction
     // ------------------------
 


@@ -896,13 +1048,21 @@ public:
     void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&,
                             int horizontalAlignment = wxALIGN_LEFT,
                             int verticalAlignment = wxALIGN_TOP,
     void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&,
                             int horizontalAlignment = wxALIGN_LEFT,
                             int verticalAlignment = wxALIGN_TOP,

-                            int textOrientation = wxHORIZONTAL );
+                            int textOrientation = wxHORIZONTAL ) const;

 
     void DrawTextRectangle( wxDC& dc, const wxArrayString& lines, const wxRect&,
                             int horizontalAlignment = wxALIGN_LEFT,
                             int verticalAlignment = wxALIGN_TOP,
 
     void DrawTextRectangle( wxDC& dc, const wxArrayString& lines, const wxRect&,
                             int horizontalAlignment = wxALIGN_LEFT,
                             int verticalAlignment = wxALIGN_TOP,

-                            int textOrientation = wxHORIZONTAL );
+                            int textOrientation = wxHORIZONTAL ) const;

 
 

+    // ------ grid render function for printing
+    //
+    void Render( wxDC& dc,
+                 const wxPoint& pos = wxDefaultPosition,
+                 const wxSize& size = wxDefaultSize,
+                 const wxGridCellCoords& topLeft = wxGridCellCoords(-1, -1),
+                 const wxGridCellCoords& bottomRight = wxGridCellCoords(-1, -1),
+                 int style = wxGRID_DRAW_DEFAULT );

 
     // Split a string containing newline characters into an array of
     // strings and return the number of lines
 
     // Split a string containing newline characters into an array of
     // strings and return the number of lines


@@ -1023,6 +1183,8 @@ public:
     bool MoveCursorLeftBlock( bool expandSelection );
     bool MoveCursorRightBlock( bool expandSelection );
 
     bool MoveCursorLeftBlock( bool expandSelection );
     bool MoveCursorRightBlock( bool expandSelection );
 

+    void SetTabBehaviour(TabBehaviour behaviour) { m_tabBehaviour = behaviour; }
+

 
     // ------ label and gridline formatting
     //
 
     // ------ label and gridline formatting
     //


@@ -1066,19 +1228,42 @@ public:
     void     SetCellHighlightPenWidth(int width);
     void     SetCellHighlightROPenWidth(int width);
 
     void     SetCellHighlightPenWidth(int width);
     void     SetCellHighlightROPenWidth(int width);
 

+
+    // interactive grid mouse operations control
+    // -----------------------------------------
+
+    // functions globally enabling row/column interactive resizing (enabled by
+    // default)

     void     EnableDragRowSize( bool enable = true );
     void     DisableDragRowSize() { EnableDragRowSize( false ); }
     void     EnableDragRowSize( bool enable = true );
     void     DisableDragRowSize() { EnableDragRowSize( false ); }

-    bool     CanDragRowSize() const { return m_canDragRowSize; }
+

     void     EnableDragColSize( bool enable = true );
     void     DisableDragColSize() { EnableDragColSize( false ); }
     void     EnableDragColSize( bool enable = true );
     void     DisableDragColSize() { EnableDragColSize( false ); }

-    bool     CanDragColSize() const { return m_canDragColSize; }
+
+        // if interactive resizing is enabled, some rows/columns can still have
+        // fixed size
+    void DisableRowResize(int row) { DoDisableLineResize(row, m_setFixedRows); }
+    void DisableColResize(int col) { DoDisableLineResize(col, m_setFixedCols); }
+
+        // these functions return whether the given row/column can be
+        // effectively resized: for this interactive resizing must be enabled
+        // and this index must not have been passed to DisableRow/ColResize()
+    bool CanDragRowSize(int row) const
+        { return m_canDragRowSize && DoCanResizeLine(row, m_setFixedRows); }
+    bool CanDragColSize(int col) const
+        { return m_canDragColSize && DoCanResizeLine(col, m_setFixedCols); }
+
+    // interactive column reordering (disabled by default)

     void     EnableDragColMove( bool enable = true );
     void     DisableDragColMove() { EnableDragColMove( false ); }
     bool     CanDragColMove() const { return m_canDragColMove; }
     void     EnableDragColMove( bool enable = true );
     void     DisableDragColMove() { EnableDragColMove( false ); }
     bool     CanDragColMove() const { return m_canDragColMove; }

+
+    // interactive resizing of grid cells (enabled by default)

     void     EnableDragGridSize(bool enable = true);
     void     DisableDragGridSize() { EnableDragGridSize(false); }
     bool     CanDragGridSize() const { return m_canDragGridSize; }
 
     void     EnableDragGridSize(bool enable = true);
     void     DisableDragGridSize() { EnableDragGridSize(false); }
     bool     CanDragGridSize() const { return m_canDragGridSize; }
 

+    // interactive dragging of cells (disabled by default)

     void     EnableDragCell( bool enable = true );
     void     DisableDragCell() { EnableDragCell( false ); }
     bool     CanDragCell() const { return m_canDragCell; }
     void     EnableDragCell( bool enable = true );
     void     DisableDragCell() { EnableDragCell( false ); }
     bool     CanDragCell() const { return m_canDragCell; }


@@ -1118,6 +1303,12 @@ public:
     void     SetRowAttr(int row, wxGridCellAttr *attr);
     void     SetColAttr(int col, wxGridCellAttr *attr);
 
     void     SetRowAttr(int row, wxGridCellAttr *attr);
     void     SetColAttr(int col, wxGridCellAttr *attr);
 

+    // the grid can cache attributes for the recently used cells (currently it
+    // only caches one attribute for the most recently used one) and might
+    // notice that its value in the attribute provider has changed -- if this
+    // happens, call this function to force it
+    void RefreshAttr(int row, int col);
+

     // returns the attribute we may modify in place: a new one if this cell
     // doesn't have any yet or the existing one if it does
     //
     // returns the attribute we may modify in place: a new one if this cell
     // doesn't have any yet or the existing one if it does
     //


@@ -1151,7 +1342,24 @@ public:
     void     GetCellAlignment( int row, int col, int *horiz, int *vert ) const;
     bool     GetDefaultCellOverflow() const;
     bool     GetCellOverflow( int row, int col ) const;
     void     GetCellAlignment( int row, int col, int *horiz, int *vert ) const;
     bool     GetDefaultCellOverflow() const;
     bool     GetCellOverflow( int row, int col ) const;

-    void     GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;
+
+    // this function returns 1 in num_rows and num_cols for normal cells,
+    // positive numbers for a cell spanning multiple columns/rows (as set with
+    // SetCellSize()) and _negative_ numbers corresponding to the offset of the
+    // top left cell of the span from this one for the other cells covered by
+    // this cell
+    //
+    // the return value is CellSpan_None, CellSpan_Main or CellSpan_Inside for
+    // each of these cases respectively
+    enum CellSpan
+    {
+        CellSpan_Inside = -1,
+        CellSpan_None = 0,
+        CellSpan_Main
+    };
+
+    CellSpan GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;
+

     wxSize GetCellSize(const wxGridCellCoords& coords)
     {
         wxSize s;
     wxSize GetCellSize(const wxGridCellCoords& coords)
     {
         wxSize s;


@@ -1162,13 +1370,24 @@ public:
     // ------ row and col sizes
     void     SetDefaultRowSize( int height, bool resizeExistingRows = false );
     void     SetRowSize( int row, int height );
     // ------ row and col sizes
     void     SetDefaultRowSize( int height, bool resizeExistingRows = false );
     void     SetRowSize( int row, int height );

-    void     HideRow(int row) { SetRowSize(row, 0); }
-    void     ShowRow(int row) { SetRowSize(row, -1); }
+    void     HideRow(int row) { DoSetRowSize(row, 0); }
+    void     ShowRow(int row) { DoSetRowSize(row, -1); }

 
     void     SetDefaultColSize( int width, bool resizeExistingCols = false );
     void     SetColSize( int col, int width );
 
     void     SetDefaultColSize( int width, bool resizeExistingCols = false );
     void     SetColSize( int col, int width );

-    void     HideCol(int col) { SetColSize(col, 0); }
-    void     ShowCol(int col) { SetColSize(col, -1); }
+    void     HideCol(int col) { DoSetColSize(col, 0); }
+    void     ShowCol(int col) { DoSetColSize(col, -1); }
+
+    // the row and column sizes can be also set all at once using
+    // wxGridSizesInfo which holds all of them at once
+
+    wxGridSizesInfo GetColSizes() const
+        { return wxGridSizesInfo(GetDefaultColSize(), m_colWidths); }
+    wxGridSizesInfo GetRowSizes() const
+        { return wxGridSizesInfo(GetDefaultRowSize(), m_rowHeights); }
+
+    void SetColSizes(const wxGridSizesInfo& sizeInfo);
+    void SetRowSizes(const wxGridSizesInfo& sizeInfo);

 
 
     // ------- columns (only, for now) reordering
 
 
     // ------- columns (only, for now) reordering


@@ -1417,10 +1636,10 @@ public:
     }
 
     // Allow adjustment of scroll increment. The default is (15, 15).
     }
 
     // Allow adjustment of scroll increment. The default is (15, 15).

-    void SetScrollLineX(int x) { m_scrollLineX = x; }
-    void SetScrollLineY(int y) { m_scrollLineY = y; }
-    int GetScrollLineX() const { return m_scrollLineX; }
-    int GetScrollLineY() const { return m_scrollLineY; }
+    void SetScrollLineX(int x) { m_xScrollPixelsPerLine = x; }
+    void SetScrollLineY(int y) { m_yScrollPixelsPerLine = y; }
+    int GetScrollLineX() const { return m_xScrollPixelsPerLine; }
+    int GetScrollLineY() const { return m_yScrollPixelsPerLine; }

 
     // ------- drag and drop
 #if wxUSE_DRAG_AND_DROP
 
     // ------- drag and drop
 #if wxUSE_DRAG_AND_DROP


@@ -1453,7 +1672,7 @@ public:
     // unset any existing sorting column
     void UnsetSortingColumn() { SetSortingColumn(wxNOT_FOUND); }
 
     // unset any existing sorting column
     void UnsetSortingColumn() { SetSortingColumn(wxNOT_FOUND); }
 

-#ifdef WXWIN_COMPATIBILITY_2_8
+#if WXWIN_COMPATIBILITY_2_8

     // ------ For compatibility with previous wxGrid only...
     //
     //  ************************************************
     // ------ For compatibility with previous wxGrid only...
     //
     //  ************************************************


@@ -1525,9 +1744,9 @@ public:
     void SetLabelAlignment( int orientation, int align )
         {
             if ( orientation == wxHORIZONTAL )
     void SetLabelAlignment( int orientation, int align )
         {
             if ( orientation == wxHORIZONTAL )

-                SetColLabelAlignment( align, -1 );
+                SetColLabelAlignment( align, wxALIGN_INVALID );

             else
             else

-                SetRowLabelAlignment( align, -1 );
+                SetRowLabelAlignment( align, wxALIGN_INVALID );

         }
 
     int GetLabelAlignment( int orientation, int WXUNUSED(align) ) const
         }
 
     int GetLabelAlignment( int orientation, int WXUNUSED(align) ) const


@@ -1613,6 +1832,9 @@ public:
            wxGRID_CHECKBOX,
            wxGRID_CHOICE,
            wxGRID_COMBOBOX };
            wxGRID_CHECKBOX,
            wxGRID_CHOICE,
            wxGRID_COMBOBOX };

+
+    wxDEPRECATED_INLINE(bool CanDragRowSize() const, return m_canDragRowSize; )
+    wxDEPRECATED_INLINE(bool CanDragColSize() const, return m_canDragColSize; )

 #endif // WXWIN_COMPATIBILITY_2_8
 
 
 #endif // WXWIN_COMPATIBILITY_2_8
 
 


@@ -1865,8 +2087,7 @@ protected:
     bool       m_editable;              // applies to whole grid
     bool       m_cellEditCtrlEnabled;   // is in-place edit currently shown?
 
     bool       m_editable;              // applies to whole grid
     bool       m_cellEditCtrlEnabled;   // is in-place edit currently shown?
 

-    int m_scrollLineX; // X scroll increment
-    int m_scrollLineY; // Y scroll increment
+    TabBehaviour m_tabBehaviour;        // determines how the TAB key behaves

 
     void Init();        // common part of all ctors
     void Create();
 
     void Init();        // common part of all ctors
     void Create();


@@ -1880,10 +2101,10 @@ protected:
     // it was processed (but not vetoed) and 0 if it wasn't processed
     int SendEvent(const wxEventType evtType,
                   int row, int col,
     // it was processed (but not vetoed) and 0 if it wasn't processed
     int SendEvent(const wxEventType evtType,
                   int row, int col,

-                  wxMouseEvent& e);
+                  const wxMouseEvent& e);

     int SendEvent(const wxEventType evtType,
                   const wxGridCellCoords& coords,
     int SendEvent(const wxEventType evtType,
                   const wxGridCellCoords& coords,

-                  wxMouseEvent& e)
+                  const wxMouseEvent& e)

         { return SendEvent(evtType, coords.GetRow(), coords.GetCol(), e); }
     int SendEvent(const wxEventType evtType,
                   int row, int col,
         { return SendEvent(evtType, coords.GetRow(), coords.GetCol(), e); }
     int SendEvent(const wxEventType evtType,
                   int row, int col,


@@ -1895,12 +2116,19 @@ protected:
     int SendEvent(const wxEventType evtType, const wxString& s = wxString())
         { return SendEvent(evtType, m_currentCellCoords, s); }
 
     int SendEvent(const wxEventType evtType, const wxString& s = wxString())
         { return SendEvent(evtType, m_currentCellCoords, s); }
 

+    // send wxEVT_GRID_{ROW,COL}_SIZE or wxEVT_GRID_COL_AUTO_SIZE, return true
+    // if the event was processed, false otherwise
+    bool SendGridSizeEvent(wxEventType type,
+                           int row, int col,
+                           const wxMouseEvent& mouseEv);
+

     void OnPaint( wxPaintEvent& );
     void OnSize( wxSizeEvent& );
     void OnKeyDown( wxKeyEvent& );
     void OnKeyUp( wxKeyEvent& );
     void OnChar( wxKeyEvent& );
     void OnEraseBackground( wxEraseEvent& );
     void OnPaint( wxPaintEvent& );
     void OnSize( wxSizeEvent& );
     void OnKeyDown( wxKeyEvent& );
     void OnKeyUp( wxKeyEvent& );
     void OnChar( wxKeyEvent& );
     void OnEraseBackground( wxEraseEvent& );

+    void OnHideEditor( wxCommandEvent& );

 
 
     bool SetCurrentCell( const wxGridCellCoords& coords );
 
 
     bool SetCurrentCell( const wxGridCellCoords& coords );


@@ -1932,16 +2160,34 @@ protected:
     friend class wxGridColLabelWindow;
     friend class wxGridRowLabelWindow;
     friend class wxGridWindow;
     friend class wxGridColLabelWindow;
     friend class wxGridRowLabelWindow;
     friend class wxGridWindow;

+    friend class wxGridHeaderRenderer;

 
     friend class wxGridHeaderCtrl;
 
 private:
 
     friend class wxGridHeaderCtrl;
 
 private:

+

     // implement wxScrolledWindow method to return m_gridWin size
     virtual wxSize GetSizeAvailableForScrollTarget(const wxSize& size);
 
     // redraw the grid lines, should be called after changing their attributes
     void RedrawGridLines();
 
     // implement wxScrolledWindow method to return m_gridWin size
     virtual wxSize GetSizeAvailableForScrollTarget(const wxSize& size);
 
     // redraw the grid lines, should be called after changing their attributes
     void RedrawGridLines();
 

+    // draw all grid lines in the given cell region (unlike the public
+    // DrawAllGridLines() which just draws all of them)
+    void DrawRangeGridLines(wxDC& dc, const wxRegion& reg,
+                            const wxGridCellCoords& topLeft,
+                            const wxGridCellCoords& bottomRight);
+
+    // draw all lines from top to bottom row and left to right column in the
+    // rectangle determined by (top, left)-(bottom, right) -- but notice that
+    // the caller must have set up the clipping correctly, this rectangle is
+    // only used here for optimization
+    void DoDrawGridLines(wxDC& dc,
+                         int top, int left,
+                         int bottom, int right,
+                         int topRow, int leftCol,
+                         int bottomRight, int rightCol);
+

     // common part of Clip{Horz,Vert}GridLines
     void DoClipGridLines(bool& var, bool clip);
 
     // common part of Clip{Horz,Vert}GridLines
     void DoClipGridLines(bool& var, bool clip);
 


@@ -1969,7 +2215,7 @@ private:
     // --------------------------------
 
     // process mouse drag event in WXGRID_CURSOR_SELECT_CELL mode
     // --------------------------------
 
     // process mouse drag event in WXGRID_CURSOR_SELECT_CELL mode

-    void DoGridCellDrag(wxMouseEvent& event,
+    bool DoGridCellDrag(wxMouseEvent& event,

                         const wxGridCellCoords& coords,
                         bool isFirstDrag);
 
                         const wxGridCellCoords& coords,
                         bool isFirstDrag);
 


@@ -2008,14 +2254,16 @@ private:
     void DoUpdateResizeColWidth(int w);
     void DoStartMoveCol(int col);
 
     void DoUpdateResizeColWidth(int w);
     void DoStartMoveCol(int col);
 

-    void DoEndDragResizeRow();
-    void DoEndDragResizeCol(wxMouseEvent *event = NULL);
+    void DoEndDragResizeRow(const wxMouseEvent& event);
+    void DoEndDragResizeCol(const wxMouseEvent& event);

     void DoEndMoveCol(int pos);
 
     void DoEndMoveCol(int pos);
 

+    // process a TAB keypress
+    void DoGridProcessTab(wxKeyboardState& kbdState);

 
     // common implementations of methods defined for both rows and columns
     void DeselectLine(int line, const wxGridOperations& oper);
 
     // common implementations of methods defined for both rows and columns
     void DeselectLine(int line, const wxGridOperations& oper);

-    void DoEndDragResizeLine(const wxGridOperations& oper);
+    bool DoEndDragResizeLine(const wxGridOperations& oper);

     int PosToLinePos(int pos, bool clipToMinMax,
                      const wxGridOperations& oper) const;
     int PosToLine(int pos, bool clipToMinMax,
     int PosToLinePos(int pos, bool clipToMinMax,
                      const wxGridOperations& oper) const;
     int PosToLine(int pos, bool clipToMinMax,


@@ -2037,9 +2285,54 @@ private:
     bool DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
                        int num, bool updateLabels);
 
     bool DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
                        int num, bool updateLabels);
 

+    // common part of Set{Col,Row}Sizes
+    void DoSetSizes(const wxGridSizesInfo& sizeInfo,
+                    const wxGridOperations& oper);
+
+    // common part of Disable{Row,Col}Resize and CanDrag{Row,Col}Size
+    void DoDisableLineResize(int line, wxGridFixedIndicesSet *& setFixed);
+    bool DoCanResizeLine(int line, const wxGridFixedIndicesSet *setFixed) const;
+
+    // Helper of Render(): get grid size, origin offset and fill cell arrays
+    void GetRenderSizes( const wxGridCellCoords& topLeft,
+                         const wxGridCellCoords& bottomRight,
+                         wxPoint& pointOffSet, wxSize& sizeGrid,
+                         wxGridCellCoordsArray& renderCells,
+                         wxArrayInt& arrayCols, wxArrayInt& arrayRows );
+
+    // Helper of Render(): set the scale to draw the cells at the right size.
+    void SetRenderScale( wxDC& dc, const wxPoint& pos, const wxSize& size,
+                         const wxSize& sizeGrid );
+
+    // Helper of Render(): get render start position from passed parameter
+    wxPoint GetRenderPosition( wxDC& dc, const wxPoint& position );
+
+    // Helper of Render(): draws a box around the rendered area
+    void DoRenderBox( wxDC& dc, const int& style,
+                      const wxPoint& pointOffSet,
+                      const wxSize& sizeCellArea,
+                      const wxGridCellCoords& topLeft,
+                      const wxGridCellCoords& bottomRight );
+
+    // Implementation of public Set{Row,Col}Size() and {Hide,Show}{Row,Col}().
+    // They interpret their height or width parameter slightly different from
+    // the public methods where -1 in it means "auto fit to the label" for the
+    // compatibility reasons. Here it means "show a previously hidden row or
+    // column" while 0 means "hide it" just as in the public methods. And any
+    // positive values are handled naturally, i.e. they just specify the size.
+    void DoSetRowSize( int row, int height );
+    void DoSetColSize( int col, int width );
+
+
+    // these sets contain the indices of fixed, i.e. non-resizable
+    // interactively, grid rows or columns and are NULL if there are no fixed
+    // elements (which is the default)
+    wxGridFixedIndicesSet *m_setFixedRows,
+                          *m_setFixedCols;
+

     DECLARE_DYNAMIC_CLASS( wxGrid )
     DECLARE_EVENT_TABLE()
     DECLARE_DYNAMIC_CLASS( wxGrid )
     DECLARE_EVENT_TABLE()

-    DECLARE_NO_COPY_CLASS(wxGrid)
+    wxDECLARE_NO_COPY_CLASS(wxGrid);

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -2059,7 +2352,7 @@ public:
     // more than once
     void Create(wxGrid *grid)
     {
     // more than once
     void Create(wxGrid *grid)
     {

-        wxASSERT_MSG( !m_grid, _T("shouldn't be called more than once") );
+        wxASSERT_MSG( !m_grid, wxT("shouldn't be called more than once") );

 
         Init(grid);
     }
 
         Init(grid);
     }


@@ -2080,7 +2373,7 @@ private:
 
     wxGrid *m_grid;
 
 
     wxGrid *m_grid;
 

-    DECLARE_NO_COPY_CLASS(wxGridUpdateLocker)
+    wxDECLARE_NO_COPY_CLASS(wxGridUpdateLocker);

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -2113,7 +2406,7 @@ public:
 
     // explicitly specifying inline allows gcc < 3.4 to
     // handle the deprecation attribute even in the constructor.
 
     // explicitly specifying inline allows gcc < 3.4 to
     // handle the deprecation attribute even in the constructor.

-    wxDEPRECATED( inline
+    wxDEPRECATED_CONSTRUCTOR(

     wxGridEvent(int id,
                 wxEventType type,
                 wxObject* obj,
     wxGridEvent(int id,
                 wxEventType type,
                 wxObject* obj,


@@ -2174,7 +2467,7 @@ public:
         SetEventObject(obj);
     }
 
         SetEventObject(obj);
     }
 

-    wxDEPRECATED( inline
+    wxDEPRECATED_CONSTRUCTOR(

     wxGridSizeEvent(int id,
                     wxEventType type,
                     wxObject* obj,
     wxGridSizeEvent(int id,
                     wxEventType type,
                     wxObject* obj,


@@ -2232,7 +2525,7 @@ public:
         SetEventObject(obj);
     }
 
         SetEventObject(obj);
     }
 

-    wxDEPRECATED( inline
+    wxDEPRECATED_CONSTRUCTOR(

     wxGridRangeSelectEvent(int id,
                            wxEventType type,
                            wxObject* obj,
     wxGridRangeSelectEvent(int id,
                            wxEventType type,
                            wxObject* obj,


@@ -2314,6 +2607,7 @@ wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_LEFT_DCLICK, wxGridE
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_DCLICK, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_ROW_SIZE, wxGridSizeEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SIZE, wxGridSizeEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_LABEL_RIGHT_DCLICK, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_ROW_SIZE, wxGridSizeEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SIZE, wxGridSizeEvent );

+wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_AUTO_SIZE, wxGridSizeEvent );

 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_RANGE_SELECT, wxGridRangeSelectEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGING, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGED, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_RANGE_SELECT, wxGridRangeSelectEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGING, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_CHANGED, wxGridEvent );


@@ -2324,6 +2618,7 @@ wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_EDITOR_CREATED, wxGridEdit
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_BEGIN_DRAG, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_MOVE, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SORT, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_CELL_BEGIN_DRAG, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_MOVE, wxGridEvent );
 wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_COL_SORT, wxGridEvent );

+wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_ADV, wxEVT_GRID_TABBING, wxGridEvent );

 
 typedef void (wxEvtHandler::*wxGridEventFunction)(wxGridEvent&);
 typedef void (wxEvtHandler::*wxGridSizeEventFunction)(wxGridSizeEvent&);
 
 typedef void (wxEvtHandler::*wxGridEventFunction)(wxGridEvent&);
 typedef void (wxEvtHandler::*wxGridSizeEventFunction)(wxGridSizeEvent&);


@@ -2364,6 +2659,7 @@ typedef void (wxEvtHandler::*wxGridEditorCreatedEventFunction)(wxGridEditorCreat
 #define EVT_GRID_CMD_LABEL_RIGHT_DCLICK(id, fn)  wx__DECLARE_GRIDEVT(LABEL_RIGHT_DCLICK, id, fn)
 #define EVT_GRID_CMD_ROW_SIZE(id, fn)            wx__DECLARE_GRIDSIZEEVT(ROW_SIZE, id, fn)
 #define EVT_GRID_CMD_COL_SIZE(id, fn)            wx__DECLARE_GRIDSIZEEVT(COL_SIZE, id, fn)
 #define EVT_GRID_CMD_LABEL_RIGHT_DCLICK(id, fn)  wx__DECLARE_GRIDEVT(LABEL_RIGHT_DCLICK, id, fn)
 #define EVT_GRID_CMD_ROW_SIZE(id, fn)            wx__DECLARE_GRIDSIZEEVT(ROW_SIZE, id, fn)
 #define EVT_GRID_CMD_COL_SIZE(id, fn)            wx__DECLARE_GRIDSIZEEVT(COL_SIZE, id, fn)

+#define EVT_GRID_CMD_COL_AUTO_SIZE(id, fn)       wx__DECLARE_GRIDSIZEEVT(COL_AUTO_SIZE, id, fn)

 #define EVT_GRID_CMD_COL_MOVE(id, fn)            wx__DECLARE_GRIDEVT(COL_MOVE, id, fn)
 #define EVT_GRID_CMD_COL_SORT(id, fn)            wx__DECLARE_GRIDEVT(COL_SORT, id, fn)
 #define EVT_GRID_CMD_RANGE_SELECT(id, fn)        wx__DECLARE_GRIDRANGESELEVT(RANGE_SELECT, id, fn)
 #define EVT_GRID_CMD_COL_MOVE(id, fn)            wx__DECLARE_GRIDEVT(COL_MOVE, id, fn)
 #define EVT_GRID_CMD_COL_SORT(id, fn)            wx__DECLARE_GRIDEVT(COL_SORT, id, fn)
 #define EVT_GRID_CMD_RANGE_SELECT(id, fn)        wx__DECLARE_GRIDRANGESELEVT(RANGE_SELECT, id, fn)


@@ -2374,6 +2670,7 @@ typedef void (wxEvtHandler::*wxGridEditorCreatedEventFunction)(wxGridEditorCreat
 #define EVT_GRID_CMD_EDITOR_HIDDEN(id, fn)       wx__DECLARE_GRIDEVT(EDITOR_HIDDEN, id, fn)
 #define EVT_GRID_CMD_EDITOR_CREATED(id, fn)      wx__DECLARE_GRIDEDITOREVT(EDITOR_CREATED, id, fn)
 #define EVT_GRID_CMD_CELL_BEGIN_DRAG(id, fn)     wx__DECLARE_GRIDEVT(CELL_BEGIN_DRAG, id, fn)
 #define EVT_GRID_CMD_EDITOR_HIDDEN(id, fn)       wx__DECLARE_GRIDEVT(EDITOR_HIDDEN, id, fn)
 #define EVT_GRID_CMD_EDITOR_CREATED(id, fn)      wx__DECLARE_GRIDEDITOREVT(EDITOR_CREATED, id, fn)
 #define EVT_GRID_CMD_CELL_BEGIN_DRAG(id, fn)     wx__DECLARE_GRIDEVT(CELL_BEGIN_DRAG, id, fn)

+#define EVT_GRID_CMD_TABBING(id, fn)             wx__DECLARE_GRIDEVT(TABBING, id, fn)

 
 // same as above but for any id (exists mainly for backwards compatibility but
 // then it's also true that you rarely have multiple grid in the same window)
 
 // same as above but for any id (exists mainly for backwards compatibility but
 // then it's also true that you rarely have multiple grid in the same window)


@@ -2387,6 +2684,7 @@ typedef void (wxEvtHandler::*wxGridEditorCreatedEventFunction)(wxGridEditorCreat
 #define EVT_GRID_LABEL_RIGHT_DCLICK(fn)  EVT_GRID_CMD_LABEL_RIGHT_DCLICK(wxID_ANY, fn)
 #define EVT_GRID_ROW_SIZE(fn)            EVT_GRID_CMD_ROW_SIZE(wxID_ANY, fn)
 #define EVT_GRID_COL_SIZE(fn)            EVT_GRID_CMD_COL_SIZE(wxID_ANY, fn)
 #define EVT_GRID_LABEL_RIGHT_DCLICK(fn)  EVT_GRID_CMD_LABEL_RIGHT_DCLICK(wxID_ANY, fn)
 #define EVT_GRID_ROW_SIZE(fn)            EVT_GRID_CMD_ROW_SIZE(wxID_ANY, fn)
 #define EVT_GRID_COL_SIZE(fn)            EVT_GRID_CMD_COL_SIZE(wxID_ANY, fn)

+#define EVT_GRID_COL_AUTO_SIZE(fn)       EVT_GRID_CMD_COL_AUTO_SIZE(wxID_ANY, fn)

 #define EVT_GRID_COL_MOVE(fn)            EVT_GRID_CMD_COL_MOVE(wxID_ANY, fn)
 #define EVT_GRID_COL_SORT(fn)            EVT_GRID_CMD_COL_SORT(wxID_ANY, fn)
 #define EVT_GRID_RANGE_SELECT(fn)        EVT_GRID_CMD_RANGE_SELECT(wxID_ANY, fn)
 #define EVT_GRID_COL_MOVE(fn)            EVT_GRID_CMD_COL_MOVE(wxID_ANY, fn)
 #define EVT_GRID_COL_SORT(fn)            EVT_GRID_CMD_COL_SORT(wxID_ANY, fn)
 #define EVT_GRID_RANGE_SELECT(fn)        EVT_GRID_CMD_RANGE_SELECT(wxID_ANY, fn)


@@ -2397,6 +2695,7 @@ typedef void (wxEvtHandler::*wxGridEditorCreatedEventFunction)(wxGridEditorCreat
 #define EVT_GRID_EDITOR_HIDDEN(fn)       EVT_GRID_CMD_EDITOR_HIDDEN(wxID_ANY, fn)
 #define EVT_GRID_EDITOR_CREATED(fn)      EVT_GRID_CMD_EDITOR_CREATED(wxID_ANY, fn)
 #define EVT_GRID_CELL_BEGIN_DRAG(fn)     EVT_GRID_CMD_CELL_BEGIN_DRAG(wxID_ANY, fn)
 #define EVT_GRID_EDITOR_HIDDEN(fn)       EVT_GRID_CMD_EDITOR_HIDDEN(wxID_ANY, fn)
 #define EVT_GRID_EDITOR_CREATED(fn)      EVT_GRID_CMD_EDITOR_CREATED(wxID_ANY, fn)
 #define EVT_GRID_CELL_BEGIN_DRAG(fn)     EVT_GRID_CMD_CELL_BEGIN_DRAG(wxID_ANY, fn)

+#define EVT_GRID_TABBING(fn)             EVT_GRID_CMD_TABBING(wxID_ANY, fn)

 
 // we used to have a single wxEVT_GRID_CELL_CHANGE event but it was split into
 // wxEVT_GRID_CELL_CHANGING and CHANGED ones in wx 2.9.0, however the CHANGED
 
 // we used to have a single wxEVT_GRID_CELL_CHANGE event but it was split into
 // wxEVT_GRID_CELL_CHANGING and CHANGED ones in wx 2.9.0, however the CHANGED


@@ -2415,9 +2714,9 @@ extern const int wxEVT_GRID_CREATE_CELL;
 extern const int wxEVT_GRID_CHANGE_LABELS;
 extern const int wxEVT_GRID_CHANGE_SEL_LABEL;
 
 extern const int wxEVT_GRID_CHANGE_LABELS;
 extern const int wxEVT_GRID_CHANGE_SEL_LABEL;
 

-#define EVT_GRID_CREATE_CELL(fn)      DECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CREATE_CELL,      wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
-#define EVT_GRID_CHANGE_LABELS(fn)    DECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CHANGE_LABELS,    wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
-#define EVT_GRID_CHANGE_SEL_LABEL(fn) DECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CHANGE_SEL_LABEL, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
+#define EVT_GRID_CREATE_CELL(fn)      wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CREATE_CELL,      wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
+#define EVT_GRID_CHANGE_LABELS(fn)    wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CHANGE_LABELS,    wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),
+#define EVT_GRID_CHANGE_SEL_LABEL(fn) wxDECLARE_EVENT_TABLE_ENTRY( wxEVT_GRID_CHANGE_SEL_LABEL, wxID_ANY, wxID_ANY, (wxObjectEventFunction) (wxEventFunction)  wxStaticCastEvent( wxGridEventFunction, &fn ), NULL ),

 
 #endif
 
 
 #endif