Add files necessary to run Expat configure.

[wxWidgets.git] / interface / wx / grid.h

diff --git a/interface/wx/grid.h b/interface/wx/grid.h
index 3d6f26a5f99f52c90b0c5d6ad9d003e5feeced49..2bdabe866a6e211220ba74037795d3e79522fc62 100644 (file)
--- a/interface/wx/grid.h
+++ b/interface/wx/grid.h
@@ -3,7 +3,7 @@
 // Purpose:     interface of wxGrid and related classes
 // Author:      wxWidgets team
 // RCS-ID:      $Id$
 // Purpose:     interface of wxGrid and related classes
 // Author:      wxWidgets team
 // RCS-ID:      $Id$

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /**
 /////////////////////////////////////////////////////////////////////////////
 
 /**


@@ -18,12 +18,16 @@
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellBoolRenderer, wxGridCellFloatRenderer,
-         wxGridCellNumberRenderer, wxGridCellStringRenderer
+    @see wxGridCellAutoWrapStringRenderer, wxGridCellBoolRenderer,
+         wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
+         wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+         wxGridCellStringRenderer

 */
 */

-class wxGridCellRenderer
+class wxGridCellRenderer : public wxClientDataContainer, public wxRefCounter

 {
 public:
 {
 public:

+    wxGridCellRenderer();
+

     /**
         This function must be implemented in derived classes to return a copy
         of itself.
     /**
         This function must be implemented in derived classes to return a copy
         of itself.


@@ -48,8 +52,39 @@ public:
     */
     virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
                                int row, int col) = 0;
     */
     virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
                                int row, int col) = 0;

+
+protected:
+    /**
+        The destructor is private because only DecRef() can delete us.
+    */
+    virtual ~wxGridCellRenderer();
+};
+
+/**
+    @class wxGridCellAutoWrapStringRenderer
+
+    This class may be used to format string data in a cell. The too
+    long lines are wrapped to be shown entirely at word boundaries.
+
+    @library{wxadv}
+    @category{grid}
+
+    @see wxGridCellRenderer, wxGridCellBoolRenderer,
+         wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
+         wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+         wxGridCellStringRenderer
+*/
+
+class wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxGridCellAutoWrapStringRenderer();

 };
 
 };
 

+

 /**
     @class wxGridCellBoolRenderer
 
 /**
     @class wxGridCellBoolRenderer
 


@@ -58,7 +93,9 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellRenderer, wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+    @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+         wxGridCellDateTimeRenderer, wxGridCellEnumRenderer,
+         wxGridCellFloatRenderer, wxGridCellNumberRenderer,

          wxGridCellStringRenderer
 */
 class wxGridCellBoolRenderer : public wxGridCellRenderer
          wxGridCellStringRenderer
 */
 class wxGridCellBoolRenderer : public wxGridCellRenderer


@@ -70,6 +107,110 @@ public:
     wxGridCellBoolRenderer();
 };
 
     wxGridCellBoolRenderer();
 };
 

+/**
+    @class wxGridCellDateTimeRenderer
+
+    This class may be used to format a date/time data in a cell.
+    The class wxDateTime is used internally to display the local date/time
+    or to parse the string date entered in the cell thanks to the defined format.
+
+    @library{wxadv}
+    @category{grid}
+
+    @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+         wxGridCellBoolRenderer, wxGridCellEnumRenderer,
+         wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+         wxGridCellStringRenderer
+*/
+class wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
+{
+public:
+    /**
+        Date/time renderer constructor.
+
+        @param outformat
+            strptime()-like format string used the parse the output date/time.
+        @param informat
+            strptime()-like format string used to parse the string entered in the cell.
+    */
+    wxGridCellDateTimeRenderer(const wxString& outformat = wxDefaultDateTimeFormat,
+                               const wxString& informat = wxDefaultDateTimeFormat);
+
+
+    /**
+        Sets the strptime()-like format string which will be used to parse
+        the date/time.
+
+        @param params
+            strptime()-like format string used to parse the date/time.
+    */
+    virtual void SetParameters(const wxString& params);
+};
+
+/**
+    @class wxGridCellEnumRenderer
+
+    This class may be used to render in a cell a number as a textual
+    equivalent.
+
+    The corresponding text strings are specified as comma-separated items in
+    the string passed to this renderer ctor or SetParameters() method. For
+    example, if this string is @c "John,Fred,Bob" the cell will be rendered as
+    "John", "Fred" or "Bob" if its contents is 0, 1 or 2 respectively.
+
+    @library{wxadv}
+    @category{grid}
+
+    @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+         wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+         wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+         wxGridCellStringRenderer
+*/
+class wxGridCellEnumRenderer : public wxGridCellStringRenderer
+{
+public:
+    /**
+        Enum renderer ctor.
+
+        @param choices
+            Comma separated string parameters "item1[,item2[...,itemN]]".
+    */
+    wxGridCellEnumRenderer( const wxString& choices = wxEmptyString );
+
+    /**
+        Sets the comma separated string content of the enum.
+
+        @param params
+            Comma separated string parameters "item1[,item2[...,itemN]]".
+    */
+    virtual void SetParameters(const wxString& params);
+};
+
+/**
+    Specifier used to format the data to string for the numbers handled by
+    wxGridCellFloatRenderer and wxGridCellFloatEditor.
+
+    @since 2.9.3
+*/
+enum wxGridCellFloatFormat
+{
+    /// Decimal floating point (%f).
+    wxGRID_FLOAT_FORMAT_FIXED       = 0x0010,
+
+    /// Scientific notation (mantise/exponent) using e character (%e).
+    wxGRID_FLOAT_FORMAT_SCIENTIFIC  = 0x0020,
+
+    /// Use the shorter of %e or %f (%g).
+    wxGRID_FLOAT_FORMAT_COMPACT     = 0x0040,
+
+    /// To use in combination with one of the above formats for the upper
+    /// case version (%F/%E/%G)
+    wxGRID_FLOAT_FORMAT_UPPER       = 0x0080,
+
+    /// The format used by default (wxGRID_FLOAT_FORMAT_FIXED).
+    wxGRID_FLOAT_FORMAT_DEFAULT     = wxGRID_FLOAT_FORMAT_FIXED
+};
+

 /**
     @class wxGridCellFloatRenderer
 
 /**
     @class wxGridCellFloatRenderer
 


@@ -78,19 +219,37 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellRenderer, wxGridCellBoolRenderer, wxGridCellNumberRenderer,
+    @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+         wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+         wxGridCellEnumRenderer, wxGridCellNumberRenderer,

          wxGridCellStringRenderer
 */
 class wxGridCellFloatRenderer : public wxGridCellStringRenderer
 {
 public:
     /**
          wxGridCellStringRenderer
 */
 class wxGridCellFloatRenderer : public wxGridCellStringRenderer
 {
 public:
     /**

+        Float cell renderer ctor.
+

         @param width
             Minimum number of characters to be shown.
         @param precision
             Number of digits after the decimal dot.
         @param width
             Minimum number of characters to be shown.
         @param precision
             Number of digits after the decimal dot.

+        @param format
+            The format used to display the string, must be a combination of
+            ::wxGridCellFloatFormat enum elements. This parameter is only
+            available since wxWidgets 2.9.3.
+    */
+    wxGridCellFloatRenderer(int width = -1, int precision = -1,
+                            int format = wxGRID_FLOAT_FORMAT_DEFAULT);
+
+    /**
+        Returns the specifier used to format the data to string.
+
+        The returned value is a combination of ::wxGridCellFloatFormat elements.
+
+        @since 2.9.3

     */
     */

-    wxGridCellFloatRenderer(int width = -1, int precision = -1);
+    int GetFormat() const;

 
     /**
         Returns the precision.
 
     /**
         Returns the precision.


@@ -103,7 +262,18 @@ public:
     int GetWidth() const;
 
     /**
     int GetWidth() const;
 
     /**

-        Parameters string format is "width[,precision]".
+        Set the format to use for display the number.
+
+        @param format
+            Must be a combination of ::wxGridCellFloatFormat enum elements.
+
+        @since 2.9.3
+    */
+    void SetFormat(int format);
+
+    /**
+        The parameters string format is "width[,precision[,format]]" where
+        @c format should be chosen between f|e|g|E|G (f is used by default)

     */
     virtual void SetParameters(const wxString& params);
 
     */
     virtual void SetParameters(const wxString& params);
 


@@ -126,7 +296,9 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellRenderer, wxGridCellBoolRenderer, wxGridCellFloatRenderer,
+    @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+         wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+         wxGridCellEnumRenderer, wxGridCellFloatRenderer,

          wxGridCellStringRenderer
 */
 class wxGridCellNumberRenderer : public wxGridCellStringRenderer
          wxGridCellStringRenderer
 */
 class wxGridCellNumberRenderer : public wxGridCellStringRenderer


@@ -147,7 +319,9 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellRenderer, wxGridCellBoolRenderer, wxGridCellFloatRenderer,
+    @see wxGridCellRenderer, wxGridCellAutoWrapStringRenderer,
+         wxGridCellBoolRenderer, wxGridCellDateTimeRenderer,
+         wxGridCellEnumRenderer, wxGridCellFloatRenderer,

          wxGridCellNumberRenderer
 */
 class wxGridCellStringRenderer : public wxGridCellRenderer
          wxGridCellNumberRenderer
 */
 class wxGridCellStringRenderer : public wxGridCellRenderer


@@ -160,7 +334,6 @@ public:
 };
 
 
 };
 
 

-

 /**
     @class wxGridCellEditor
 
 /**
     @class wxGridCellEditor
 


@@ -173,10 +346,12 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellBoolEditor, wxGridCellChoiceEditor, wxGridCellFloatEditor,
-         wxGridCellNumberEditor, wxGridCellTextEditor
+    @see wxGridCellAutoWrapStringEditor, wxGridCellBoolEditor,
+         wxGridCellChoiceEditor, wxGridCellEnumEditor,
+         wxGridCellFloatEditor, wxGridCellNumberEditor,
+         wxGridCellTextEditor

 */
 */

-class wxGridCellEditor
+class wxGridCellEditor : public wxClientDataContainer, public wxRefCounter

 {
 public:
     /**
 {
 public:
     /**


@@ -186,7 +361,13 @@ public:
 
     /**
         Fetch the value from the table and prepare the edit control to begin
 
     /**
         Fetch the value from the table and prepare the edit control to begin

-        editing. Sets the focus to the edit control.
+        editing.
+
+        This function should save the original value of the grid cell at the
+        given @a row and @a col and show the control allowing the user to
+        change it.
+
+        @see EndEdit()

     */
     virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
 
     */
     virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
 


@@ -207,12 +388,34 @@ public:
     virtual void Destroy();
 
     /**
     virtual void Destroy();
 
     /**

-        Complete the editing of the current cell. If necessary, the control may
-        be destroyed.
+        End editing the cell.

 
 

-        @return @true if the value has changed.
+        This function must check if the current value of the editing control is
+        valid and different from the original value (available as @a oldval in
+        its string form and possibly saved internally using its real type by
+        BeginEdit()). If it isn't, it just returns @false, otherwise it must do
+        the following:
+            - Save the new value internally so that ApplyEdit() could apply it.
+            - Fill @a newval (which is never @NULL) with the string
+            representation of the new value.
+            - Return @true
+
+        Notice that it must @em not modify the grid as the change could still
+        be vetoed.
+
+        If the user-defined wxEVT_GRID_CELL_CHANGING event handler doesn't veto
+        this change, ApplyEdit() will be called next.

     */
     */

-    virtual bool EndEdit(int row, int col, wxGrid* grid) = 0;
+    virtual bool EndEdit(int row, int col, const wxGrid* grid,
+                         const wxString& oldval, wxString* newval) = 0;
+
+    /**
+        Effectively save the changes in the grid.
+
+        This function should save the value of the control in the grid. It is
+        called only after EndEdit() returns @true.
+     */
+    virtual void ApplyEdit(int row, int col, wxGrid* grid) = 0;

 
     /**
         Some types of controls on some platforms may need some help with the
 
     /**
         Some types of controls on some platforms may need some help with the


@@ -229,7 +432,7 @@ 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, wxGridCellAttr& attr);

 
     /**
         Reset the value in the control back to its starting value.
 
     /**
         Reset the value in the control back to its starting value.


@@ -259,6 +462,11 @@ public:
     */
     virtual void StartingKey(wxKeyEvent& event);
 
     */
     virtual void StartingKey(wxKeyEvent& event);
 

+    /**
+       Returns the value currently in the editor control.
+     */
+    virtual wxString GetValue() const = 0;
+

 protected:
 
     /**
 protected:
 
     /**


@@ -267,6 +475,24 @@ protected:
     virtual ~wxGridCellEditor();
 };
 
     virtual ~wxGridCellEditor();
 };
 

+/**
+    @class wxGridCellAutoWrapStringEditor
+
+    Grid cell editor for wrappable string/text data.
+
+    @library{wxadv}
+    @category{grid}
+
+    @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellChoiceEditor,
+         wxGridCellEnumEditor, wxGridCellFloatEditor,
+         wxGridCellNumberEditor, wxGridCellTextEditor
+*/
+class wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
+{
+public:
+    wxGridCellAutoWrapStringEditor();
+};
+

 /**
     @class wxGridCellBoolEditor
 
 /**
     @class wxGridCellBoolEditor
 


@@ -275,8 +501,10 @@ protected:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellEditor, wxGridCellChoiceEditor, wxGridCellFloatEditor,
-         wxGridCellNumberEditor, wxGridCellTextEditor
+    @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+         wxGridCellChoiceEditor, wxGridCellEnumEditor,
+         wxGridCellFloatEditor, wxGridCellNumberEditor,
+         wxGridCellTextEditor

 */
 class wxGridCellBoolEditor : public wxGridCellEditor
 {
 */
 class wxGridCellBoolEditor : public wxGridCellEditor
 {


@@ -300,7 +528,7 @@ public:
         an empty string otherwise.
     */
     static void UseStringValues(const wxString& valueTrue = "1",
         an empty string otherwise.
     */
     static void UseStringValues(const wxString& valueTrue = "1",

-                                const wxString& valueFalse = wxEmptyString) const;
+                                const wxString& valueFalse = wxEmptyString);

 };
 
 /**
 };
 
 /**


@@ -312,13 +540,17 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellFloatEditor,
-         wxGridCellNumberEditor, wxGridCellTextEditor
+    @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+         wxGridCellBoolEditor, wxGridCellEnumEditor,
+         wxGridCellFloatEditor, wxGridCellNumberEditor,
+         wxGridCellTextEditor

 */
 class wxGridCellChoiceEditor : public wxGridCellEditor
 {
 public:
     /**
 */
 class wxGridCellChoiceEditor : public wxGridCellEditor
 {
 public:
     /**

+        Choice cell renderer ctor.
+

         @param count
             Number of strings from which the user can choose.
         @param choices
         @param count
             Number of strings from which the user can choose.
         @param choices


@@ -330,7 +562,10 @@ public:
     wxGridCellChoiceEditor(size_t count = 0,
                            const wxString choices[] = NULL,
                            bool allowOthers = false);
     wxGridCellChoiceEditor(size_t count = 0,
                            const wxString choices[] = NULL,
                            bool allowOthers = false);

+

     /**
     /**

+        Choice cell renderer ctor.
+

         @param choices
             An array of strings from which the user can choose.
         @param allowOthers
         @param choices
             An array of strings from which the user can choose.
         @param allowOthers


@@ -346,6 +581,33 @@ public:
     virtual void SetParameters(const wxString& params);
 };
 
     virtual void SetParameters(const wxString& params);
 };
 

+/**
+    @class wxGridCellEnumEditor
+
+    Grid cell editor which displays an enum number as a textual equivalent
+    (eg. data in cell is 0,1,2 ... n the cell could be displayed as
+    "John","Fred"..."Bob" in the combo choice box).
+
+    @library{wxadv}
+    @category{grid}
+
+    @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+         wxGridCellBoolEditor, wxGridCellChoiceEditor,
+         wxGridCellTextEditor, wxGridCellFloatEditor,
+         wxGridCellNumberEditor
+*/
+class wxGridCellEnumEditor : public wxGridCellChoiceEditor
+{
+public:
+    /**
+        Enum cell editor ctor.
+
+        @param choices
+            Comma separated choice parameters "item1[,item2[...,itemN]]".
+    */
+    wxGridCellEnumEditor( const wxString& choices = wxEmptyString );
+};
+

 /**
     @class wxGridCellTextEditor
 
 /**
     @class wxGridCellTextEditor
 


@@ -354,22 +616,35 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellChoiceEditor,
-         wxGridCellFloatEditor, wxGridCellNumberEditor
+    @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+         wxGridCellBoolEditor, wxGridCellChoiceEditor,
+         wxGridCellEnumEditor, wxGridCellFloatEditor,
+         wxGridCellNumberEditor

 */
 class wxGridCellTextEditor : public wxGridCellEditor
 {
 public:
     /**
 */
 class wxGridCellTextEditor : public wxGridCellEditor
 {
 public:
     /**

-        Default constructor.
+        Text cell editor constructor.
+
+        @param maxChars
+            Maximum width of text (this parameter is supported starting since
+            wxWidgets 2.9.5).

     */
     */

-    wxGridCellTextEditor();
+    explicit wxGridCellTextEditor(size_t maxChars = 0);

 
     /**
         The parameters string format is "n" where n is a number representing
         the maximum width.
     */
     virtual void SetParameters(const wxString& params);
 
     /**
         The parameters string format is "n" where n is a number representing
         the maximum width.
     */
     virtual void SetParameters(const wxString& params);

+
+    /**
+        Set validator to validate user input.
+
+        @since 2.9.5
+    */
+    virtual void SetValidator(const wxValidator& validator);

 };
 
 /**
 };
 
 /**


@@ -380,22 +655,32 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellEditor, wxGridCellNumberEditor, wxGridCellBoolEditor,
-    wxGridCellTextEditor, wxGridCellChoiceEditor
+    @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+         wxGridCellBoolEditor, wxGridCellChoiceEditor,
+         wxGridCellEnumEditor, wxGridCellNumberEditor,
+         wxGridCellTextEditor

 */
 class wxGridCellFloatEditor : public wxGridCellTextEditor
 {
 public:
     /**
 */
 class wxGridCellFloatEditor : public wxGridCellTextEditor
 {
 public:
     /**

+        Float cell editor ctor.
+

         @param width
             Minimum number of characters to be shown.
         @param precision
             Number of digits after the decimal dot.
         @param width
             Minimum number of characters to be shown.
         @param precision
             Number of digits after the decimal dot.

+        @param format
+            The format to use for displaying the number, a combination of
+            ::wxGridCellFloatFormat enum elements. This parameter is only
+            available since wxWidgets 2.9.3.

     */
     */

-    wxGridCellFloatEditor(int width = -1, int precision = -1);
+    wxGridCellFloatEditor(int width = -1, int precision = -1,
+                          int format = wxGRID_FLOAT_FORMAT_DEFAULT);

 
     /**
 
     /**

-        Parameters string format is "width,precision"
+        The parameters string format is "width[,precision[,format]]" where
+        @c format should be chosen between f|e|g|E|G (f is used by default)

     */
     virtual void SetParameters(const wxString& params);
 };
     */
     virtual void SetParameters(const wxString& params);
 };


@@ -408,8 +693,10 @@ public:
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}
 

-    @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellChoiceEditor,
-         wxGridCellFloatEditor, wxGridCellTextEditor
+    @see wxGridCellEditor, wxGridCellAutoWrapStringEditor,
+         wxGridCellBoolEditor, wxGridCellChoiceEditor,
+         wxGridCellEnumEditor, wxGridCellFloatEditor,
+         wxGridCellTextEditor

 */
 class wxGridCellNumberEditor : public wxGridCellTextEditor
 {
 */
 class wxGridCellNumberEditor : public wxGridCellTextEditor
 {


@@ -453,13 +740,33 @@ protected:
     @library{wxadv}
     @category{grid}
 */
     @library{wxadv}
     @category{grid}
 */

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

 {
 public:
 {
 public:

+    /**
+        Kind of the attribute to retrieve.
+
+        @see wxGridCellAttrProvider::GetAttr(), wxGridTableBase::GetAttr()
+     */
+    enum wxAttrKind
+    {
+        /// Return the combined effective attribute for the cell.
+        Any,
+
+        /// Return the attribute explicitly set for this cell.
+        Cell,
+
+        /// Return the attribute set for this cells row.
+        Row,
+
+        /// Return the attribute set for this cells column.
+        Col
+    };
+

     /**
         Default constructor.
     */
     /**
         Default constructor.
     */

-    wxGridCellAttr();
+    wxGridCellAttr(wxGridCellAttr* attrDefault = NULL);

     /**
         Constructor specifying some of the often used attributes.
     */
     /**
         Constructor specifying some of the often used attributes.
     */


@@ -479,7 +786,21 @@ public:
     void DecRef();
 
     /**
     void DecRef();
 
     /**

-        See SetAlignment() for the returned values.
+        Get the alignment to use for the cell with the given attribute.
+
+        If this attribute doesn't specify any alignment, the default attribute
+        alignment is used (which can be changed using
+        wxGrid::SetDefaultCellAlignment() but is left and top by default).
+
+        Notice that @a hAlign and @a vAlign values are always overwritten by
+        this function, use GetNonDefaultAlignment() if this is not desirable.
+
+        @param hAlign
+            Horizontal alignment is returned here if this argument is non-@NULL.
+            It is one of wxALIGN_LEFT, wxALIGN_CENTRE or wxALIGN_RIGHT.
+        @param vAlign
+            Vertical alignment is returned here if this argument is non-@NULL.
+            It is one of wxALIGN_TOP, wxALIGN_CENTRE or wxALIGN_BOTTOM.

     */
     void GetAlignment(int* hAlign, int* vAlign) const;
 
     */
     void GetAlignment(int* hAlign, int* vAlign) const;
 


@@ -498,6 +819,29 @@ public:
     */
     const wxFont& GetFont() const;
 
     */
     const wxFont& GetFont() const;
 

+    /**
+        Get the alignment defined by this attribute.
+
+        Unlike GetAlignment() this function only modifies @a hAlign and @a
+        vAlign if this attribute does define a non-default alignment. This
+        means that they must be initialized before calling this function and
+        that their values will be preserved unchanged if they are different
+        from wxALIGN_INVALID.
+
+        For example, the following fragment can be used to use the cell
+        alignment if one is defined but right-align its contents by default
+        (instead of left-aligning it by default) while still using the default
+        vertical alignment:
+        @code
+            int hAlign = wxALIGN_RIGHT,
+                vAlign = wxALIGN_INVALID;
+            attr.GetNonDefaultAlignment(&hAlign, &vAlign);
+        @endcode
+
+        @since 2.9.1
+     */
+    void GetNonDefaultAlignment(int *hAlign, int *vAlign) const;
+

     /**
         Returns the cell renderer.
     */
     /**
         Returns the cell renderer.
     */


@@ -592,113 +936,474 @@ public:
         Sets the text colour.
     */
     void SetTextColour(const wxColour& colText);
         Sets the text colour.
     */
     void SetTextColour(const wxColour& colText);

-};

 
 

+protected:

 
 

+    /**
+        The destructor is private because only DecRef() can delete us.
+    */
+    virtual ~wxGridCellAttr();
+};

 
 /**
 
 /**

-    @class wxGridTableBase
-
-    The almost abstract base class for grid tables.
-
-    A grid table is responsible for storing the grid data and, indirectly, grid
-    cell attributes. The data can be stored in the way most convenient for the
-    application but has to be provided in string form to wxGrid. It is also
-    possible to provide cells values in other formats if appropriate, e.g. as
-    numbers.
+    Base class for corner window renderer.

 
 

-    This base class is not quite abstract as it implements a trivial strategy
-    for storing the attributes by forwarding it to wxGridCellAttrProvider and
-    also provides stubs for some other functions. However it does have a number
-    of pure virtual methods which must be implemented in the derived classes.
+    This is the simplest of all header renderers and only has a single
+    function.

 
 

-    @see wxGridStringTable
+    @see wxGridCellAttrProvider::GetCornerRenderer()

 
 

-    @library{wxadv}
-    @category{grid}
-*/
-class wxGridTableBase : public wxObject
+    @since 2.9.1
+ */
+class wxGridCornerHeaderRenderer

 {
 public:
     /**
 {
 public:
     /**

-        Default constructor.
-     */
-    wxGridTableBase();
-
-    /**
-        Destructor frees the attribute provider if it was created.
+        Called by the grid to draw the corner window border.
+
+        This method is responsible for drawing the border inside the given @a
+        rect and adjusting the rectangle size to correspond to the area inside
+        the border, i.e. usually call wxRect::Deflate() to account for the
+        border width.
+
+        @param grid
+            The grid whose corner window is being drawn.
+        @param dc
+            The device context to use for drawing.
+        @param rect
+            Input/output parameter which contains the border rectangle on input
+            and should be updated to contain the area inside the border on
+            function return.

      */
      */

-    virtual ~wxGridTableBase();
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const = 0;
+};

 
 

-    /**
-        Must be overridden to return the number of rows in the table.
+/**
+    Common base class for row and column headers renderers.

 
 

-        For backwards compatibility reasons, this method is not const.
-        Use GetRowsCount() instead of it in const methods of derived table
-        classes.
-     */
-    virtual int GetNumberRows() = 0;
+    @see wxGridColumnHeaderRenderer, wxGridRowHeaderRenderer

 
 

+    @since 2.9.1
+ */
+class wxGridHeaderLabelsRenderer : public wxGridCornerHeaderRenderer
+{
+public:

     /**
     /**

-        Must be overridden to return the number of columns in the table.
+        Called by the grid to draw the specified label.

 
 

-        For backwards compatibility reasons, this method is not const.
-        Use GetColsCount() instead of it in const methods of derived table
-        classes,
+        Notice that the base class DrawBorder() method is called before this
+        one.
+
+        The default implementation uses wxGrid::GetLabelTextColour() and
+        wxGrid::GetLabelFont() to draw the label.

      */
      */

-    virtual int GetNumberCols() = 0;
+    virtual void DrawLabel(const wxGrid& grid,
+                           wxDC& dc,
+                           const wxString& value,
+                           const wxRect& rect,
+                           int horizAlign,
+                           int vertAlign,
+                           int textOrientation) const;
+};

 
 

-    /**
-        Return the number of rows in the table.
+/**
+    Base class for row headers renderer.

 
 

-        This method is not virtual and is only provided as a convenience for
-        the derived classes which can't call GetNumberRows() without a
-        @c const_cast from their const methods.
-     */
-    int GetRowsCount() const;
+    This is the same as wxGridHeaderLabelsRenderer currently but we still use a
+    separate class for it to distinguish it from wxGridColumnHeaderRenderer.

 
 

-    /**
-        Return the number of columns in the table.
+    @see wxGridRowHeaderRendererDefault

 
 

-        This method is not virtual and is only provided as a convenience for
-        the derived classes which can't call GetNumberCols() without a
-        @c const_cast from their const methods.
-     */
-    int GetColsCount() const;
+    @see wxGridCellAttrProvider::GetRowHeaderRenderer()

 
 

+    @since 2.9.1
+ */
+class wxGridRowHeaderRenderer : public wxGridHeaderLabelsRenderer
+{
+};

 
 

-    /**
-        @name Table Cell Accessors
-     */
-    //@{
+/**
+    Base class for column headers renderer.

 
 

-    /**
-        Must be overridden to implement testing for empty cells.
-     */
-    virtual bool IsEmptyCell(int row, int col) = 0;
+    This is the same as wxGridHeaderLabelsRenderer currently but we still use a
+    separate class for it to distinguish it from wxGridRowHeaderRenderer.

 
 

-    /**
-        Same as IsEmptyCell() but taking wxGridCellCoords.
+    @see wxGridColumnHeaderRendererDefault

 
 

-        Notice that this method is not virtual, only IsEmptyCell() should be
-        overridden.
-     */
-    bool IsEmpty(const wxGridCellCoords& coords);
+    @see wxGridCellAttrProvider::GetColumnHeaderRenderer()

 
 

-    /**
-        Must be overridden to implement accessing the table values as text.
-     */
-    virtual wxString GetValue(int row, int col) = 0;
+    @since 2.9.1
+ */
+class wxGridColumnHeaderRenderer : public wxGridHeaderLabelsRenderer
+{
+};

 
 

-    /**
-        Must be overridden to implement setting the table values as text.
-     */
-    virtual void SetValue(int row, int col, const wxString& value) = 0;
+/**
+    Default row header renderer.

 
 

-    /**
-        Returns the type of the value in the given cell.
+    You may derive from this class if you need to only override one of its
+    methods (i.e. either DrawLabel() or DrawBorder()) but continue to use the
+    default implementation for the other one.

 
 

-        By default all cells are strings and this method returns
+    @see wxGridColumnHeaderRendererDefault
+
+    @since 2.9.1
+ */
+class wxGridRowHeaderRendererDefault : public wxGridRowHeaderRenderer
+{
+public:
+    /// Implement border drawing for the row labels.
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const;
+};
+
+/**
+    Default column header renderer.
+
+    @see wxGridRowHeaderRendererDefault
+
+    @since 2.9.1
+ */
+class wxGridColumnHeaderRendererDefault : public wxGridColumnHeaderRenderer
+{
+public:
+    /// Implement border drawing for the column labels.
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const;
+};
+
+/**
+    Default corner window renderer.
+
+    @see wxGridColumnHeaderRendererDefault, wxGridRowHeaderRendererDefault
+
+    @since 2.9.1
+ */
+class wxGridCornerHeaderRendererDefault : public wxGridCornerHeaderRenderer
+{
+public:
+    /// Implement border drawing for the corner window.
+    virtual void DrawBorder(const wxGrid& grid,
+                            wxDC& dc,
+                            wxRect& rect) const;
+};
+
+/**
+    Class providing attributes to be used for the grid cells.
+
+    This class both defines an interface which grid cell attributes providers
+    should implement -- and which can be implemented differently in derived
+    classes -- and a default implementation of this interface which is often
+    good enough to be used without modification, especially with not very large
+    grids for which the efficiency of attributes storage hardly matters (see
+    the discussion below).
+
+    An object of this class can be associated with a wxGrid using
+    wxGridTableBase::SetAttrProvider() but it's not necessary to call it if you
+    intend to use the default provider as it is used by wxGridTableBase by
+    default anyhow.
+
+    Notice that while attributes provided by this class can be set for
+    individual cells using SetAttr() or the entire rows or columns using
+    SetRowAttr() and SetColAttr() they are always retrieved using GetAttr()
+    function.
+
+
+    The default implementation of this class stores the attributes passed to
+    its SetAttr(), SetRowAttr() and SetColAttr() in a straightforward way. A
+    derived class may use its knowledge about how the attributes are used in
+    your program to implement it much more efficiently: for example, using a
+    special background colour for all even-numbered rows can be implemented by
+    simply returning the same attribute from GetAttr() if the row number is
+    even instead of having to store N/2 row attributes where N is the total
+    number of rows in the grid.
+
+    Notice that objects of this class can't be copied.
+ */
+class wxGridCellAttrProvider : public wxClientDataContainer
+{
+public:
+    /// Trivial default constructor.
+    wxGridCellAttrProvider();
+
+    /// Destructor releases any attributes held by this class.
+    virtual ~wxGridCellAttrProvider();
+
+    /**
+        Get the attribute to use for the specified cell.
+
+        If wxGridCellAttr::Any is used as @a kind value, this function combines
+        the attributes set for this cell using SetAttr() and those for its row
+        or column (set with SetRowAttr() or SetColAttr() respectively), with
+        the cell attribute having the highest precedence.
+
+        Notice that the caller must call DecRef() on the returned pointer if it
+        is non-@NULL.
+
+        @param row
+            The row of the cell.
+        @param col
+            The column of the cell.
+        @param kind
+            The kind of the attribute to return.
+        @return
+            The attribute to use which should be DecRef()'d by caller or @NULL
+            if no attributes are defined for this cell.
+     */
+    virtual wxGridCellAttr *GetAttr(int row, int col,
+                                    wxGridCellAttr::wxAttrKind kind) const;
+
+    /**
+        Setting attributes.
+
+        All these functions take ownership of the attribute passed to them,
+        i.e. will call DecRef() on it themselves later and so it should not be
+        destroyed by the caller. And the attribute can be @NULL to reset a
+        previously set value.
+     */
+    //@{
+
+    /// Set attribute for the specified cell.
+    virtual void SetAttr(wxGridCellAttr *attr, int row, int col);
+
+    /// Set attribute for the specified row.
+    virtual void SetRowAttr(wxGridCellAttr *attr, int row);
+
+    /// Set attribute for the specified column.
+    virtual void SetColAttr(wxGridCellAttr *attr, int col);
+
+    //@}
+
+    /**
+        Getting header renderers.
+
+        These functions return the renderers for the given row or column header
+        label and the corner window. Unlike cell attributes, these objects are
+        not reference counted and are never @NULL so they are returned by
+        reference and not pointer and DecRef() shouldn't (and can't) be called
+        for them.
+
+        All these functions were added in wxWidgets 2.9.1.
+     */
+    //@{
+
+    /**
+        Return the renderer used for drawing column headers.
+
+        By default wxGridColumnHeaderRendererDefault is returned.
+
+        @see wxGrid::SetUseNativeColLabels(), wxGrid::UseNativeColHeader()
+
+        @since 2.9.1
+     */
+    virtual const wxGridColumnHeaderRenderer& GetColumnHeaderRenderer(int col);
+
+    /**
+        Return the renderer used for drawing row headers.
+
+        By default wxGridRowHeaderRendererDefault is returned.
+
+        @since 2.9.1
+     */
+    virtual const wxGridRowHeaderRenderer& GetRowHeaderRenderer(int row);
+
+    /**
+        Return the renderer used for drawing the corner window.
+
+        By default wxGridCornerHeaderRendererDefault is returned.
+
+        @since 2.9.1
+     */
+    virtual const wxGridCornerHeaderRenderer& GetCornerRenderer();
+
+    //@}
+};
+
+/**
+    Represents coordinates of a grid cell.
+
+    An object of this class is simply a (row, column) pair.
+ */
+class wxGridCellCoords
+{
+public:
+    /**
+        Default constructor initializes the object to invalid state.
+
+        Initially the row and column are both invalid (-1) and so operator!()
+        for an uninitialized wxGridCellCoords returns false.
+     */
+    wxGridCellCoords();
+
+    /**
+        Constructor taking a row and a column.
+     */
+    wxGridCellCoords(int row, int col);
+
+    /**
+        Return the row of the coordinate.
+     */
+    int GetRow() const;
+
+    /**
+        Set the row of the coordinate.
+     */
+    void SetRow(int n);
+
+    /**
+        Return the column of the coordinate.
+     */
+    int GetCol() const;
+
+    /**
+        Set the column of the coordinate.
+     */
+    void SetCol(int n);
+
+    /**
+        Set the row and column of the coordinate.
+     */
+    void Set(int row, int col);
+
+    /**
+        Assignment operator for coordinate types.
+     */
+    wxGridCellCoords& operator=(const wxGridCellCoords& other);
+
+    /**
+        Equality operator.
+     */
+    bool operator==(const wxGridCellCoords& other) const;
+
+    /**
+        Inequality operator.
+     */
+     bool operator!=(const wxGridCellCoords& other) const;
+
+    /**
+        Checks whether the coordinates are invalid.
+
+        Returns false only if both row and column are -1. Notice that if either
+        row or column (but not both) are -1, this method returns true even if
+        the object is invalid. This is done because objects in such state
+        should actually never exist, i.e. either both coordinates should be -1
+        or none of them should be -1.
+     */
+    bool operator!() const;
+};
+
+/**
+    @class wxGridTableBase
+
+    The almost abstract base class for grid tables.
+
+    A grid table is responsible for storing the grid data and, indirectly, grid
+    cell attributes. The data can be stored in the way most convenient for the
+    application but has to be provided in string form to wxGrid. It is also
+    possible to provide cells values in other formats if appropriate, e.g. as
+    numbers.
+
+    This base class is not quite abstract as it implements a trivial strategy
+    for storing the attributes by forwarding it to wxGridCellAttrProvider and
+    also provides stubs for some other functions. However it does have a number
+    of pure virtual methods which must be implemented in the derived classes.
+
+    @see wxGridStringTable
+
+    @library{wxadv}
+    @category{grid}
+*/
+class wxGridTableBase : public wxObject
+{
+public:
+    /**
+        Default constructor.
+     */
+    wxGridTableBase();
+
+    /**
+        Destructor frees the attribute provider if it was created.
+     */
+    virtual ~wxGridTableBase();
+
+    /**
+        Must be overridden to return the number of rows in the table.
+
+        For backwards compatibility reasons, this method is not const.
+        Use GetRowsCount() instead of it in const methods of derived table
+        classes.
+     */
+    virtual int GetNumberRows() = 0;
+
+    /**
+        Must be overridden to return the number of columns in the table.
+
+        For backwards compatibility reasons, this method is not const.
+        Use GetColsCount() instead of it in const methods of derived table
+        classes,
+     */
+    virtual int GetNumberCols() = 0;
+
+    /**
+        Return the number of rows in the table.
+
+        This method is not virtual and is only provided as a convenience for
+        the derived classes which can't call GetNumberRows() without a
+        @c const_cast from their const methods.
+     */
+    int GetRowsCount() const;
+
+    /**
+        Return the number of columns in the table.
+
+        This method is not virtual and is only provided as a convenience for
+        the derived classes which can't call GetNumberCols() without a
+        @c const_cast from their const methods.
+     */
+    int GetColsCount() const;
+
+
+    /**
+        @name Table Cell Accessors
+     */
+    //@{
+
+    /**
+        May be overridden to implement testing for empty cells.
+
+        This method is used by the grid to test if the given cell is not used
+        and so whether a neighbouring cell may overflow into it. By default it
+        only returns true if the value of the given cell, as returned by
+        GetValue(), is empty.
+     */
+    virtual bool IsEmptyCell(int row, int col);
+
+    /**
+        Same as IsEmptyCell() but taking wxGridCellCoords.
+
+        Notice that this method is not virtual, only IsEmptyCell() should be
+        overridden.
+     */
+    bool IsEmpty(const wxGridCellCoords& coords);
+
+    /**
+        Must be overridden to implement accessing the table values as text.
+     */
+    virtual wxString GetValue(int row, int col) = 0;
+
+    /**
+        Must be overridden to implement setting the table values as text.
+     */
+    virtual void SetValue(int row, int col, const wxString& value) = 0;
+
+    /**
+        Returns the type of the value in the given cell.
+
+        By default all cells are strings and this method returns

         @c wxGRID_VALUE_STRING.
      */
     virtual wxString GetTypeName(int row, int col);
         @c wxGRID_VALUE_STRING.
      */
     virtual wxString GetTypeName(int row, int col);


@@ -856,6 +1561,9 @@ public:
     /**
         Delete rows from the table.
 
     /**
         Delete rows from the table.
 

+        Notice that currently deleting a row intersecting a multi-cell (see
+        SetCellSize()) is not supported and will result in a crash.
+

         @param pos
             The first row to delete.
         @param numRows
         @param pos
             The first row to delete.
         @param numRows


@@ -1004,170 +1712,1207 @@ public:
 
 
 
 
 
 

-/**
-    @class wxGrid
-
-    wxGrid and its related classes are used for displaying and editing tabular
-    data.
-    They provide a rich set of features for display, editing, and interacting
-    with a variety of data sources. For simple applications, and to help you
-    get started, wxGrid is the only class you need to refer to directly. It
-    will set up default instances of the other classes and manage them for you.
-    For more complex applications you can derive your own classes for custom
-    grid views, grid data tables, cell editors and renderers. The @ref
-    overview_grid "wxGrid overview" has examples of simple and more complex applications,
-    explains the relationship between the various grid classes and has a
-    summary of the keyboard shortcuts and mouse functions provided by wxGrid.
-
-    wxGrid has been greatly expanded and redesigned for wxWidgets 2.2 onwards.
-    The new grid classes are reasonably backward-compatible but there are some
-    exceptions. There are also easier ways of doing many things compared to the
-    previous implementation.
+enum wxGridTableRequest
+{
+    wxGRIDTABLE_REQUEST_VIEW_GET_VALUES = 2000,
+    wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES,
+    wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
+    wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
+    wxGRIDTABLE_NOTIFY_ROWS_DELETED,
+    wxGRIDTABLE_NOTIFY_COLS_INSERTED,
+    wxGRIDTABLE_NOTIFY_COLS_APPENDED,
+    wxGRIDTABLE_NOTIFY_COLS_DELETED
+};

 
 

-    A wxGridTableBase class holds the actual data to be displayed by a wxGrid
-    class. One or more wxGrid classes may act as a view for one table class.
-    The default table class is called wxGridStringTable and holds an array of
-    strings. An instance of such a class is created by wxGrid::CreateGrid.

 
 

-    wxGridCellRenderer is the abstract base class for rendereing contents in a
-    cell. The following renderers are predefined:
-     - wxGridCellStringRenderer,
-     - wxGridCellBoolRenderer,
-     - wxGridCellFloatRenderer,
-     - wxGridCellNumberRenderer.
-    The look of a cell can be further defined using wxGridCellAttr. An object
-    of this type may be returned by wxGridTableBase::GetAttr.
+/**
+   @class wxGridTableMessage

 
 

-    wxGridCellEditor is the abstract base class for editing the value of a
-    cell. The following editors are predefined:
-     - wxGridCellTextEditor
-     - wxGridCellBoolEditor
-     - wxGridCellChoiceEditor
-     - wxGridCellNumberEditor.
+   A simple class used to pass messages from the table to the grid.

 
     @library{wxadv}
     @category{grid}
 
     @library{wxadv}
     @category{grid}

-
-    @see @ref overview_grid "wxGrid overview"

 */
 */

-class wxGrid : public wxScrolledWindow
+class wxGridTableMessage

 {
 public:
 {
 public:

-    /**
-        Different selection modes supported by the grid.
-     */
-    enum wxGridSelectionModes
-    {
-        /**
-            The default selection mode allowing selection of the individual
-            cells as well as of the entire rows and columns.
-         */
-        wxGridSelectCells,
-
-        /**
-            The selection mode allowing the selection of the entire rows only.
+    wxGridTableMessage();
+    wxGridTableMessage( wxGridTableBase *table, int id,
+                        int comInt1 = -1,
+                        int comInt2 = -1 );
+
+    void SetTableObject( wxGridTableBase *table );
+    wxGridTableBase * GetTableObject() const;
+    void SetId( int id );
+    int  GetId();
+    void SetCommandInt( int comInt1 );
+    int  GetCommandInt();
+    void SetCommandInt2( int comInt2 );
+    int  GetCommandInt2();
+};

 
 

-            The user won't be able to select any cells or columns in this mode.
-         */
-        wxGridSelectRows,

 
 

-        /**
-            The selection mode allowing the selection of the entire columns only.

 
 

-            The user won't be able to select any cells or rows in this mode.
-         */
-        wxGridSelectColumns
-    };
+/**
+   @class wxGridStringTable

 
 

-    /**
+   Simplest type of data table for a grid for small tables of strings
+   that are stored in memory
+*/
+class wxGridStringTable : public wxGridTableBase
+{
+public:
+    wxGridStringTable();
+    wxGridStringTable( int numRows, int numCols );
+
+    // these are pure virtual in wxGridTableBase
+    virtual int GetNumberRows();
+    virtual int GetNumberCols();
+    virtual wxString GetValue( int row, int col );
+    virtual void SetValue( int row, int col, const wxString& value );
+
+    // overridden functions from wxGridTableBase
+    void Clear();
+    bool InsertRows( size_t pos = 0, size_t numRows = 1 );
+    bool AppendRows( size_t numRows = 1 );
+    bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
+    bool InsertCols( size_t pos = 0, size_t numCols = 1 );
+    bool AppendCols( size_t numCols = 1 );
+    bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
+
+    void SetRowLabelValue( int row, const wxString& );
+    void SetColLabelValue( int col, const wxString& );
+    wxString GetRowLabelValue( int row );
+    wxString GetColLabelValue( int col );
+};
+
+
+
+
+
+
+/**
+    @class wxGridSizesInfo
+
+    wxGridSizesInfo stores information about sizes of all wxGrid rows or
+    columns.
+
+    It assumes that most of the rows or columns (which are both called elements
+    here as the difference between them doesn't matter at this class level)
+    have the default size and so stores it separately. And it uses a wxHashMap
+    to store the sizes of all elements which have the non-default size.
+
+    This structure is particularly useful for serializing the sizes of all
+    wxGrid elements at once.
+
+    @library{wxadv}
+    @category{grid}
+ */
+struct wxGridSizesInfo
+{
+    /**
+        Default constructor.
+
+        m_sizeDefault and m_customSizes must be initialized later.
+     */
+    wxGridSizesInfo();
+
+    /**
+        Constructor.
+
+        This constructor is used by wxGrid::GetRowSizes() and GetColSizes()
+        methods. User code will usually use the default constructor instead.
+
+        @param defSize
+            The default element size.
+        @param allSizes
+            Array containing the sizes of @em all elements, including those
+            which have the default size.
+     */
+    wxGridSizesInfo(int defSize, const wxArrayInt& allSizes);
+
+    /**
+        Get the element size.
+
+        @param pos
+            The index of the element.
+        @return
+            The size for this element, using m_customSizes if @a pos is in it
+            or m_sizeDefault otherwise.
+     */
+    int GetSize(unsigned pos) const;
+
+
+    /// Default size
+    int m_sizeDefault;
+
+    /**
+        Map with element indices as keys and their sizes as values.
+
+        This map only contains the elements with non-default size.
+     */
+    wxUnsignedToIntHashMap m_customSizes;
+};
+
+
+
+/**
+    Rendering styles supported by wxGrid::Render() method.
+
+    @since 2.9.4
+ */
+enum wxGridRenderStyle
+{
+    /// Draw grid row header labels.
+    wxGRID_DRAW_ROWS_HEADER = 0x001,
+
+    /// Draw grid column header labels.
+    wxGRID_DRAW_COLS_HEADER = 0x002,
+
+    /// Draw grid cell border lines.
+    wxGRID_DRAW_CELL_LINES = 0x004,
+
+    /**
+        Draw a bounding rectangle around the rendered cell area.
+
+        Useful where row or column headers are not drawn or where there is
+        multi row or column cell clipping and therefore no cell border at
+        the rendered outer boundary.
+    */
+    wxGRID_DRAW_BOX_RECT = 0x008,
+
+    /**
+        Draw the grid cell selection highlight if a selection is present.
+
+        At present the highlight colour drawn depends on whether the grid
+        window loses focus before drawing begins.
+    */
+    wxGRID_DRAW_SELECTION = 0x010,
+
+    /**
+        The default render style.
+
+        Includes all except wxGRID_DRAW_SELECTION.
+     */
+    wxGRID_DRAW_DEFAULT = wxGRID_DRAW_ROWS_HEADER |
+                          wxGRID_DRAW_COLS_HEADER |
+                          wxGRID_DRAW_CELL_LINES |
+                          wxGRID_DRAW_BOX_RECT
+};
+
+
+
+/**
+    @class wxGrid
+
+    wxGrid and its related classes are used for displaying and editing tabular
+    data. They provide a rich set of features for display, editing, and
+    interacting with a variety of data sources. For simple applications, and to
+    help you get started, wxGrid is the only class you need to refer to
+    directly. It will set up default instances of the other classes and manage
+    them for you. For more complex applications you can derive your own classes
+    for custom grid views, grid data tables, cell editors and renderers. The
+    @ref overview_grid has examples of simple and more complex applications,
+    explains the relationship between the various grid classes and has a
+    summary of the keyboard shortcuts and mouse functions provided by wxGrid.
+
+    A wxGridTableBase class holds the actual data to be displayed by a wxGrid
+    class. One or more wxGrid classes may act as a view for one table class.
+    The default table class is called wxGridStringTable and holds an array of
+    strings. An instance of such a class is created by CreateGrid().
+
+    wxGridCellRenderer is the abstract base class for rendering contents in a
+    cell. The following renderers are predefined:
+
+    - wxGridCellBoolRenderer
+    - wxGridCellFloatRenderer
+    - wxGridCellNumberRenderer
+    - wxGridCellStringRenderer
+
+    The look of a cell can be further defined using wxGridCellAttr. An object
+    of this type may be returned by wxGridTableBase::GetAttr().
+
+    wxGridCellEditor is the abstract base class for editing the value of a
+    cell. The following editors are predefined:
+
+    - wxGridCellBoolEditor
+    - wxGridCellChoiceEditor
+    - wxGridCellFloatEditor
+    - wxGridCellNumberEditor
+    - wxGridCellTextEditor
+
+    Please see wxGridEvent, wxGridSizeEvent, wxGridRangeSelectEvent, and
+    wxGridEditorCreatedEvent for the documentation of all event types you can
+    use with wxGrid.
+
+    @library{wxadv}
+    @category{grid}
+
+    @see @ref overview_grid, wxGridUpdateLocker
+*/
+class wxGrid : public wxScrolledWindow
+{
+public:
+
+    /**
+        Different selection modes supported by the grid.
+     */
+    enum wxGridSelectionModes
+    {
+        /**
+            The default selection mode allowing selection of the individual
+            cells as well as of the entire rows and columns.
+         */
+        wxGridSelectCells,
+
+        /**
+            The selection mode allowing the selection of the entire rows only.
+
+            The user won't be able to select any cells or columns in this mode.
+         */
+        wxGridSelectRows,
+
+        /**
+            The selection mode allowing the selection of the entire columns only.
+
+            The user won't be able to select any cells or rows in this mode.
+         */
+        wxGridSelectColumns,
+
+        /**
+            The selection mode allowing the user to select either the entire
+            columns or the entire rows but not individual cells nor blocks.
+
+            Notice that while this constant is defined as @code
+            wxGridSelectColumns | wxGridSelectRows @endcode this doesn't mean
+            that all the other combinations are valid -- at least currently
+            they are not.
+
+            @since 2.9.1
+         */
+        wxGridSelectRowsOrColumns
+    };
+
+    /**
+        Return values for GetCellSize().
+
+        @since 2.9.1
+     */
+    enum CellSpan
+    {
+        /// This cell is inside a span covered by another cell.
+        CellSpan_Inside = -1,
+
+        /// This is a normal, non-spanning cell.
+        CellSpan_None = 0,
+
+        /// This cell spans several physical wxGrid cells.
+        CellSpan_Main
+    };
+
+    /**
+        Constants defining different support built-in TAB handling behaviours.
+
+        The elements of this enum determine what happens when TAB is pressed
+        when the cursor is in the rightmost column (or Shift-TAB is pressed
+        when the cursor is in the leftmost one).
+
+        @see SetTabBehaviour(), @c wxEVT_GRID_TABBING
+
+        @since 2.9.5
+     */
+    enum TabBehaviour
+    {
+        /// Do nothing, this is default.
+        Tab_Stop,
+
+        /// Move to the beginning of the next (or the end of the previous) row.
+        Tab_Wrap,
+
+        /// Move to the next (or the previous) control after the grid.
+        Tab_Leave
+    };
+
+    /**
+        @name Constructors and Initialization
+     */
+    //@{
+
+    /**

         Default constructor.
 
         Default constructor.
 

-        You must call Create() to really create the grid window and also call
-        CreateGrid() or SetTable() to initialize the grid contents.
-     */
-    wxGrid();
+        You must call Create() to really create the grid window and also call
+        CreateGrid() or SetTable() to initialize the grid contents.
+     */
+    wxGrid();
+    /**
+        Constructor creating the grid window.
+
+        You must call either CreateGrid() or SetTable() to initialize the grid
+        contents before using it.
+    */
+    wxGrid(wxWindow* parent, wxWindowID id,
+           const wxPoint& pos = wxDefaultPosition,
+           const wxSize& size = wxDefaultSize,
+           long style = wxWANTS_CHARS,
+           const wxString& name = wxGridNameStr);
+
+    /**
+        Destructor.
+
+        This will also destroy the associated grid table unless you passed a
+        table object to the grid and specified that the grid should not take
+        ownership of the table (see SetTable()).
+    */
+    virtual ~wxGrid();
+
+    /**
+        Creates the grid window for an object initialized using the default
+        constructor.
+
+        You must call either CreateGrid() or SetTable() to initialize the grid
+        contents before using it.
+     */
+    bool Create(wxWindow* parent, wxWindowID id,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = wxWANTS_CHARS,
+                const wxString& name = wxGridNameStr);
+
+    /**
+        Creates a grid with the specified initial number of rows and columns.
+
+        Call this directly after the grid constructor. When you use this
+        function wxGrid will create and manage a simple table of string values
+        for you. All of the grid data will be stored in memory.
+
+        For applications with more complex data types or relationships, or for
+        dealing with very large datasets, you should derive your own grid table
+        class and pass a table object to the grid with SetTable().
+    */
+    bool CreateGrid(int numRows, int numCols,
+                    wxGridSelectionModes selmode = wxGridSelectCells);
+
+    /**
+        Passes a pointer to a custom grid table to be used by the grid.
+
+        This should be called after the grid constructor and before using the
+        grid object. If @a takeOwnership is set to @true then the table will be
+        deleted by the wxGrid destructor.
+
+        Use this function instead of CreateGrid() when your application
+        involves complex or non-string data or data sets that are too large to
+        fit wholly in memory.
+    */
+    bool SetTable(wxGridTableBase* table, bool takeOwnership = false,
+                  wxGridSelectionModes selmode = wxGridSelectCells);
+
+    /**
+       Receive and handle a message from the table.
+    */
+    bool ProcessTableMessage(wxGridTableMessage& msg);
+
+    //@}
+
+
+    /**
+        @name Grid Line Formatting
+     */
+    //@{
+
+    /**
+        Turns the drawing of grid lines on or off.
+    */
+    void EnableGridLines(bool enable = true);
+
+    /**
+        Returns the pen used for vertical grid lines.
+
+        This virtual function may be overridden in derived classes in order to
+        change the appearance of individual grid lines for the given column
+        @a col.
+
+        See GetRowGridLinePen() for an example.
+    */
+    virtual wxPen GetColGridLinePen(int col);
+
+    /**
+        Returns the pen used for grid lines.
+
+        This virtual function may be overridden in derived classes in order to
+        change the appearance of grid lines. Note that currently the pen width
+        must be 1.
+
+        @see GetColGridLinePen(), GetRowGridLinePen()
+    */
+    virtual wxPen GetDefaultGridLinePen();
+
+    /**
+        Returns the colour used for grid lines.
+
+        @see GetDefaultGridLinePen()
+    */
+    wxColour GetGridLineColour() const;
+
+    /**
+        Returns the pen used for horizontal grid lines.
+
+        This virtual function may be overridden in derived classes in order to
+        change the appearance of individual grid line for the given @a row.
+
+        Example:
+        @code
+        // in a grid displaying music notation, use a solid black pen between
+        // octaves (C0=row 127, C1=row 115 etc.)
+        wxPen MidiGrid::GetRowGridLinePen(int row)
+        {
+            if ( row % 12 == 7 )
+                return wxPen(*wxBLACK, 1, wxSOLID);
+            else
+                return GetDefaultGridLinePen();
+        }
+        @endcode
+    */
+    virtual wxPen GetRowGridLinePen(int row);
+
+    /**
+        Returns @true if drawing of grid lines is turned on, @false otherwise.
+    */
+    bool GridLinesEnabled() const;
+
+    /**
+        Sets the colour used to draw grid lines.
+    */
+    void SetGridLineColour(const wxColour& colour);
+
+    //@}
+
+
+    /**
+        @name Label Values and Formatting
+     */
+    //@{
+
+    /**
+        Sets the arguments to the current column label alignment values.
+
+        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+        or @c wxALIGN_RIGHT.
+
+        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+        @c wxALIGN_BOTTOM.
+    */
+    void GetColLabelAlignment(int* horiz, int* vert) const;
+
+    /**
+        Returns the orientation of the column labels (either @c wxHORIZONTAL or
+        @c wxVERTICAL).
+    */
+    int GetColLabelTextOrientation() const;
+
+    /**
+        Returns the specified column label.
+
+        The default grid table class provides column labels of the form
+        A,B...Z,AA,AB...ZZ,AAA... If you are using a custom grid table you can
+        override wxGridTableBase::GetColLabelValue() to provide your own
+        labels.
+    */
+    wxString GetColLabelValue(int col) const;
+
+    /**
+        Returns the colour used for the background of row and column labels.
+    */
+    wxColour GetLabelBackgroundColour() const;
+
+    /**
+        Returns the font used for row and column labels.
+    */
+    wxFont GetLabelFont() const;
+
+    /**
+        Returns the colour used for row and column label text.
+    */
+    wxColour GetLabelTextColour() const;
+
+    /**
+        Returns the alignment used for row labels.
+
+        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+        or @c wxALIGN_RIGHT.
+
+        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+        @c wxALIGN_BOTTOM.
+    */
+    void GetRowLabelAlignment(int* horiz, int* vert) const;
+
+    /**
+        Returns the specified row label.
+
+        The default grid table class provides numeric row labels. If you are
+        using a custom grid table you can override
+        wxGridTableBase::GetRowLabelValue() to provide your own labels.
+    */
+    wxString GetRowLabelValue(int row) const;
+
+    /**
+        Hides the column labels by calling SetColLabelSize() with a size of 0.
+        Show labels again by calling that method with a width greater than 0.
+    */
+    void HideColLabels();
+
+    /**
+        Hides the row labels by calling SetRowLabelSize() with a size of 0.
+
+        The labels can be shown again by calling SetRowLabelSize() with a width
+        greater than 0.
+    */
+    void HideRowLabels();
+
+    /**
+        Sets the horizontal and vertical alignment of column label text.
+
+        Horizontal alignment should be one of @c wxALIGN_LEFT,
+        @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
+        of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+    */
+    void SetColLabelAlignment(int horiz, int vert);
+
+    /**
+        Sets the orientation of the column labels (either @c wxHORIZONTAL or
+        @c wxVERTICAL).
+    */
+    void SetColLabelTextOrientation(int textOrientation);
+
+    /**
+        Set the value for the given column label.
+
+        If you are using a custom grid table you must override
+        wxGridTableBase::SetColLabelValue() for this to have any effect.
+    */
+    void SetColLabelValue(int col, const wxString& value);
+
+    /**
+        Sets the background colour for row and column labels.
+    */
+    void SetLabelBackgroundColour(const wxColour& colour);
+
+    /**
+        Sets the font for row and column labels.
+    */
+    void SetLabelFont(const wxFont& font);
+
+    /**
+        Sets the colour for row and column label text.
+    */
+    void SetLabelTextColour(const wxColour& colour);
+
+    /**
+        Sets the horizontal and vertical alignment of row label text.
+
+        Horizontal alignment should be one of @c wxALIGN_LEFT,
+        @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
+        of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+    */
+    void SetRowLabelAlignment(int horiz, int vert);
+
+    /**
+        Sets the value for the given row label.
+
+        If you are using a derived grid table you must override
+        wxGridTableBase::SetRowLabelValue() for this to have any effect.
+    */
+    void SetRowLabelValue(int row, const wxString& value);
+
+    /**
+        Call this in order to make the column labels use a native look by using
+        wxRendererNative::DrawHeaderButton() internally.
+
+        There is no equivalent method for drawing row columns as there is not
+        native look for that. This option is useful when using wxGrid for
+        displaying tables and not as a spread-sheet.
+
+        @see UseNativeColHeader()
+    */
+    void SetUseNativeColLabels(bool native = true);
+
+    /**
+        Enable the use of native header window for column labels.
+
+        If this function is called with @true argument, a wxHeaderCtrl is used
+        instead to display the column labels instead of drawing them in wxGrid
+        code itself. This has the advantage of making the grid look and feel
+        perfectly the same as native applications (using SetUseNativeColLabels()
+        the grid can be made to look more natively but it still doesn't feel
+        natively, notably the column resizing and dragging still works slightly
+        differently as it is implemented in wxWidgets itself) but results in
+        different behaviour for column and row headers, for which there is no
+        equivalent function, and, most importantly, is unsuitable for grids
+        with huge numbers of columns as wxHeaderCtrl doesn't support virtual
+        mode. Because of this, by default the grid does not use the native
+        header control but you should call this function to enable it if you
+        are using the grid to display tabular data and don't have thousands of
+        columns in it.
+
+        Another difference between the default behaviour and the native header
+        behaviour is that the latter provides the user with a context menu
+        (which appears on right clicking the header) allowing to rearrange the
+        grid columns if CanDragColMove() returns @true. If you want to prevent
+        this from happening for some reason, you need to define a handler for
+        @c wxEVT_GRID_LABEL_RIGHT_CLICK event which simply does nothing (in
+        particular doesn't skip the event) as this will prevent the default
+        right click handling from working.
+
+        Also note that currently @c wxEVT_GRID_LABEL_RIGHT_DCLICK event is not
+        generated for the column labels if the native columns header is used
+        (but this limitation could possibly be lifted in the future).
+     */
+    void UseNativeColHeader(bool native = true);
+
+    //@}
+
+
+    /**
+        @name Cell Formatting
+
+        Note that wxGridCellAttr can be used alternatively to most of these
+        methods. See the "Attributes Management" of wxGridTableBase.
+     */
+    //@{
+
+    /**
+        Sets the arguments to the horizontal and vertical text alignment values
+        for the grid cell at the specified location.
+
+        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+        or @c wxALIGN_RIGHT.
+
+        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+        @c wxALIGN_BOTTOM.
+    */
+    void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
+
+    /**
+        Returns the background colour of the cell at the specified location.
+    */
+    wxColour GetCellBackgroundColour(int row, int col) const;
+
+    /**
+        Returns the font for text in the grid cell at the specified location.
+    */
+    wxFont GetCellFont(int row, int col) const;
+
+    /**
+        Returns the text colour for the grid cell at the specified location.
+    */
+    wxColour GetCellTextColour(int row, int col) const;
+
+    /**
+        Returns the default cell alignment.
+
+        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+        or @c wxALIGN_RIGHT.
+
+        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+        @c wxALIGN_BOTTOM.
+
+        @see SetDefaultCellAlignment()
+    */
+    void GetDefaultCellAlignment(int* horiz, int* vert) const;
+
+    /**
+        Returns the current default background colour for grid cells.
+    */
+    wxColour GetDefaultCellBackgroundColour() const;
+
+    /**
+        Returns the current default font for grid cell text.
+    */
+    wxFont GetDefaultCellFont() const;
+
+    /**
+        Returns the current default colour for grid cell text.
+    */
+    wxColour GetDefaultCellTextColour() const;
+
+    /**
+        Sets the horizontal and vertical alignment for grid cell text at the
+        specified location.
+
+        Horizontal alignment should be one of @c wxALIGN_LEFT,
+        @c wxALIGN_CENTRE or @c wxALIGN_RIGHT.
+
+        Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
+        or @c wxALIGN_BOTTOM.
+    */
+    void SetCellAlignment(int row, int col, int horiz, int vert);
+    /**
+        Sets the horizontal and vertical alignment for grid cell text at the
+        specified location.
+
+        Horizontal alignment should be one of @c wxALIGN_LEFT,
+        @c wxALIGN_CENTRE or @c wxALIGN_RIGHT.
+
+        Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
+        or @c wxALIGN_BOTTOM.
+    */
+    void SetCellAlignment(int align, int row, int col);
+
+    /**
+        Set the background colour for the given cell or all cells by default.
+    */
+    void SetCellBackgroundColour(int row, int col, const wxColour& colour);
+
+    /**
+        Sets the font for text in the grid cell at the specified location.
+    */
+    void SetCellFont(int row, int col, const wxFont& font);
+
+    /**
+        Sets the text colour for the given cell.
+    */
+    void SetCellTextColour(int row, int col, const wxColour& colour);
+    /**
+        Sets the text colour for the given cell.
+    */
+    void SetCellTextColour(const wxColour& val, int row, int col);
+    /**
+        Sets the text colour for all cells by default.
+    */
+    void SetCellTextColour(const wxColour& colour);
+
+    /**
+        Sets the default horizontal and vertical alignment for grid cell text.
+
+        Horizontal alignment should be one of @c wxALIGN_LEFT,
+        @c wxALIGN_CENTRE or @c wxALIGN_RIGHT. Vertical alignment should be one
+        of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+    */
+    void SetDefaultCellAlignment(int horiz, int vert);
+
+    /**
+        Sets the default background colour for grid cells.
+    */
+    void SetDefaultCellBackgroundColour(const wxColour& colour);
+
+    /**
+        Sets the default font to be used for grid cell text.
+    */
+    void SetDefaultCellFont(const wxFont& font);
+
+    /**
+        Sets the current default colour for grid cell text.
+    */
+    void SetDefaultCellTextColour(const wxColour& colour);
+
+    //@}
+
+
+    /**
+        @name Cell Values, Editors, and Renderers
+
+        Note that wxGridCellAttr can be used alternatively to most of these
+        methods. See the "Attributes Management" of wxGridTableBase.
+     */
+    //@{
+
+    /**
+        Returns @true if the in-place edit control for the current grid cell
+        can be used and @false otherwise.
+
+        This function always returns @false for the read-only cells.
+    */
+    bool CanEnableCellControl() const;
+
+    /**
+        Disables in-place editing of grid cells.
+
+        Equivalent to calling EnableCellEditControl(@false).
+    */
+    void DisableCellEditControl();
+
+    /**
+        Enables or disables in-place editing of grid cell data.
+
+        The grid will issue either a @c wxEVT_GRID_EDITOR_SHOWN or
+        @c wxEVT_GRID_EDITOR_HIDDEN event.
+    */
+    void EnableCellEditControl(bool enable = true);
+
+    /**
+        Makes the grid globally editable or read-only.
+
+        If the edit argument is @false this function sets the whole grid as
+        read-only. If the argument is @true the grid is set to the default
+        state where cells may be editable. In the default state you can set
+        single grid cells and whole rows and columns to be editable or
+        read-only via wxGridCellAttr::SetReadOnly(). For single cells you
+        can also use the shortcut function SetReadOnly().
+
+        For more information about controlling grid cell attributes see the
+        wxGridCellAttr class and the @ref overview_grid.
+    */
+    void EnableEditing(bool edit);
+
+    /**
+        Returns a pointer to the editor for the cell at the specified location.
+
+        See wxGridCellEditor and the @ref overview_grid for more information
+        about cell editors and renderers.
+
+        The caller must call DecRef() on the returned pointer.
+    */
+    wxGridCellEditor* GetCellEditor(int row, int col) const;
+
+    /**
+        Returns a pointer to the renderer for the grid cell at the specified
+        location.
+
+        See wxGridCellRenderer and the @ref overview_grid for more information
+        about cell editors and renderers.
+
+        The caller must call DecRef() on the returned pointer.
+    */
+    wxGridCellRenderer* GetCellRenderer(int row, int col) const;
+
+    /**
+        Returns the string contained in the cell at the specified location.
+
+        For simple applications where a grid object automatically uses a
+        default grid table of string values you use this function together with
+        SetCellValue() to access cell values. For more complex applications
+        where you have derived your own grid table class that contains various
+        data types (e.g. numeric, boolean or user-defined custom types) then
+        you only use this function for those cells that contain string values.
+
+        See wxGridTableBase::CanGetValueAs() and the @ref overview_grid for
+        more information.
+    */
+    wxString GetCellValue(int row, int col) const;
+    /**
+        Returns the string contained in the cell at the specified location.
+
+        For simple applications where a grid object automatically uses a
+        default grid table of string values you use this function together with
+        SetCellValue() to access cell values. For more complex applications
+        where you have derived your own grid table class that contains various
+        data types (e.g. numeric, boolean or user-defined custom types) then
+        you only use this function for those cells that contain string values.
+
+        See wxGridTableBase::CanGetValueAs() and the @ref overview_grid for
+        more information.
+    */
+    wxString GetCellValue(const wxGridCellCoords& coords) const;
+
+    /**
+        Returns a pointer to the current default grid cell editor.
+
+        See wxGridCellEditor and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    wxGridCellEditor* GetDefaultEditor() const;
+
+    /**
+        Returns the default editor for the specified cell.
+
+        The base class version returns the editor appropriate for the current
+        cell type but this method may be overridden in the derived classes to
+        use custom editors for some cells by default.
+
+        Notice that the same may be achieved in a usually simpler way by
+        associating a custom editor with the given cell or cells.
+
+        The caller must call DecRef() on the returned pointer.
+    */
+    virtual wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
+    /**
+        Returns the default editor for the specified cell.
+
+        The base class version returns the editor appropriate for the current
+        cell type but this method may be overridden in the derived classes to
+        use custom editors for some cells by default.
+
+        Notice that the same may be achieved in a usually simpler way by
+        associating a custom editor with the given cell or cells.
+
+        The caller must call DecRef() on the returned pointer.
+    */
+    wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const;
+
+    /**
+        Returns the default editor for the cells containing values of the given
+        type.
+
+        The base class version returns the editor which was associated with the
+        specified @a typeName when it was registered RegisterDataType() but
+        this function may be overridden to return something different. This
+        allows to override an editor used for one of the standard types.
+
+        The caller must call DecRef() on the returned pointer.
+    */
+    virtual wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
+
+    /**
+        Returns a pointer to the current default grid cell renderer.
+
+        See wxGridCellRenderer and the @ref overview_grid for more information
+        about cell editors and renderers.
+
+        The caller must call DecRef() on the returned pointer.
+    */
+    wxGridCellRenderer* GetDefaultRenderer() const;
+
+    /**
+        Returns the default renderer for the given cell.
+
+        The base class version returns the renderer appropriate for the current
+        cell type but this method may be overridden in the derived classes to
+        use custom renderers for some cells by default.
+
+        The caller must call DecRef() on the returned pointer.
+    */
+    virtual wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
+
+    /**
+        Returns the default renderer for the cell containing values of the
+        given type.
+
+        @see GetDefaultEditorForType()
+    */
+    virtual wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
+
+    /**
+        Hides the in-place cell edit control.
+    */
+    void HideCellEditControl();
+
+    /**
+        Returns @true if the in-place edit control is currently enabled.
+    */
+    bool IsCellEditControlEnabled() const;
+
+    /**
+        Returns @true if the current cell is read-only.
+
+        @see SetReadOnly(), IsReadOnly()
+    */
+    bool IsCurrentCellReadOnly() const;
+
+    /**
+        Returns @false if the whole grid has been set as read-only or @true
+        otherwise.
+
+        See EnableEditing() for more information about controlling the editing
+        status of grid cells.
+    */
+    bool IsEditable() const;
+
+    /**
+        Returns @true if the cell at the specified location can't be edited.
+
+        @see SetReadOnly(), IsCurrentCellReadOnly()
+    */
+    bool IsReadOnly(int row, int col) const;
+
+    /**
+        Register a new data type.
+
+        The data types allow to naturally associate specific renderers and
+        editors to the cells containing values of the given type. For example,
+        the grid automatically registers a data type with the name
+        @c wxGRID_VALUE_STRING which uses wxGridCellStringRenderer and
+        wxGridCellTextEditor as its renderer and editor respectively -- this is
+        the data type used by all the cells of the default wxGridStringTable,
+        so this renderer and editor are used by default for all grid cells.
+
+        However if a custom table returns @c wxGRID_VALUE_BOOL from its
+        wxGridTableBase::GetTypeName() method, then wxGridCellBoolRenderer and
+        wxGridCellBoolEditor are used for it because the grid also registers a
+        boolean data type with this name.
+
+        And as this mechanism is completely generic, you may register your own
+        data types using your own custom renderers and editors. Just remember
+        that the table must identify a cell as being of the given type for them
+        to be used for this cell.
+
+        @param typeName
+            Name of the new type. May be any string, but if the type name is
+            the same as the name of an already registered type, including one
+            of the standard ones (which are @c wxGRID_VALUE_STRING, @c
+            wxGRID_VALUE_BOOL, @c wxGRID_VALUE_NUMBER, @c wxGRID_VALUE_FLOAT
+            and @c wxGRID_VALUE_CHOICE), then the new registration information
+            replaces the previously used renderer and editor.
+        @param renderer
+            The renderer to use for the cells of this type. Its ownership is
+            taken by the grid, i.e. it will call DecRef() on this pointer when
+            it doesn't need it any longer.
+        @param editor
+            The editor to use for the cells of this type. Its ownership is also
+            taken by the grid.
+    */
+    void RegisterDataType(const wxString& typeName,
+                          wxGridCellRenderer* renderer,
+                          wxGridCellEditor* editor);
+
+    /**
+        Sets the value of the current grid cell to the current in-place edit
+        control value.
+
+        This is called automatically when the grid cursor moves from the
+        current cell to a new cell. It is also a good idea to call this
+        function when closing a grid since any edits to the final cell location
+        will not be saved otherwise.
+    */
+    void SaveEditControlValue();
+
+    /**
+        Sets the editor for the grid cell at the specified location.
+
+        The grid will take ownership of the pointer.
+
+        See wxGridCellEditor and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    void SetCellEditor(int row, int col, wxGridCellEditor* editor);
+
+    /**
+        Sets the renderer for the grid cell at the specified location.
+
+        The grid will take ownership of the pointer.
+
+        See wxGridCellRenderer and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    void SetCellRenderer(int row, int col, wxGridCellRenderer* renderer);
+
+    /**
+        Sets the string value for the cell at the specified location.
+
+        For simple applications where a grid object automatically uses a
+        default grid table of string values you use this function together with
+        GetCellValue() to access cell values. For more complex applications
+        where you have derived your own grid table class that contains various
+        data types (e.g. numeric, boolean or user-defined custom types) then
+        you only use this function for those cells that contain string values.
+
+        See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
+        more information.
+    */
+    void SetCellValue(int row, int col, const wxString& s);
+    /**
+        Sets the string value for the cell at the specified location.
+
+        For simple applications where a grid object automatically uses a
+        default grid table of string values you use this function together with
+        GetCellValue() to access cell values. For more complex applications
+        where you have derived your own grid table class that contains various
+        data types (e.g. numeric, boolean or user-defined custom types) then
+        you only use this function for those cells that contain string values.
+
+        See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
+        more information.
+    */
+    void SetCellValue(const wxGridCellCoords& coords, const wxString& s);
+    /**
+        @deprecated Please use SetCellValue(int,int,const wxString&) or
+                    SetCellValue(const wxGridCellCoords&,const wxString&)
+                    instead.
+
+        Sets the string value for the cell at the specified location.
+
+        For simple applications where a grid object automatically uses a
+        default grid table of string values you use this function together with
+        GetCellValue() to access cell values. For more complex applications
+        where you have derived your own grid table class that contains various
+        data types (e.g. numeric, boolean or user-defined custom types) then
+        you only use this function for those cells that contain string values.
+
+        See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
+        more information.
+    */
+    void SetCellValue(const wxString& val, int row, int col);

 
     /**
 
     /**

-        Constructor creating the grid window.
+        Sets the specified column to display boolean values.

 
 

-        You must call either CreateGrid() or SetTable() to initialize the grid
-        contents before using it.
+        @see SetColFormatCustom()

     */
     */

-    wxGrid(wxWindow* parent,
-           wxWindowID id,
-           const wxPoint& pos = wxDefaultPosition,
-           const wxSize& size = wxDefaultSize,
-           long style = wxWANTS_CHARS,
-           const wxString& name = wxGridNameStr);
+    void SetColFormatBool(int col);

 
     /**
 
     /**

-        Creates the grid window for an object initialized using the default
-        constructor.
+        Sets the specified column to display data in a custom format.

 
 

-        You must call either CreateGrid() or SetTable() to initialize the grid
-        contents before using it.
-     */
-    bool Create(wxWindow* parent,
-                wxWindowID id,
-                const wxPoint& pos = wxDefaultPosition,
-                const wxSize& size = wxDefaultSize,
-                long style = wxWANTS_CHARS,
-                const wxString& name = wxGridNameStr);
+        This method provides an alternative to defining a custom grid table
+        which would return @a typeName from its GetTypeName() method for the
+        cells in this column: while it doesn't really change the type of the
+        cells in this column, it does associate the renderer and editor used
+        for the cells of the specified type with them.
+
+        See the @ref overview_grid for more information on working with custom
+        data types.
+    */
+    void SetColFormatCustom(int col, const wxString& typeName);

 
     /**
 
     /**

-        Destructor.
+        Sets the specified column to display floating point values with the
+        given width and precision.

 
 

-        This will also destroy the associated grid table unless you passed a
-        table object to the grid and specified that the grid should not take
-        ownership of the table (see wxGrid::SetTable).
+        @see SetColFormatCustom()

     */
     */

-    virtual ~wxGrid();
+    void SetColFormatFloat(int col, int width = -1, int precision = -1);

 
     /**
 
     /**

-        Appends one or more new columns to the right of the grid.
-
-        The @a updateLabels argument is not used at present. If you are using a
-        derived grid table class you will need to override
-        wxGridTableBase::AppendCols. See InsertCols() for further information.
+        Sets the specified column to display integer values.

 
 

-        @return @true on success or @false if appending columns failed.
+        @see SetColFormatCustom()

     */
     */

-    bool AppendCols(int numCols = 1, bool updateLabels = true);
+    void SetColFormatNumber(int col);

 
     /**
 
     /**

-        Appends one or more new rows to the bottom of the grid.
+        Sets the default editor for grid cells.

 
 

-        The @a updateLabels argument is not used at present. If you are using a
-        derived grid table class you will need to override
-        wxGridTableBase::AppendRows. See InsertRows() for further information.
+        The grid will take ownership of the pointer.

 
 

-        @return @true on success or @false if appending rows failed.
+        See wxGridCellEditor and the @ref overview_grid for more information
+        about cell editors and renderers.

     */
     */

-    bool AppendRows(int numRows = 1, bool updateLabels = true);
+    void SetDefaultEditor(wxGridCellEditor* editor);

 
     /**
 
     /**

-        Return @true if the horizontal grid lines stop at the last column
-        boundary or @false if they continue to the end of the window.
+        Sets the default renderer for grid cells.

 
 

-        The default is to clip grid lines.
+        The grid will take ownership of the pointer.

 
 

-        @see ClipHorzGridLines(), AreVertGridLinesClipped()
-     */
-    bool AreHorzGridLinesClipped() const;
+        See wxGridCellRenderer and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    void SetDefaultRenderer(wxGridCellRenderer* renderer);

 
     /**
 
     /**

-        Return @true if the vertical grid lines stop at the last row
-        boundary or @false if they continue to the end of the window.
+        Makes the cell at the specified location read-only or editable.

 
 

-        The default is to clip grid lines.
+        @see IsReadOnly()
+    */
+    void SetReadOnly(int row, int col, bool isReadOnly = true);

 
 

-        @see ClipVertGridLines(), AreHorzGridLinesClipped()
+    /**
+        Displays the in-place cell edit control for the current cell.
+    */
+    void ShowCellEditControl();
+
+    //@}
+
+
+    /**
+        @name Column and Row Sizes
+
+        @see @ref overview_grid_resizing

      */
      */

-    bool AreVertGridLinesClipped() const;
+    //@{

 
     /**
 
     /**

-        Automatically sets the height and width of all rows and columns to fit their
-        contents.
+        Automatically sets the height and width of all rows and columns to fit
+        their contents.

     */
     void AutoSize();
 
     */
     void AutoSize();
 


@@ -1177,23 +2922,23 @@ public:
     void AutoSizeColLabelSize(int col);
 
     /**
     void AutoSizeColLabelSize(int col);
 
     /**

-        Automatically sizes the column to fit its contents. If setAsMin is @true the
-        calculated width will
-        also be set as the minimal width for the column.
+        Automatically sizes the column to fit its contents. If @a setAsMin is
+        @true the calculated width will also be set as the minimal width for
+        the column.

     */
     void AutoSizeColumn(int col, bool setAsMin = true);
 
     /**
     */
     void AutoSizeColumn(int col, bool setAsMin = true);
 
     /**

-        Automatically sizes all columns to fit their contents. If setAsMin is @true the
-        calculated widths will
-        also be set as the minimal widths for the columns.
+        Automatically sizes all columns to fit their contents. If @a setAsMin
+        is @true the calculated widths will also be set as the minimal widths
+        for the columns.

     */
     void AutoSizeColumns(bool setAsMin = true);
 
     /**
     */
     void AutoSizeColumns(bool setAsMin = true);
 
     /**

-        Automatically sizes the row to fit its contents. If setAsMin is @true the
-        calculated height will
-        also be set as the minimal height for the row.
+        Automatically sizes the row to fit its contents. If @a setAsMin is
+        @true the calculated height will also be set as the minimal height for
+        the row.

     */
     void AutoSizeRow(int row, bool setAsMin = true);
 
     */
     void AutoSizeRow(int row, bool setAsMin = true);
 


@@ -1203,534 +2948,536 @@ public:
     void AutoSizeRowLabelSize(int col);
 
     /**
     void AutoSizeRowLabelSize(int col);
 
     /**

-        Automatically sizes all rows to fit their contents. If setAsMin is @true the
-        calculated heights will
-        also be set as the minimal heights for the rows.
+        Automatically sizes all rows to fit their contents. If @a setAsMin is
+        @true the calculated heights will also be set as the minimal heights
+        for the rows.

     */
     void AutoSizeRows(bool setAsMin = true);
 
     /**
     */
     void AutoSizeRows(bool setAsMin = true);
 
     /**

-        Increments the grid's batch count.
+        Returns @true if the cell value can overflow.

 
 

-        When the count is greater than zero repainting of the grid is
-        suppressed. Each call to BeginBatch must be matched by a later call to
-        EndBatch(). Code that does a lot of grid modification can be enclosed
-        between BeginBatch and EndBatch calls to avoid screen flicker. The
-        final EndBatch will cause the grid to be repainted.
+        A cell can overflow if the next cell in the row is empty.
+    */
+    bool GetCellOverflow(int row, int col) const;

 
 

-        Notice that you should use wxGridUpdateLocker which ensures that there
-        is always a matching EndBatch() call for this BeginBatch() if possible
-        instead of calling this method directly.
+    /**
+        Returns the current height of the column labels.

     */
     */

-    void BeginBatch();
+    int GetColLabelSize() const;

 
     /**
 
     /**

-        Convert grid cell coordinates to grid window pixel coordinates.
+        Returns the minimal width to which a column may be resized.

 
 

-        This function returns the rectangle that encloses the block of cells
-        limited by @a topLeft and @a bottomRight cell in device coords and
-        clipped to the client size of the grid window.
+        Use SetColMinimalAcceptableWidth() to change this value globally or
+        SetColMinimalWidth() to do it for individual columns.

 
 

-        @see CellToRect()
+        @see GetRowMinimalAcceptableHeight()

     */
     */

-    wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
-                             const wxGridCellCoords& bottomRight) const;
+    int GetColMinimalAcceptableWidth() const;

 
     /**
 
     /**

-        Returns @true if columns can be moved by dragging with the mouse.
-
-        Columns can be moved by dragging on their labels.
+        Returns the width of the specified column.

     */
     */

-    bool CanDragColMove() const;
+    int GetColSize(int col) const;

 
     /**
 
     /**

-        Returns @true if columns can be resized by dragging with the mouse.
+        Returns @true if the specified column is not currently hidden.
+     */
+    bool IsColShown(int col) const;

 
 

-        Columns can be resized by dragging the edges of their labels. If grid
-        line dragging is enabled they can also be resized by dragging the right
-        edge of the column in the grid cell area (see
-        wxGrid::EnableDragGridSize).
+    /**
+        Returns @true if the cells can overflow by default.

     */
     */

-    bool CanDragColSize() const;
+    bool GetDefaultCellOverflow() const;

 
     /**
 
     /**

-        Return @true if the dragging of grid lines to resize rows and columns
-        is enabled or @false otherwise.
+        Returns the default height for column labels.

     */
     */

-    bool CanDragGridSize() const;
+    int GetDefaultColLabelSize() const;

 
     /**
 
     /**

-        Returns @true if rows can be resized by dragging with the mouse.
-
-        Rows can be resized by dragging the edges of their labels. If grid line
-        dragging is enabled they can also be resized by dragging the lower edge
-        of the row in the grid cell area (see wxGrid::EnableDragGridSize).
+        Returns the current default width for grid columns.

     */
     */

-    bool CanDragRowSize() const;
+    int GetDefaultColSize() const;

 
     /**
 
     /**

-        Returns @true if the in-place edit control for the current grid cell
-        can be used and @false otherwise.
-
-        This function always returns @false for the read-only cells.
+        Returns the default width for the row labels.

     */
     */

-    bool CanEnableCellControl() const;
+    int GetDefaultRowLabelSize() const;

 
 

-    //@{

     /**
     /**

-        Return the rectangle corresponding to the grid cell's size and position
-        in logical coordinates.
-
-        @see BlockToDeviceRect()
+        Returns the current default height for grid rows.

     */
     */

-    wxRect CellToRect(int row, int col) const;
-    const wxRect CellToRect(const wxGridCellCoords& coords) const;
-
-    //@}
+    int GetDefaultRowSize() const;

 
     /**
 
     /**

-        Clears all data in the underlying grid table and repaints the grid.
+        Returns the minimal size to which rows can be resized.

 
 

-        The table is not deleted by this function. If you are using a derived
-        table class then you need to override wxGridTableBase::Clear() for this
-        function to have any effect.
+        Use SetRowMinimalAcceptableHeight() to change this value globally or
+        SetRowMinimalHeight() to do it for individual cells.
+
+        @see GetColMinimalAcceptableWidth()

     */
     */

-    void ClearGrid();
+    int GetRowMinimalAcceptableHeight() const;

 
     /**
 
     /**

-        Deselects all cells that are currently selected.
+        Returns the current width of the row labels.

     */
     */

-    void ClearSelection();
+    int GetRowLabelSize() const;

 
     /**
 
     /**

-        Change whether the horizontal grid lines are clipped by the end of the
-        last column.
-
-        By default the grid lines are not drawn beyond the end of the last
-        column but after calling this function with @a clip set to @false they
-        will be drawn across the entire grid window.
+        Returns the height of the specified row.
+    */
+    int GetRowSize(int row) const;

 
 

-        @see AreHorzGridLinesClipped(), ClipVertGridLines()
+    /**
+        Returns @true if the specified row is not currently hidden.

      */
      */

-    void ClipHorzGridLines(bool clip);
+    bool IsRowShown(int row) const;

 
     /**
 
     /**

-        Change whether the vertical grid lines are clipped by the end of the
-        last row.
+        Sets the overflow permission of the cell.
+    */
+    void SetCellOverflow(int row, int col, bool allow);

 
 

-        By default the grid lines are not drawn beyond the end of the last
-        row but after calling this function with @a clip set to @false they
-        will be drawn across the entire grid window.
+    /**
+        Sets the height of the column labels.

 
 

-        @see AreVertzGridLinesClipped(), ClipHorzGridLines()
-     */
-    void ClipVertzGridLines(bool clip);
+        If @a height equals to @c wxGRID_AUTOSIZE then height is calculated
+        automatically so that no label is truncated. Note that this could be
+        slow for a large table.
+    */
+    void SetColLabelSize(int height);

 
     /**
 
     /**

-        Creates a grid with the specified initial number of rows and columns.
+        Sets the minimal @a width to which the user can resize columns.

 
 

-        Call this directly after the grid constructor. When you use this
-        function wxGrid will create and manage a simple table of string values
-        for you. All of the grid data will be stored in memory.
-        For applications with more complex data types or relationships, or for
-        dealing with very large datasets, you should derive your own grid table
-        class and pass a table object to the grid with SetTable().
+        @see GetColMinimalAcceptableWidth()

     */
     */

-    bool CreateGrid(int numRows, int numCols,
-                    wxGridSelectionModes selmode = wxGridSelectCells);
+    void SetColMinimalAcceptableWidth(int width);

 
     /**
 
     /**

-        Deletes one or more columns from a grid starting at the specified
-        position.
+        Sets the minimal @a width for the specified column @a col.

 
 

-        The @a updateLabels argument is not used at present. If you are using a
-        derived grid table class you will need to override
-        wxGridTableBase::DeleteCols. See InsertCols() for further information.
+        It is usually best to call this method during grid creation as calling
+        it later will not resize the column to the given minimal width even if
+        it is currently narrower than it.

 
 

-        @return @true on success or @false if deleting columns failed.
+        @a width must be greater than the minimal acceptable column width as
+        returned by GetColMinimalAcceptableWidth().

     */
     */

-    bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);
+    void SetColMinimalWidth(int col, int width);

 
     /**
 
     /**

-        Deletes one or more rows from a grid starting at the specified position.
-
-        The @a updateLabels argument is not used at present. If you are using a
-        derived grid table class you will need to override
-        wxGridTableBase::DeleteRows. See InsertRows() for further information.
+        Sets the width of the specified column.

 
 

-        @return @true on success or @false if appending rows failed.
+        @param col
+            The column index.
+        @param width
+            The new column width in pixels, 0 to hide the column or -1 to fit
+            the column width to its label width.

     */
     */

-    bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
+    void SetColSize(int col, int width);

 
     /**
 
     /**

-        Disables in-place editing of grid cells.
+        Hides the specified column.

 
 

-        Equivalent to calling EnableCellEditControl(@false).
-    */
-    void DisableCellEditControl();
+        To show the column later you need to call SetColSize() with non-0
+        width or ShowCol() to restore the previous column width.
+
+        If the column is already hidden, this method doesn't do anything.
+
+        @param col
+            The column index.
+     */
+    void HideCol(int col);

 
     /**
 
     /**

-        Disables column moving by dragging with the mouse.
+        Shows the previously hidden column by resizing it to non-0 size.

 
 

-        Equivalent to passing @false to EnableDragColMove().
+        The column is shown again with the same width that it had before
+        HideCol() call.
+
+        If the column is currently shown, this method doesn't do anything.
+
+        @see HideCol(), SetColSize()
+     */
+    void ShowCol(int col);
+
+
+    /**
+        Sets the default overflow permission of the cells.

     */
     */

-    void DisableDragColMove();
+    void SetDefaultCellOverflow( bool allow );

 
     /**
 
     /**

-        Disables column sizing by dragging with the mouse.
+        Sets the default width for columns in the grid.

 
 

-        Equivalent to passing @false to EnableDragColSize().
+        This will only affect columns subsequently added to the grid unless
+        @a resizeExistingCols is @true.
+
+        If @a width is less than GetColMinimalAcceptableWidth(), then the
+        minimal acceptable width is used instead of it.

     */
     */

-    void DisableDragColSize();
+    void SetDefaultColSize(int width, bool resizeExistingCols = false);

 
     /**
 
     /**

-        Disable mouse dragging of grid lines to resize rows and columns.
+        Sets the default height for rows in the grid.
+
+        This will only affect rows subsequently added to the grid unless
+        @a resizeExistingRows is @true.

 
 

-        Equivalent to passing @false to EnableDragGridSize()
+        If @a height is less than GetRowMinimalAcceptableHeight(), then the
+        minimal acceptable height is used instead of it.

     */
     */

-    void DisableDragGridSize();
+    void SetDefaultRowSize(int height, bool resizeExistingRows = false);

 
     /**
 
     /**

-        Disables row sizing by dragging with the mouse.
+        Sets the width of the row labels.

 
 

-        Equivalent to passing @false to EnableDragRowSize().
+        If @a width equals @c wxGRID_AUTOSIZE then width is calculated
+        automatically so that no label is truncated. Note that this could be
+        slow for a large table.

     */
     */

-    void DisableDragRowSize();
+    void SetRowLabelSize(int width);

 
     /**
 
     /**

-        Enables or disables in-place editing of grid cell data.
+        Sets the minimal row @a height used by default.

 
 

-        The grid will issue either a wxEVT_GRID_EDITOR_SHOWN or
-        wxEVT_GRID_EDITOR_HIDDEN event.
+        See SetColMinimalAcceptableWidth() for more information.

     */
     */

-    void EnableCellEditControl(bool enable = true);
+    void SetRowMinimalAcceptableHeight(int height);

 
     /**
 
     /**

-        Enables or disables column moving by dragging with the mouse.
-    */
-    void EnableDragColMove(bool enable = true);
+        Sets the minimal @a height for the specified @a row.

 
 

-    /**
-        Enables or disables column sizing by dragging with the mouse.
+        See SetColMinimalWidth() for more information.

     */
     */

-    void EnableDragColSize(bool enable = true);
+    void SetRowMinimalHeight(int row, int height);

 
     /**
 
     /**

-        Enables or disables row and column resizing by dragging gridlines with the
-        mouse.
-    */
-    void EnableDragGridSize(bool enable = true);
+        Sets the height of the specified row.

 
 

-    /**
-        Enables or disables row sizing by dragging with the mouse.
+        See SetColSize() for more information.

     */
     */

-    void EnableDragRowSize(bool enable = true);
+    void SetRowSize(int row, int height);

 
     /**
 
     /**

-        Makes the grid globally editable or read-only.
+        Hides the specified row.

 
 

-        If the edit argument is @false this function sets the whole grid as
-        read-only. If the argument is @true the grid is set to the default
-        state where cells may be editable. In the default state you can set
-        single grid cells and whole rows and columns to be editable or
-        read-only via wxGridCellAttribute::SetReadOnly. For single cells you
-        can also use the shortcut function SetReadOnly().
+        To show the row later you need to call SetRowSize() with non-0
+        width or ShowRow() to restore its original height.

 
 

-        For more information about controlling grid cell attributes see the
-        wxGridCellAttr cell attribute class and the
-        @ref overview_grid "wxGrid overview".
-    */
-    void EnableEditing(bool edit);
+        If the row is already hidden, this method doesn't do anything.

 
 

-    /**
-        Turns the drawing of grid lines on or off.
-    */
-    void EnableGridLines(bool enable = true);
+        @param col
+            The row index.
+     */
+    void HideRow(int col);

 
     /**
 
     /**

-        Decrements the grid's batch count.
+        Shows the previously hidden row.

 
 

-        When the count is greater than zero repainting of the grid is
-        suppressed. Each previous call to BeginBatch() must be matched by a
-        later call to EndBatch. Code that does a lot of grid modification can
-        be enclosed between BeginBatch and EndBatch calls to avoid screen
-        flicker. The final EndBatch will cause the grid to be repainted.
+        The row is shown again with the same height that it had before
+        HideRow() call.

 
 

-        @see wxGridUpdateLocker
-    */
-    void EndBatch();
+        If the row is currently shown, this method doesn't do anything.

 
 

-    /**
-        Overridden wxWindow method.
-    */
-    virtual void Fit();
+        @see HideRow(), SetRowSize()
+     */
+    void ShowRow(int col);

 
     /**
 
     /**

-        Causes immediate repainting of the grid.
+        Get size information for all columns at once.

 
 

-        Use this instead of the usual wxWindow::Refresh.
-    */
-    void ForceRefresh();
+        This method is useful when the information about all column widths
+        needs to be saved. The widths can be later restored using
+        SetColSizes().
+
+        @sa wxGridSizesInfo, GetRowSizes()
+     */
+    wxGridSizesInfo GetColSizes() const;

 
     /**
 
     /**

-        Returns the number of times that BeginBatch() has been called
-        without (yet) matching calls to EndBatch(). While
-        the grid's batch count is greater than zero the display will not be updated.
-    */
-    int GetBatchCount();
+        Get size information for all row at once.
+
+        @sa wxGridSizesInfo, GetColSizes()
+     */
+    wxGridSizesInfo GetRowSizes() const;

 
     /**
 
     /**

-        Sets the arguments to the horizontal and vertical text alignment values
-        for the grid cell at the specified location.
+        Restore all columns sizes.

 
 

-        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
-        or @c wxALIGN_RIGHT.
+        This is usually called with wxGridSizesInfo object previously returned
+        by GetColSizes().

 
 

-        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
-        @c wxALIGN_BOTTOM.
-    */
-    void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
+        @sa SetRowSizes()
+     */
+    void SetColSizes(const wxGridSizesInfo& sizeInfo);

 
     /**
 
     /**

-        Returns the background colour of the cell at the specified location.
-    */
-    wxColour GetCellBackgroundColour(int row, int col) const;
+        Restore all rows sizes.
+
+        @sa SetColSizes()
+     */
+    void SetRowSizes(const wxGridSizesInfo& sizeInfo);

 
     /**
 
     /**

-        Returns a pointer to the editor for the cell at the specified location.
+        Set the size of the cell.

 
 

-        See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+        Specifying a value of more than 1 in @a num_rows or @a num_cols will
+        make the cell at (@a row, @a col) span the block of the specified size,
+        covering the other cells which would be normally shown in it. Passing 1
+        for both arguments resets the cell to normal appearance.

 
 

-        The caller must call DecRef() on the returned pointer.
-    */
-    wxGridCellEditor* GetCellEditor(int row, int col) const;
+        @see GetCellSize()

 
 

-    /**
-        Returns the font for text in the grid cell at the specified location.
-    */
-    wxFont GetCellFont(int row, int col) const;
+        @param row
+            The row of the cell.
+        @param col
+            The column of the cell.
+        @param num_rows
+            Number of rows to be occupied by this cell, must be >= 1.
+        @param num_cols
+            Number of columns to be occupied by this cell, must be >= 1.
+     */
+    void SetCellSize(int row, int col, int num_rows, int num_cols);

 
     /**
 
     /**

-        Returns a pointer to the renderer for the grid cell at the specified
-        location.
+        Get the size of the cell in number of cells covered by it.

 
 

-        See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+        For normal cells, the function fills both @a num_rows and @a num_cols
+        with 1 and returns CellSpan_None. For cells which span multiple cells, i.e.
+        for which SetCellSize() had been called, the returned values are the
+        same ones as were passed to SetCellSize() call and the function return
+        value is CellSpan_Main.

 
 

-        The caller must call DecRef() on the returned pointer.
-    */
-    wxGridCellRenderer* GetCellRenderer(int row, int col) const;
+        More unexpectedly, perhaps, the returned values may be @em negative for
+        the cells which are inside a span covered by a cell occupying multiple
+        rows or columns. They correspond to the offset of the main cell of the
+        span from the cell passed to this functions and the function returns
+        CellSpan_Inside value to indicate this.

 
 

-    /**
-        Returns the text colour for the grid cell at the specified location.
-    */
-    wxColour GetCellTextColour(int row, int col) const;
+        As an example, consider a 3*3 grid with the cell (1, 1) (the one in the
+        middle) having a span of 2 rows and 2 columns, i.e. the grid looks like
+        @code
+            +----+----+----+
+            |    |    |    |
+            +----+----+----+
+            |    |         |
+            +----+         |
+            |    |         |
+            +----+----+----+
+        @endcode
+        Then the function returns 2 and 2 in @a num_rows and @a num_cols for
+        the cell (1, 1) itself and -1 and -1 for the cell (2, 2) as well as -1
+        and 0 for the cell (2, 1).
+
+        @param row
+            The row of the cell.
+        @param col
+            The column of the cell.
+        @param num_rows
+            Pointer to variable receiving the number of rows, must not be @NULL.
+        @param num_cols
+            Pointer to variable receiving the number of columns, must not be
+            @NULL.
+        @return
+            The kind of this cell span (the return value is new in wxWidgets
+            2.9.1, this function was void in previous wxWidgets versions).
+     */
+    CellSpan GetCellSize( int row, int col, int *num_rows, int *num_cols ) const;

 
 

-    //@{

     /**
     /**

-        Returns the string contained in the cell at the specified location.
+        Get the number of rows and columns allocated for this cell.

 
 

-        For simple applications where a grid object automatically uses a
-        default grid table of string values you use this function together with
-        SetCellValue() to access cell values. For more complex applications
-        where you have derived your own grid table class that contains various
-        data types (e.g. numeric, boolean or user-defined custom types) then
-        you only use this function for those cells that contain string values.
+        This overload doesn't return a CellSpan value but the values returned
+        may still be negative, see GetCellSize(int, int, int *, int *) for
+        details.
+     */
+    wxSize GetCellSize(const wxGridCellCoords& coords);

 
 

-        See wxGridTableBase::CanGetValueAs and the @ref overview_grid "wxGrid overview"
-        for more information.
-    */
-    wxString GetCellValue(int row, int col) const;
-    const wxString  GetCellValue(const wxGridCellCoords& coords) const;

     //@}
 
     //@}
 

-    /**
-        Returns the column ID of the specified column position.
-    */
-    int GetColAt(int colPos) const;

 
     /**
 
     /**

-        Returns the pen used for vertical grid lines.
-
-        This virtual function may be overridden in derived classes in order to
-        change the appearance of individual grid lines for the given column @e
-        col.
-
-        See GetRowGridLinePen() for an example.
-    */
-    virtual wxPen GetColGridLinePen(int col);
+        @name User-Resizing and Dragging

 
 

-    /**
-        Sets the arguments to the current column label alignment values.
+        Functions controlling various interactive mouse operations.

 
 

-        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
-        or @c wxALIGN_RIGHT.
+        By default, columns and rows can be resized by dragging the edges of
+        their labels (this can be disabled using DisableDragColSize() and
+        DisableDragRowSize() methods). And if grid line dragging is enabled with
+        EnableDragGridSize() they can also be resized by dragging the right or
+        bottom edge of the grid cells.

 
 

-        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
-        @c wxALIGN_BOTTOM.
-    */
-    void GetColLabelAlignment(int* horiz, int* vert) const;
+        Columns can also be moved to interactively change their order but this
+        needs to be explicitly enabled with EnableDragColMove().
+     */
+    //@{

 
     /**
 
     /**

-        Returns the current height of the column labels.
+        Return @true if the dragging of cells is enabled or @false otherwise.

     */
     */

-    int GetColLabelSize() const;
+    bool CanDragCell() const;

 
     /**
 
     /**

-        Returns the specified column label.
+        Returns @true if columns can be moved by dragging with the mouse.

 
 

-        The default grid table class provides column labels of the form
-        A,B...Z,AA,AB...ZZ,AAA... If you are using a custom grid table you can
-        override wxGridTableBase::GetColLabelValue to provide your own labels.
+        Columns can be moved by dragging on their labels.

     */
     */

-    wxString GetColLabelValue(int col) const;
+    bool CanDragColMove() const;

 
     /**
 
     /**

-        Returns the minimal width to which a column may be resized.
+        Returns @true if the given column can be resized by dragging with the
+        mouse.

 
 

-        Use SetColMinimalAcceptableWidth() to change this value globally or
-        SetColMinimalWidth() to do it for individual columns.
+        This function returns @true if resizing the columns interactively is
+        globally enabled, i.e. if DisableDragColSize() hadn't been called, and
+        if this column wasn't explicitly marked as non-resizable with
+        DisableColResize().

     */
     */

-    int GetColMinimalAcceptableWidth() const;
+    bool CanDragColSize(int col) const;

 
     /**
 
     /**

-        Returns the position of the specified column.
+        Return @true if the dragging of grid lines to resize rows and columns
+        is enabled or @false otherwise.

     */
     */

-    int GetColPos(int colID) const;
+    bool CanDragGridSize() const;

 
     /**
 
     /**

-        Returns the width of the specified column.
+        Returns @true if the given row can be resized by dragging with the
+        mouse.
+
+        This is the same as CanDragColSize() but for rows.

     */
     */

-    int GetColSize(int col) const;
+    bool CanDragRowSize(int row) const;

 
     /**
 
     /**

-        Returns the default cell alignment.
+        Disable interactive resizing of the specified column.

 
 

-        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
-        or @c wxALIGN_RIGHT.
+        This method allows to disable resizing of an individual column in a
+        grid where the columns are otherwise resizable (which is the case by
+        default).

 
 

-        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
-        @c wxALIGN_BOTTOM.
+        Notice that currently there is no way to make some columns resizable in
+        a grid where columns can't be resized by default as there doesn't seem
+        to be any need for this in practice. There is also no way to make the
+        column marked as fixed using this method resizable again because it is
+        supposed that fixed columns are used for static parts of the grid and
+        so should remain fixed during the entire grid lifetime.

 
 

-        @see SetDefaultCellAlignment()
-    */
-    void GetDefaultCellAlignment(int* horiz, int* vert) const;
+        Also notice that disabling interactive column resizing will not prevent
+        the program from changing the column size.

 
 

-    /**
-        Returns the current default background colour for grid cells.
-    */
-    wxColour GetDefaultCellBackgroundColour() const;
+        @see EnableDragColSize()
+     */
+    void DisableColResize(int col);

 
     /**
 
     /**

-        Returns the current default font for grid cell text.
-    */
-    wxFont GetDefaultCellFont() const;
+        Disable interactive resizing of the specified row.

 
 

-    /**
-        Returns the current default colour for grid cell text.
-    */
-    wxColour GetDefaultCellTextColour() const;
+        This is the same as DisableColResize() but for rows.

 
 

-    /**
-        Returns the default height for column labels.
-    */
-    int GetDefaultColLabelSize() const;
+        @see EnableDragRowSize()
+     */
+    void DisableRowResize(int row);

 
     /**
 
     /**

-        Returns the current default width for grid columns.
+        Disables column moving by dragging with the mouse.
+
+        Equivalent to passing @false to EnableDragColMove().

     */
     */

-    int GetDefaultColSize() const;
+    void DisableDragColMove();

 
     /**
 
     /**

-        Returns a pointer to the current default grid cell editor.
+        Disables column sizing by dragging with the mouse.

 
 

-        See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+        Equivalent to passing @false to EnableDragColSize().

     */
     */

-    wxGridCellEditor* GetDefaultEditor() const;
+    void DisableDragColSize();

 
 

-    //@{

     /**
     /**

-        Returns the default editor for the specified cell.
-
-        The base class version returns the editor appropriate for the current
-        cell type but this method may be overridden in the derived classes to
-        use custom editors for some cells by default.
-
-        Notice that the same may be usually achieved in simpler way by
-        associating a custom editor with the given cell or cells.
+        Disable mouse dragging of grid lines to resize rows and columns.

 
 

-        The caller must call DecRef() on the returned pointer.
+        Equivalent to passing @false to EnableDragGridSize()

     */
     */

-    virtual wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
-    wxGridCellEditor*  GetDefaultEditorForCell(const wxGridCellCoords& c) const;
-    //@}
+    void DisableDragGridSize();

 
     /**
 
     /**

-        Returns the default editor for the cells containing values of the given
-        type.
+        Disables row sizing by dragging with the mouse.

 
 

-        The base class version returns the editor which was associated with the
-        specified @a typeName when it was registered RegisterDataType() but
-        this function may be overridden to return something different. This
-        allows to override an editor used for one of the standard types.
+        Equivalent to passing @false to EnableDragRowSize().
+    */
+    void DisableDragRowSize();

 
 

-        The caller must call DecRef() on the returned pointer.
+    /**
+        Enables or disables cell dragging with the mouse.

     */
     */

-    virtual wxGridCellEditor *
-    GetDefaultEditorForType(const wxString& typeName) const;
+    void EnableDragCell(bool enable = true);

 
     /**
 
     /**

-        Returns the pen used for grid lines.
+        Enables or disables column moving by dragging with the mouse.
+    */
+    void EnableDragColMove(bool enable = true);

 
 

-        This virtual function may be overridden in derived classes in order to
-        change the appearance of grid lines. Note that currently the pen width
-        must be 1.
+    /**
+        Enables or disables column sizing by dragging with the mouse.

 
 

-        @see GetColGridLinePen(), GetRowGridLinePen()
+        @see DisableColResize()

     */
     */

-    virtual wxPen GetDefaultGridLinePen();
+    void EnableDragColSize(bool enable = true);

 
     /**
 
     /**

-        Returns a pointer to the current default grid cell renderer.
+        Enables or disables row and column resizing by dragging gridlines with
+        the mouse.
+    */
+    void EnableDragGridSize(bool enable = true);

 
 

-        See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+    /**
+        Enables or disables row sizing by dragging with the mouse.

 
 

-        The caller must call DecRef() on the returned pointer.
+        @see DisableRowResize()

     */
     */

-    wxGridCellRenderer* GetDefaultRenderer() const;
+    void EnableDragRowSize(bool enable = true);

 
     /**
 
     /**

-        Returns the default renderer for the given cell.
+        Returns the column ID of the specified column position.
+    */
+    int GetColAt(int colPos) const;

 
 

-        The base class version returns the renderer appropriate for the current
-        cell type but this method may be overridden in the derived classes to
-        use custom renderers for some cells by default.
+    /**
+        Returns the position of the specified column.
+    */
+    int GetColPos(int colID) const;

 
 

-        The caller must call DecRef() on the returned pointer.
+    /**
+        Sets the position of the specified column.

     */
     */

-    virtual wxGridCellRenderer *GetDefaultRendererForCell(int row, int col) const;
+    void SetColPos(int colID, int newPos);

 
     /**
 
     /**

-        Returns the default renderer for the cell containing values of the
-        given type.
+        Sets the positions of all columns at once.

 
 

-        @see GetDefaultEditorForType()
+        This method takes an array containing the indices of the columns in
+        their display order, i.e. uses the same convention as
+        wxHeaderCtrl::SetColumnsOrder().

     */
     */

-    virtual wxGridCellRenderer *
-    GetDefaultRendererForType(const wxString& typeName) const;
+    void SetColumnsOrder(const wxArrayInt& order);

 
     /**
 
     /**

-        Returns the default width for the row labels.
+        Resets the position of the columns to the default.

     */
     */

-    int GetDefaultRowLabelSize() const;
+    void ResetColPos();
+
+    //@}
+

 
     /**
 
     /**

-        Returns the current default height for grid rows.
+        @name Cursor Movement

     */
     */

-    int GetDefaultRowSize() const;
+    //@{

 
     /**
         Returns the current grid cell column position.
 
     /**
         Returns the current grid cell column position.


@@ -1743,131 +3490,162 @@ public:
     int GetGridCursorRow() const;
 
     /**
     int GetGridCursorRow() const;
 
     /**

-        Returns the colour used for grid lines.
+        Make the given cell current and ensure it is visible.

 
 

-        @see GetDefaultGridLinePen()
-    */
-    wxColour GetGridLineColour() const;
+        This method is equivalent to calling MakeCellVisible() and
+        SetGridCursor() and so, as with the latter, a @c wxEVT_GRID_SELECT_CELL
+        event is generated by it and the selected cell doesn't change if the
+        event is vetoed.
+     */
+    void GoToCell(int row, int col);
+    /**
+        Make the given cell current and ensure it is visible.
+
+        This method is equivalent to calling MakeCellVisible() and
+        SetGridCursor() and so, as with the latter, a @c wxEVT_GRID_SELECT_CELL
+        event is generated by it and the selected cell doesn't change if the
+        event is vetoed.
+     */
+    void GoToCell(const wxGridCellCoords& coords);

 
     /**
 
     /**

-        Returns the colour used for the background of row and column labels.
+        Moves the grid cursor down by one row.
+
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    wxColour GetLabelBackgroundColour() const;
+    bool MoveCursorDown(bool expandSelection);

 
     /**
 
     /**

-        Returns the font used for row and column labels.
+        Moves the grid cursor down in the current column such that it skips to
+        the beginning or end of a block of non-empty cells.
+
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    wxFont GetLabelFont() const;
+    bool MoveCursorDownBlock(bool expandSelection);

 
     /**
 
     /**

-        Returns the colour used for row and column label text.
+        Moves the grid cursor left by one column.
+
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    wxColour GetLabelTextColour() const;
+    bool MoveCursorLeft(bool expandSelection);

 
     /**
 
     /**

-        Returns the total number of grid columns.
+        Moves the grid cursor left in the current row such that it skips to the
+        beginning or end of a block of non-empty cells.

 
 

-        This is the same as the number of columns in the underlying grid
-        table.
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    int GetNumberCols() const;
+    bool MoveCursorLeftBlock(bool expandSelection);

 
     /**
 
     /**

-        Returns the total number of grid rows.
+        Moves the grid cursor right by one column.

 
 

-        This is the same as the number of rows in the underlying grid table.
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    int GetNumberRows() const;
+    bool MoveCursorRight(bool expandSelection);

 
     /**
 
     /**

-        Returns the attribute for the given cell creating one if necessary.
-
-        If the cell already has an attribute, it is returned. Otherwise a new
-        attribute is created, associated with the cell and returned. In any
-        case the caller must call DecRef() on the returned pointer.
+        Moves the grid cursor right in the current row such that it skips to
+        the beginning or end of a block of non-empty cells.

 
 

-        This function may only be called if CanHaveAttributes() returns @true.
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
+    bool MoveCursorRightBlock(bool expandSelection);

 
     /**
 
     /**

-        Returns the pen used for horizontal grid lines.
-
-        This virtual function may be overridden in derived classes in order to
-        change the appearance of individual grid line for the given row @e row.
+        Moves the grid cursor up by one row.

 
 

-        Example:
-        @code
-           // in a grid displaying music notation, use a solid black pen between
-           // octaves (C0=row 127, C1=row 115 etc.)
-           wxPen MidiGrid::GetRowGridLinePen(int row)
-           {
-               if ( row % 12 == 7 )
-                  return wxPen(*wxBLACK, 1, wxSOLID);
-               else
-                  return GetDefaultGridLinePen();
-           }
-        @endcode
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    virtual wxPen GetRowGridLinePen(int row);
+    bool MoveCursorUp(bool expandSelection);

 
     /**
 
     /**

-        Returns the alignment used for row labels.
-
-        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
-        or @c wxALIGN_RIGHT.
+        Moves the grid cursor up in the current column such that it skips to
+        the beginning or end of a block of non-empty cells.

 
 

-        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
-        @c wxALIGN_BOTTOM.
+        If a block of cells was previously selected it will expand if the
+        argument is @true or be cleared if the argument is @false.

     */
     */

-    void GetRowLabelAlignment(int* horiz, int* vert) const;
+    bool MoveCursorUpBlock(bool expandSelection);

 
     /**
 
     /**

-        Returns the current width of the row labels.
+        Moves the grid cursor down by some number of rows so that the previous
+        bottom visible row becomes the top visible row.

     */
     */

-    int GetRowLabelSize() const;
+    bool MovePageDown();

 
     /**
 
     /**

-        Returns the specified row label.
-
-        The default grid table class provides numeric row labels. If you are
-        using a custom grid table you can override
-        wxGridTableBase::GetRowLabelValue to provide your own labels.
+        Moves the grid cursor up by some number of rows so that the previous
+        top visible row becomes the bottom visible row.

     */
     */

-    wxString GetRowLabelValue(int row) const;
+    bool MovePageUp();

 
     /**
 
     /**

-        Returns the minimal size to which rows can be resized.
+        Set the grid cursor to the specified cell.

 
 

-        Use SetRowMinimalAcceptableHeight() to change this value globally or
-        SetRowMinimalHeight() to do it for individual cells.
+        The grid cursor indicates the current cell and can be moved by the user
+        using the arrow keys or the mouse.

 
 

-        @see GetColMinimalAcceptableWidth()
-    */
-    int GetRowMinimalAcceptableHeight() const;
+        Calling this function generates a @c wxEVT_GRID_SELECT_CELL event and
+        if the event handler vetoes this event, the cursor is not moved.

 
 

+        This function doesn't make the target call visible, use GoToCell() to
+        do this.
+    */
+    void SetGridCursor(int row, int col);

     /**
     /**

-        Returns the height of the specified row.
+        Set the grid cursor to the specified cell.
+
+        The grid cursor indicates the current cell and can be moved by the user
+        using the arrow keys or the mouse.
+
+        Calling this function generates a @c wxEVT_GRID_SELECT_CELL event and
+        if the event handler vetoes this event, the cursor is not moved.
+
+        This function doesn't make the target call visible, use GoToCell() to
+        do this.

     */
     */

-    int GetRowSize(int row) const;
+    void SetGridCursor(const wxGridCellCoords& coords);

 
     /**
 
     /**

-        Returns the number of pixels per horizontal scroll increment.
+        Set the grid's behaviour when the user presses the TAB key.

 
 

-        The default is 15.
+        Pressing the TAB key moves the grid cursor right in the current row, if
+        there is a cell at the right and, similarly, Shift-TAB moves the cursor
+        to the left in the current row if it's not in the first column.

 
 

-        @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
+        What happens if the cursor can't be moved because it it's already at
+        the beginning or end of the row can be configured using this function,
+        see wxGrid::TabBehaviour documentation for the detailed description.
+
+        IF none of the standard behaviours is appropriate, you can always
+        handle @c wxEVT_GRID_TABBING event directly to implement a custom
+        TAB-handling logic.
+
+        @since 2.9.5

     */
     */

-    int GetScrollLineX() const;
+    void SetTabBehaviour(TabBehaviour behaviour);

 
 

-    /**
-        Returns the number of pixels per vertical scroll increment.
+    //@}

 
 

-        The default is 15.

 
 

-        @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
+    /**
+        @name User Selection
+     */
+    //@{
+
+    /**
+        Deselects all cells that are currently selected.

     */
     */

-    int GetScrollLineY() const;
+    void ClearSelection();

 
     /**
         Returns an array of individually selected cells.
 
     /**
         Returns an array of individually selected cells.


@@ -1909,169 +3687,52 @@ public:
     */
     wxArrayInt GetSelectedRows() const;
 
     */
     wxArrayInt GetSelectedRows() const;
 

-    /**
-        Access or update the selection fore/back colours
-    */
-    wxColour GetSelectionBackground() const;
-
-    /**
-        Returns an array of the bottom right corners of blocks of selected
-        cells.
-
-        Please see GetSelectedCells() for more information about the selection
-        representation in wxGrid.
-
-        @see GetSelectionBlockTopLeft()
-    */
-    wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
-
-    /**
-        Returns an array of the top left corners of blocks of selected cells.
-
-        Please see GetSelectedCells() for more information about the selection
-        representation in wxGrid.
-
-        @see GetSelectionBlockBottomRight()
-    */
-    wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
-
-    /**
-        Returns the colour used for drawing the selection foreground.
-    */
-    wxColour GetSelectionForeground() const;
-
-    /**
-        Returns the current selection mode.
-
-        @see SetSelectionMode().
-    */
-    wxGridSelectionModes GetSelectionMode() const;
-
-    /**
-        Returns a base pointer to the current table object.
-
-        The returned pointer is still owned by the grid.
-    */
-    wxGridTableBase *GetTable() const;
-
-    //@{
-    /**
-        Make the given cell current and ensure it is visible.
-
-        This method is equivalent to calling MakeCellVisible() and
-        SetGridCursor() and so, as with the latter, a wxEVT_GRID_SELECT_CELL
-        event is generated by it and the selected cell doesn't change if the
-        event is vetoed.
-     */
-    void GoToCell(int row, int col);
-    void GoToCell(const wxGridCellCoords& coords);
-    //@}
-
-    /**
-        Returns @true if drawing of grid lines is turned on, @false otherwise.
-    */
-    bool GridLinesEnabled() const;
-
-    /**
-        Hides the in-place cell edit control.
-    */
-    void HideCellEditControl();
-
-    /**
-        Hides the column labels by calling SetColLabelSize()
-        with a size of 0. Show labels again by calling that method with
-        a width greater than 0.
-    */
-    void HideColLabels();
-
-    /**
-        Hides the row labels by calling SetRowLabelSize() with a size of 0.
-
-        The labels can be shown again by calling SetRowLabelSize() with a width
-        greater than 0.
-    */
-    void HideRowLabels();
-
-    /**
-        Inserts one or more new columns into a grid with the first new column
-        at the specified position.
-
-        Notice that inserting the columns in the grid requires grid table
-        cooperation: when this method is called, grid object begins by
-        requesting the underlying grid table to insert new columns. If this is
-        successful the table notifies the grid and the grid updates the
-        display. For a default grid (one where you have called
-        wxGrid::CreateGrid) this process is automatic. If you are using a
-        custom grid table (specified with wxGrid::SetTable) then you must
-        override wxGridTableBase::InsertCols() in your derived table class.
-
-        @param pos
-            The position which the first newly inserted column will have.
-        @param numCols
-            The number of columns to insert.
-        @param updateLabels
-            Currently not used.
-        @return
-            @true if the columns were successfully inserted, @false if an error
-            occurred (most likely the table couldn't be updated).
+    /**
+        Returns the colour used for drawing the selection background.

     */
     */

-    bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true);
+    wxColour GetSelectionBackground() const;

 
     /**
 
     /**

-        Inserts one or more new rows into a grid with the first new row at the
-        specified position.
+        Returns an array of the bottom right corners of blocks of selected
+        cells.

 
 

-        Notice that you must implement wxGridTableBase::InsertRows() if you use
-        a grid with a custom table, please see InsertCols() for more
-        information.
+        Please see GetSelectedCells() for more information about the selection
+        representation in wxGrid.

 
 

-        @param pos
-            The position which the first newly inserted row will have.
-        @param numRows
-            The number of rows to insert.
-        @param updateLabels
-            Currently not used.
-        @return
-            @true if the rows were successfully inserted, @false if an error
-            occurred (most likely the table couldn't be updated).
+        @see GetSelectionBlockTopLeft()

     */
     */

-    bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true);
+    wxGridCellCoordsArray GetSelectionBlockBottomRight() const;

 
     /**
 
     /**

-        Returns @true if the in-place edit control is currently enabled.
+        Returns an array of the top left corners of blocks of selected cells.
+
+        Please see GetSelectedCells() for more information about the selection
+        representation in wxGrid.
+
+        @see GetSelectionBlockBottomRight()

     */
     */

-    bool IsCellEditControlEnabled() const;
+    wxGridCellCoordsArray GetSelectionBlockTopLeft() const;

 
     /**
 
     /**

-        Returns @true if the current cell is read-only.
-
-        @see SetReadOnly(), IsReadOnly()
+        Returns the colour used for drawing the selection foreground.

     */
     */

-    bool IsCurrentCellReadOnly() const;
+    wxColour GetSelectionForeground() const;

 
     /**
 
     /**

-        Returns @false if the whole grid has been set as read-only or @true
-        otherwise.
+        Returns the current selection mode.

 
 

-        See EnableEditing() for more information about controlling the editing
-        status of grid cells.
+        @see SetSelectionMode().

     */
     */

-    bool IsEditable() const;
+    wxGridSelectionModes GetSelectionMode() const;

 
 

-    //@{

     /**
     /**

-        Is this cell currently selected?
+        Returns @true if the given cell is selected.

     */
     bool IsInSelection(int row, int col) const;
     */
     bool IsInSelection(int row, int col) const;

-    bool IsInSelection(const wxGridCellCoords& coords) const;
-    //@}
-

     /**
     /**

-        Returns @true if the cell at the specified location can't be edited.
-
-        @see SetReadOnly(), IsCurrentCellReadOnly()
+        Returns @true if the given cell is selected.

     */
     */

-    bool IsReadOnly(int row, int col) const;
+    bool IsInSelection(const wxGridCellCoords& coords) const;

 
     /**
         Returns @true if there are currently any selected cells, rows, columns
 
     /**
         Returns @true if there are currently any selected cells, rows, columns


@@ -2079,493 +3740,551 @@ public:
     */
     bool IsSelection() const;
 
     */
     bool IsSelection() const;
 

-    //@{

     /**
     /**

-        Returns @true if a cell is either wholly or at least partially visible
-        in the grid window.
-
-        By default, the cell must be entirely visible for this function to
-        return true but if @a wholeCellVisible is @false, the function returns
-        @true even if the cell is only partially visible.
+        Selects all cells in the grid.

     */
     */

-    bool IsVisible(int row, int col, bool wholeCellVisible = true) const;
-    bool IsVisible(const wxGridCellCoords& coords,
-                   bool wholeCellVisible = true) const;
-    //@}
+    void SelectAll();

 
 

-    //@{

     /**
     /**

-        Brings the specified cell into the visible grid cell area with minimal
-        scrolling.
+        Selects a rectangular block of cells.

 
 

-        Does nothing if the cell is already visible.
+        If @a addToSelected is @false then any existing selection will be
+        deselected; if @true the column will be added to the existing
+        selection.

     */
     */

-    void MakeCellVisible(int row, int col);
-    void MakeCellVisible(const wxGridCellCoords& coords);
-    //@}
-
+    void SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
+                     bool addToSelected = false);

     /**
     /**

-        Moves the grid cursor down by one row.
+        Selects a rectangular block of cells.

 
 

-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
+        If @a addToSelected is @false then any existing selection will be
+        deselected; if @true the column will be added to the existing
+        selection.

     */
     */

-    bool MoveCursorDown(bool expandSelection);
+    void SelectBlock(const wxGridCellCoords& topLeft,
+                     const wxGridCellCoords& bottomRight,
+                     bool addToSelected = false);

 
     /**
 
     /**

-        Moves the grid cursor down in the current column such that it skips to
-        the beginning or end of a block of non-empty cells.
-
-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
-    */
-    bool MoveCursorDownBlock(bool expandSelection);
+        Selects the specified column.

 
 

-    /**
-        Moves the grid cursor left by one column.
+        If @a addToSelected is @false then any existing selection will be
+        deselected; if @true the column will be added to the existing
+        selection.

 
 

-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
+        This method won't select anything if the current selection mode is
+        wxGridSelectRows.

     */
     */

-    bool MoveCursorLeft(bool expandSelection);
+    void SelectCol(int col, bool addToSelected = false);

 
     /**
 
     /**

-        Moves the grid cursor left in the current row such that it skips to the
-        beginning or end of a block of non-empty cells.
+        Selects the specified row.

 
 

-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
+        If @a addToSelected is @false then any existing selection will be
+        deselected; if @true the row will be added to the existing selection.
+
+        This method won't select anything if the current selection mode is
+        wxGridSelectColumns.

     */
     */

-    bool MoveCursorLeftBlock(bool expandSelection);
+    void SelectRow(int row, bool addToSelected = false);

 
     /**
 
     /**

-        Moves the grid cursor right by one column.
-
-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
+        Set the colour to be used for drawing the selection background.

     */
     */

-    bool MoveCursorRight(bool expandSelection);
+    void SetSelectionBackground(const wxColour& c);

 
     /**
 
     /**

-        Moves the grid cursor right in the current row such that it skips to
-        the beginning or end of a block of non-empty cells.
-
-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
+        Set the colour to be used for drawing the selection foreground.

     */
     */

-    bool MoveCursorRightBlock(bool expandSelection);
+    void SetSelectionForeground(const wxColour& c);

 
     /**
 
     /**

-        Moves the grid cursor up by one row.
+        Set the selection behaviour of the grid.

 
 

-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
+        The existing selection is converted to conform to the new mode if
+        possible and discarded otherwise (e.g. any individual selected cells
+        are deselected if the new mode allows only the selection of the entire
+        rows or columns).

     */
     */

-    bool MoveCursorUp(bool expandSelection);
+    void SetSelectionMode(wxGridSelectionModes selmode);

 
 

-    /**
-        Moves the grid cursor up in the current column such that it skips to
-        the beginning or end of a block of non-empty cells.
+    //@}

 
 

-        If a block of cells was previously selected it will expand if the
-        argument is @true or be cleared if the argument is @false.
-    */
-    bool MoveCursorUpBlock(bool expandSelection);

 
     /**
 
     /**

-        Moves the grid cursor down by some number of rows so that the previous
-        bottom visible row becomes the top visible row.
-    */
-    bool MovePageDown();
+        @name Scrolling
+     */
+    //@{

 
     /**
 
     /**

-        Moves the grid cursor up by some number of rows so that the previous
-        top visible row becomes the bottom visible row.
+        Returns the number of pixels per horizontal scroll increment.
+
+        The default is 15.
+
+        @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()

     */
     */

-    bool MovePageUp();
+    int GetScrollLineX() const;

 
     /**
 
     /**

-        Register a new data type.
+        Returns the number of pixels per vertical scroll increment.

 
 

-        The data types allow to naturally associate specific renderers and
-        editors to the cells containing values of the given type. For example,
-        the grid automatically registers a data type with the name @c
-        wxGRID_VALUE_STRING which uses wxGridCellStringRenderer and
-        wxGridCellTextEditor as its renderer and editor respectively -- this is
-        the data type used by all the cells of the default wxGridStringTable,
-        so this renderer and editor are used by default for all grid cells.
+        The default is 15.

 
 

-        However if a custom table returns @c wxGRID_VALUE_BOOL from its
-        wxGridTableBase::GetTypeName() method, then wxGridCellBoolRenderer and
-        wxGridCellBoolEditor are used for it because the grid also registers a
-        boolean data type with this name.
+        @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
+    */
+    int GetScrollLineY() const;

 
 

-        And as this mechanism is completely generic, you may register your own
-        data types using your own custom renderers and editors. Just remember
-        that the table must identify a cell as being of the given type for them
-        to be used for this cell.
+    /**
+        Returns @true if a cell is either entirely or at least partially
+        visible in the grid window.

 
 

-        @param typeName
-            Name of the new type. May be any string, but if the type name is
-            the same as the name of an already registered type, including one
-            of the standard ones (which are @c wxGRID_VALUE_STRING, @c
-            wxGRID_VALUE_BOOL, @c wxGRID_VALUE_NUMBER, @c wxGRID_VALUE_FLOAT
-            and @c wxGRID_VALUE_CHOICE), then the new registration information
-            replaces the previously used renderer and editor.
-        @param renderer
-            The renderer to use for the cells of this type. Its ownership is
-            taken by the grid, i.e. it will call DecRef() on this pointer when
-            it doesn't need it any longer.
-        @param editor
-            The editor to use for the cells of this type. Its ownership is also
-            taken by the grid.
+        By default, the cell must be entirely visible for this function to
+        return @true but if @a wholeCellVisible is @false, the function returns
+        @true even if the cell is only partially visible.

     */
     */

-    void RegisterDataType(const wxString& typeName,
-                          wxGridCellRenderer* renderer,
-                          wxGridCellEditor* editor);
-
+    bool IsVisible(int row, int col, bool wholeCellVisible = true) const;

     /**
     /**

-        Sets the value of the current grid cell to the current in-place edit
-        control value.
+        Returns @true if a cell is either entirely or at least partially
+        visible in the grid window.

 
 

-        This is called automatically when the grid cursor moves from the
-        current cell to a new cell. It is also a good idea to call this
-        function when closing a grid since any edits to the final cell location
-        will not be saved otherwise.
+        By default, the cell must be entirely visible for this function to
+        return @true but if @a wholeCellVisible is @false, the function returns
+        @true even if the cell is only partially visible.

     */
     */

-    void SaveEditControlValue();
+    bool IsVisible(const wxGridCellCoords& coords,
+                   bool wholeCellVisible = true) const;

 
     /**
 
     /**

-        Selects all cells in the grid.
-    */
-    void SelectAll();
+        Brings the specified cell into the visible grid cell area with minimal
+        scrolling.

 
 

-    //@{
+        Does nothing if the cell is already visible.
+    */
+    void MakeCellVisible(int row, int col);

     /**
     /**

-        Selects a rectangular block of cells.
+        Brings the specified cell into the visible grid cell area with minimal
+        scrolling.

 
 

-        If @a addToSelected is @false then any existing selection will be
-        deselected; if @true the column will be added to the existing
-        selection.
+        Does nothing if the cell is already visible.

     */
     */

-    void SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
-                     bool addToSelected = false);
-    void SelectBlock(const wxGridCellCoords& topLeft,
-                     const wxGridCellCoords& bottomRight,
-                     bool addToSelected = false);
-    //@}
+    void MakeCellVisible(const wxGridCellCoords& coords);

 
     /**
 
     /**

-        Selects the specified column.
+        Sets the number of pixels per horizontal scroll increment.

 
 

-        If @a addToSelected is @false then any existing selection will be
-        deselected; if @true the column will be added to the existing
-        selection.
+        The default is 15.

 
 

-        This method won't select anything if the current selection mode is
-        wxGridSelectRows.
+        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()

     */
     */

-    void SelectCol(int col, bool addToSelected = false);
+    void SetScrollLineX(int x);

 
     /**
 
     /**

-        Selects the specified row.
+        Sets the number of pixels per vertical scroll increment.

 
 

-        If @a addToSelected is @false then any existing selection will be
-        deselected; if @true the row will be added to the existing selection.
+        The default is 15.

 
 

-        This method won't select anything if the current selection mode is
-        wxGridSelectColumns.
+        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()

     */
     */

-    void SelectRow(int row, bool addToSelected = false);
+    void SetScrollLineY(int y);
+
+    //@}

 
 

+
+    /**
+        @name Cell and Device Coordinate Translation
+     */

     //@{
     //@{

+

     /**
     /**

-        Sets the horizontal and vertical alignment for grid cell text at the
-        specified location.
+        Convert grid cell coordinates to grid window pixel coordinates.

 
 

-        Horizontal alignment should be one of @c wxALIGN_LEFT, @c
-        wxALIGN_CENTRE or @c wxALIGN_RIGHT.
+        This function returns the rectangle that encloses the block of cells
+        limited by @a topLeft and @a bottomRight cell in device coords and
+        clipped to the client size of the grid window.

 
 

-        Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
-        or @c wxALIGN_BOTTOM.
+        @see CellToRect()

     */
     */

-    void SetCellAlignment(int row, int col, int horiz, int vert);
-    void SetCellAlignment(int align, int row, int col);
-    //@}
+    wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
+                             const wxGridCellCoords& bottomRight) const;

 
 

-    //@{

     /**
     /**

-        Set the background colour for the given cell or all cells by default.
-    */
-    void SetCellBackgroundColour(int row, int col, const wxColour& colour);
-    //@}
+        Return the rectangle corresponding to the grid cell's size and position
+        in logical coordinates.

 
 

+        @see BlockToDeviceRect()
+    */
+    wxRect CellToRect(int row, int col) const;

     /**
     /**

-        Sets the editor for the grid cell at the specified location.
+        Return the rectangle corresponding to the grid cell's size and position
+        in logical coordinates.

 
 

-        The grid will take ownership of the pointer.
+        @see BlockToDeviceRect()
+    */
+    wxRect CellToRect(const wxGridCellCoords& coords) const;
+
+    /**
+        Returns the column at the given pixel position.

 
 

-        See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+        @param x
+            The x position to evaluate.
+        @param clipToMinMax
+            If @true, rather than returning @c wxNOT_FOUND, it returns either
+            the first or last column depending on whether @a x is too far to
+            the left or right respectively.
+        @return
+            The column index or @c wxNOT_FOUND.

     */
     */

-    void SetCellEditor(int row, int col, wxGridCellEditor* editor);
+    int XToCol(int x, bool clipToMinMax = false) const;

 
     /**
 
     /**

-        Sets the font for text in the grid cell at the specified location.
+        Returns the column whose right hand edge is close to the given logical
+        @a x position.
+
+        If no column edge is near to this position @c wxNOT_FOUND is returned.

     */
     */

-    void SetCellFont(int row, int col, const wxFont& font);
+    int XToEdgeOfCol(int x) const;

 
     /**
 
     /**

-        Sets the renderer for the grid cell at the specified location.
+        Translates logical pixel coordinates to the grid cell coordinates.

 
 

-        The grid will take ownership of the pointer.
+        Notice that this function expects logical coordinates on input so if
+        you use this function in a mouse event handler you need to translate
+        the mouse position, which is expressed in device coordinates, to
+        logical ones.
+
+        @see XToCol(), YToRow()
+     */
+    wxGridCellCoords XYToCell(int x, int y) const;
+    /**
+        Translates logical pixel coordinates to the grid cell coordinates.
+
+        Notice that this function expects logical coordinates on input so if
+        you use this function in a mouse event handler you need to translate
+        the mouse position, which is expressed in device coordinates, to
+        logical ones.
+
+        @see XToCol(), YToRow()
+     */
+    wxGridCellCoords XYToCell(const wxPoint& pos) const;
+    // XYToCell(int, int, wxGridCellCoords&) overload is intentionally
+    // undocumented, using it is ugly and non-const reference parameters are
+    // not used in wxWidgets API
+
+    /**
+        Returns the row whose bottom edge is close to the given logical @a y
+        position.

 
 

-        See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+        If no row edge is near to this position @c wxNOT_FOUND is returned.

     */
     */

-    void SetCellRenderer(int row, int col, wxGridCellRenderer* renderer);
+    int YToEdgeOfRow(int y) const;

 
 

-    //@{

     /**
     /**

-        Sets the text colour for the given cell or all cells by default.
+        Returns the grid row that corresponds to the logical @a y coordinate.
+
+        Returns @c wxNOT_FOUND if there is no row at the @a y position.

     */
     */

-    void SetCellTextColour(int row, int col, const wxColour& colour);
-    void SetCellTextColour(const wxColour& val, int row, int col);
-    void SetCellTextColour(const wxColour& colour);
+    int YToRow(int y, bool clipToMinMax = false) const;
+

     //@}
 
     //@}
 

+
+    /**
+        @name Miscellaneous Functions
+     */

     //@{
     //@{

+

     /**
     /**

-        Sets the string value for the cell at the specified location.
+        Appends one or more new columns to the right of the grid.

 
 

-        For simple applications where a grid object automatically uses a
-        default grid table of string values you use this function together with
-        GetCellValue() to access cell values. For more complex applications
-        where you have derived your own grid table class that contains various
-        data types (e.g. numeric, boolean or user-defined custom types) then
-        you only use this function for those cells that contain string values.
-        The last form is for backward compatibility only.
+        The @a updateLabels argument is not used at present. If you are using a
+        derived grid table class you will need to override
+        wxGridTableBase::AppendCols(). See InsertCols() for further
+        information.

 
 

-        See wxGridTableBase::CanSetValueAs and the @ref overview_grid
-        "wxGrid overview" for more information.
+        @return @true on success or @false if appending columns failed.

     */
     */

-    void SetCellValue(int row, int col, const wxString& s);
-    void SetCellValue(const wxGridCellCoords& coords, const wxString& s);
-    void SetCellValue(const wxString& val, int row, int col);
-    //@}
+    bool AppendCols(int numCols = 1, bool updateLabels = true);

 
     /**
 
     /**

-        Sets the cell attributes for all cells in the specified column.
+        Appends one or more new rows to the bottom of the grid.

 
 

-        For more information about controlling grid cell attributes see the
-        wxGridCellAttr cell attribute class and the @ref overview_grid "wxGrid overview".
+        The @a updateLabels argument is not used at present. If you are using a
+        derived grid table class you will need to override
+        wxGridTableBase::AppendRows(). See InsertRows() for further
+        information.
+
+        @return @true on success or @false if appending rows failed.

     */
     */

-    void SetColAttr(int col, wxGridCellAttr* attr);
+    bool AppendRows(int numRows = 1, bool updateLabels = true);

 
     /**
 
     /**

-        Sets the specified column to display boolean values.
+        Return @true if the horizontal grid lines stop at the last column
+        boundary or @false if they continue to the end of the window.

 
 

-        @see SetColFormatCustom()
-    */
-    void SetColFormatBool(int col);
+        The default is to clip grid lines.
+
+        @see ClipHorzGridLines(), AreVertGridLinesClipped()
+     */
+    bool AreHorzGridLinesClipped() const;

 
     /**
 
     /**

-        Sets the specified column to display data in a custom format.
+        Return @true if the vertical grid lines stop at the last row
+        boundary or @false if they continue to the end of the window.

 
 

-        This method provides an alternative to defining a custom grid table
-        which would return @a typeName from its GetTypeName() method for the
-        cells in this column: while it doesn't really change the type of the
-        cells in this column, it does associate the renderer and editor used
-        for the cells of the specified type with them.
+        The default is to clip grid lines.

 
 

-        See the @ref overview_grid "wxGrid overview" for more
-        information on working with custom data types.
-    */
-    void SetColFormatCustom(int col, const wxString& typeName);
+        @see ClipVertGridLines(), AreHorzGridLinesClipped()
+     */
+    bool AreVertGridLinesClipped() const;

 
     /**
 
     /**

-        Sets the specified column to display floating point values with the
-        given width and precision.
+        Increments the grid's batch count.

 
 

-        @see SetColFormatCustom()
+        When the count is greater than zero repainting of the grid is
+        suppressed. Each call to BeginBatch must be matched by a later call to
+        EndBatch(). Code that does a lot of grid modification can be enclosed
+        between BeginBatch() and EndBatch() calls to avoid screen flicker. The
+        final EndBatch() call will cause the grid to be repainted.
+
+        Notice that you should use wxGridUpdateLocker which ensures that there
+        is always a matching EndBatch() call for this BeginBatch() if possible
+        instead of calling this method directly.

     */
     */

-    void SetColFormatFloat(int col, int width = -1, int precision = -1);
+    void BeginBatch();

 
     /**
 
     /**

-        Sets the specified column to display integer values.
+        Clears all data in the underlying grid table and repaints the grid.

 
 

-        @see SetColFormatCustom()
+        The table is not deleted by this function. If you are using a derived
+        table class then you need to override wxGridTableBase::Clear() for this
+        function to have any effect.

     */
     */

-    void SetColFormatNumber(int col);
+    void ClearGrid();

 
     /**
 
     /**

-        Sets the horizontal and vertical alignment of column label text.
+        Change whether the horizontal grid lines are clipped by the end of the
+        last column.

 
 

-        Horizontal alignment should be one of @c wxALIGN_LEFT, @c
-        wxALIGN_CENTRE or @c wxALIGN_RIGHT.
-        Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
-        or @c wxALIGN_BOTTOM.
-    */
-    void SetColLabelAlignment(int horiz, int vert);
+        By default the grid lines are not drawn beyond the end of the last
+        column but after calling this function with @a clip set to @false they
+        will be drawn across the entire grid window.
+
+        @see AreHorzGridLinesClipped(), ClipVertGridLines()
+     */
+    void ClipHorzGridLines(bool clip);

 
     /**
 
     /**

-        Sets the height of the column labels.
+        Change whether the vertical grid lines are clipped by the end of the
+        last row.

 
 

-        If @a height equals to @c wxGRID_AUTOSIZE then height is calculated
-        automatically so that no label is truncated. Note that this could be
-        slow for a large table.
-    */
-    void SetColLabelSize(int height);
+        By default the grid lines are not drawn beyond the end of the last
+        row but after calling this function with @a clip set to @false they
+        will be drawn across the entire grid window.
+
+        @see AreVertGridLinesClipped(), ClipHorzGridLines()
+     */
+    void ClipVertGridLines(bool clip);

 
     /**
 
     /**

-        Set the value for the given column label.
+        Deletes one or more columns from a grid starting at the specified
+        position.

 
 

-        If you are using a custom grid table you must override
-        wxGridTableBase::SetColLabelValue for this to have any effect.
+        The @a updateLabels argument is not used at present. If you are using a
+        derived grid table class you will need to override
+        wxGridTableBase::DeleteCols(). See InsertCols() for further
+        information.
+
+        @return @true on success or @false if deleting columns failed.

     */
     */

-    void SetColLabelValue(int col, const wxString& value);
+    bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);

 
     /**
 
     /**

-        Sets the minimal width to which the user can resize columns.
+        Deletes one or more rows from a grid starting at the specified
+        position.

 
 

-        @see GetColMinimalAcceptableWidth()
+        The @a updateLabels argument is not used at present. If you are using a
+        derived grid table class you will need to override
+        wxGridTableBase::DeleteRows(). See InsertRows() for further
+        information.
+
+        @return @true on success or @false if appending rows failed.

     */
     */

-    void SetColMinimalAcceptableWidth(int width);
+    bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);

 
     /**
 
     /**

-        Sets the minimal width for the specified column.
+        Decrements the grid's batch count.

 
 

-        It is usually best to call this method during grid creation as calling
-        it later will not resize the column to the given minimal width even if
-        it is currently narrower than it.
+        When the count is greater than zero repainting of the grid is
+        suppressed. Each previous call to BeginBatch() must be matched by a
+        later call to EndBatch(). Code that does a lot of grid modification can
+        be enclosed between BeginBatch() and EndBatch() calls to avoid screen
+        flicker. The final EndBatch() will cause the grid to be repainted.

 
 

-        @a width must be greater than the minimal acceptable column width as
-        returned by GetColMinimalAcceptableWidth().
+        @see wxGridUpdateLocker

     */
     */

-    void SetColMinimalWidth(int col, int width);
+    void EndBatch();

 
     /**
 
     /**

-        Sets the position of the specified column.
+        Overridden wxWindow method.

     */
     */

-    void SetColPos(int colID, int newPos);
+    virtual void Fit();

 
     /**
 
     /**

-        Sets the width of the specified column.
-
-        Notice that this function does not refresh the grid, you need to call
-        ForceRefresh() to make the changes take effect immediately.
+        Causes immediate repainting of the grid.

 
 

-        @param col
-            The column index.
-        @param width
-            The new column width in pixels or a negative value to fit the
-            column width to its label width.
+        Use this instead of the usual wxWindow::Refresh().

     */
     */

-    void SetColSize(int col, int width);
+    void ForceRefresh();

 
     /**
 
     /**

-        Sets the default horizontal and vertical alignment for grid cell text.
-
-        Horizontal alignment should be one of @c wxALIGN_LEFT, @c
-        wxALIGN_CENTRE or @c wxALIGN_RIGHT.
-        Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
-        or @c wxALIGN_BOTTOM.
+        Returns the number of times that BeginBatch() has been called without
+        (yet) matching calls to EndBatch(). While the grid's batch count is
+        greater than zero the display will not be updated.

     */
     */

-    void SetDefaultCellAlignment(int horiz, int vert);
+    int GetBatchCount();

 
     /**
 
     /**

-        Sets the default background colour for grid cells.
-    */
-    void SetDefaultCellBackgroundColour(const wxColour& colour);
+        Returns the total number of grid columns.

 
 

-    /**
-        Sets the default font to be used for grid cell text.
+        This is the same as the number of columns in the underlying grid table.

     */
     */

-    void SetDefaultCellFont(const wxFont& font);
+    int GetNumberCols() const;

 
     /**
 
     /**

-        Sets the current default colour for grid cell text.
+        Returns the total number of grid rows.
+
+        This is the same as the number of rows in the underlying grid table.

     */
     */

-    void SetDefaultCellTextColour(const wxColour& colour);
+    int GetNumberRows() const;

 
     /**
 
     /**

-        Sets the default width for columns in the grid.
+        Returns the attribute for the given cell creating one if necessary.

 
 

-        This will only affect columns subsequently added to the grid unless
-        @a resizeExistingCols is @true.
+        If the cell already has an attribute, it is returned. Otherwise a new
+        attribute is created, associated with the cell and returned. In any
+        case the caller must call DecRef() on the returned pointer.

 
 

-        If @a width is less than GetColMinimalAcceptableWidth(), then the
-        minimal acceptable width is used instead of it.
+        This function may only be called if CanHaveAttributes() returns @true.

     */
     */

-    void SetDefaultColSize(int width, bool resizeExistingCols = false);
+    wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;

 
     /**
 
     /**

-        Sets the default editor for grid cells.
-
-        The grid will take ownership of the pointer.
+        Returns a base pointer to the current table object.

 
 

-        See wxGridCellEditor and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+        The returned pointer is still owned by the grid.

     */
     */

-    void SetDefaultEditor(wxGridCellEditor* editor);
+    wxGridTableBase *GetTable() const;

 
     /**
 
     /**

-        Sets the default renderer for grid cells.
+        Inserts one or more new columns into a grid with the first new column
+        at the specified position.

 
 

-        The grid will take ownership of the pointer.
+        Notice that inserting the columns in the grid requires grid table
+        cooperation: when this method is called, grid object begins by
+        requesting the underlying grid table to insert new columns. If this is
+        successful the table notifies the grid and the grid updates the
+        display. For a default grid (one where you have called CreateGrid())
+        this process is automatic. If you are using a custom grid table
+        (specified with SetTable()) then you must override
+        wxGridTableBase::InsertCols() in your derived table class.

 
 

-        See wxGridCellRenderer and the @ref overview_grid "wxGrid overview"
-        for more information about cell editors and renderers.
+        @param pos
+            The position which the first newly inserted column will have.
+        @param numCols
+            The number of columns to insert.
+        @param updateLabels
+            Currently not used.
+        @return
+            @true if the columns were successfully inserted, @false if an error
+            occurred (most likely the table couldn't be updated).

     */
     */

-    void SetDefaultRenderer(wxGridCellRenderer* renderer);
+    bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true);

 
     /**
 
     /**

-        Sets the default height for rows in the grid.
+        Inserts one or more new rows into a grid with the first new row at the
+        specified position.

 
 

-        This will only affect rows subsequently added to the grid unless
-        @a resizeExistingRows is @true.
+        Notice that you must implement wxGridTableBase::InsertRows() if you use
+        a grid with a custom table, please see InsertCols() for more
+        information.

 
 

-        If @a height is less than GetRowMinimalAcceptableHeight(), then the
-        minimal acceptable heihgt is used instead of it.
+        @param pos
+            The position which the first newly inserted row will have.
+        @param numRows
+            The number of rows to insert.
+        @param updateLabels
+            Currently not used.
+        @return
+            @true if the rows were successfully inserted, @false if an error
+            occurred (most likely the table couldn't be updated).

     */
     */

-    void SetDefaultRowSize(int height, bool resizeExistingRows = false);
+    bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true);

 
 

-    //@{

     /**
     /**

-        Set the grid cursor to the specified cell.
+        Invalidates the cached attribute for the given cell.

 
 

-        The grid cursor indicates the current cell and can be moved by the user
-        using the arrow keys or the mouse.
+        For efficiency reasons, wxGrid may cache the recently used attributes
+        (currently it caches only the single most recently used one, in fact)
+        which can result in the cell appearance not being refreshed even when
+        the attribute returned by your custom wxGridCellAttrProvider-derived
+        class has changed. To force the grid to refresh the cell attribute,
+        this function may be used. Notice that calling it will not result in
+        actually redrawing the cell, you still need to call
+        wxWindow::RefreshRect() to invalidate the area occupied by the cell in
+        the window to do this. Also note that you don't need to call this
+        function if you store the attributes in wxGrid itself, i.e. use its
+        SetAttr() and similar methods, it is only useful when using a separate
+        custom attributes provider.

 
 

-        Calling this function generates a wxEVT_GRID_SELECT_CELL event and if
-        the event handler vetoes this event, the cursor is not moved.
+        @param row
+            The row of the cell whose attribute needs to be queried again.
+        @param col
+            The column of the cell whose attribute needs to be queried again.

 
 

-        This function doesn't make the target call visible, use GoToCell() to
-        do this.
-    */
-    void SetGridCursor(int row, int col);
-    void SetGridCursor(const wxGridCellCoords& coords);
-    //@}
+        @since 2.9.2
+     */
+    void RefreshAttr(int row, int col);

 
     /**
 
     /**

-        Sets the colour used to draw grid lines.
-    */
-    void SetGridLineColour(const wxColour& colour);
+        Draws part or all of a wxGrid on a wxDC for printing or display.

 
 

-    /**
-        Sets the background colour for row and column labels.
-    */
-    void SetLabelBackgroundColour(const wxColour& colour);
+        Pagination can be accomplished by using sequential Render() calls
+        with appropriate values in wxGridCellCoords topLeft and bottomRight.

 
 

-    /**
-        Sets the font for row and column labels.
-    */
-    void SetLabelFont(const wxFont& font);
+        @param dc
+            The wxDC to be drawn on.
+        @param pos
+            The position on the wxDC where rendering should begin. If not
+            specified drawing will begin at the wxDC MaxX() and MaxY().
+        @param size
+            The size of the area on the wxDC that the rendered wxGrid should
+            occupy. If not specified the drawing will be scaled to fit the
+            available dc width or height. The wxGrid's aspect ratio is
+            maintained whether or not size is specified.
+        @param topLeft
+            The top left cell of the block to be drawn. Defaults to ( 0, 0 ).
+        @param bottomRight
+            The bottom right cell of the block to be drawn. Defaults to row and
+            column counts.
+        @param style
+            A combination of values from wxGridRenderStyle.
+
+        @since 2.9.4
+     */
+    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 );

 
     /**
 
     /**

-        Sets the colour for row and column label text.
+        Sets the cell attributes for all cells in the specified column.
+
+        For more information about controlling grid cell attributes see the
+        wxGridCellAttr cell attribute class and the @ref overview_grid.

     */
     */

-    void SetLabelTextColour(const wxColour& colour);
+    void SetColAttr(int col, wxGridCellAttr* attr);

 
     /**
         Sets the extra margins used around the grid area.
 
     /**
         Sets the extra margins used around the grid area.


@@ -2575,13 +4294,6 @@ public:
     */
     void SetMargins(int extraWidth, int extraHeight);
 
     */
     void SetMargins(int extraWidth, int extraHeight);
 

-    /**
-        Makes the cell at the specified location read-only or editable.
-
-        @see IsReadOnly()
-    */
-    void SetReadOnly(int row, int col, bool isReadOnly = true);
-

     /**
         Sets the cell attributes for all cells in the specified row.
 
     /**
         Sets the cell attributes for all cells in the specified row.
 


@@ -2592,179 +4304,144 @@ public:
     */
     void SetRowAttr(int row, wxGridCellAttr* attr);
 
     */
     void SetRowAttr(int row, wxGridCellAttr* attr);
 

-    /**
-        Sets the horizontal and vertical alignment of row label text.
-
-        Horizontal alignment should be one of @c wxALIGN_LEFT, @c
-        wxALIGN_CENTRE or @c wxALIGN_RIGHT.
-        Vertical alignment should be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE
-        or @c wxALIGN_BOTTOM.
-    */
-    void SetRowLabelAlignment(int horiz, int vert);
-
-    /**
-        Sets the width of the row labels.
+    //@}

 
 

-        If @a width equals @c wxGRID_AUTOSIZE then width is calculated
-        automatically so that no label is truncated. Note that this could be
-        slow for a large table.
-    */
-    void SetRowLabelSize(int width);

 
     /**
 
     /**

-        Sets the value for the given row label.
+        @name Sorting support.

 
 

-        If you are using a derived grid table you must override
-        wxGridTableBase::SetRowLabelValue for this to have any effect.
-    */
-    void SetRowLabelValue(int row, const wxString& value);
+        wxGrid doesn't provide any support for sorting the data but it does
+        generate events allowing the user code to sort it and supports
+        displaying the sort indicator in the column used for sorting.

 
 

-    /**
-        Sets the minimal row height used by default.
+        To use wxGrid sorting support you need to handle wxEVT_GRID_COL_SORT
+        event (and not veto it) and resort the data displayed in the grid. The
+        grid will automatically update the sorting indicator on the column
+        which was clicked.

 
 

-        See SetColMinimalAcceptableWidth() for more information.
-    */
-    void SetRowMinimalAcceptableHeight(int height);
+        You can also call the functions in this section directly to update the
+        sorting indicator. Once again, they don't do anything with the grid
+        data, it remains your responsibility to actually sort it appropriately.
+     */
+    //@{

 
     /**
 
     /**

-        Sets the minimal height for the specified row.
-
-        See SetColMinimalWidth() for more information.
-    */
-    void SetRowMinimalHeight(int row, int height);
+        Return the column in which the sorting indicator is currently
+        displayed.

 
 

-    /**
-        Sets the height of the specified row.
+        Returns @c wxNOT_FOUND if sorting indicator is not currently displayed
+        at all.

 
 

-        See SetColSize() for more information.
-    */
-    void SetRowSize(int row, int height);
+        @see SetSortingColumn()
+     */
+    int GetSortingColumn() const;

 
     /**
 
     /**

-        Sets the number of pixels per horizontal scroll increment.
-
-        The default is 15.
+        Return @true if this column is currently used for sorting.

 
 

-        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
-    */
-    void SetScrollLineX(int x);
+        @see GetSortingColumn()
+     */
+    bool IsSortingBy(int col) const;

 
     /**
 
     /**

-        Sets the number of pixels per vertical scroll increment.
-
-        The default is 15.
+        Return @true if the current sorting order is ascending or @false if it
+        is descending.

 
 

-        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
-    */
-    void SetScrollLineY(int y);
+        It only makes sense to call this function if GetSortingColumn() returns
+        a valid column index and not @c wxNOT_FOUND.

 
 

-    /**
-        Set the colour to be used for drawing the selection background.
-    */
-    void SetSelectionBackground(const wxColour& c);
+        @see SetSortingColumn()
+     */
+    bool IsSortOrderAscending() const;

 
     /**
 
     /**

-        Set the colour to be used for drawing the selection foreground.
-    */
-    void SetSelectionForeground(const wxColour& c);
+        Set the column to display the sorting indicator in and its direction.

 
 

-    /**
-        Set the selection behaviour of the grid.
+        @param col
+            The column to display the sorting indicator in or @c wxNOT_FOUND to
+            remove any currently displayed sorting indicator.
+        @param ascending
+            If @true, display the ascending sort indicator, otherwise display
+            the descending sort indicator.

 
 

-        The existing selection is converted to conform to the new mode if
-        possible and discarded otherwise (e.g. any individual selected cells
-        are deselected if the new mode allows only the selection of the entire
-        rows or columns).
-    */
-    void SetSelectionMode(wxGridSelectionModes selmode);
+        @see GetSortingColumn(), IsSortOrderAscending()
+     */
+    void SetSortingColumn(int col, bool ascending = true);

 
     /**
 
     /**

-        Passes a pointer to a custom grid table to be used by the grid.
+        Remove any currently shown sorting indicator.

 
 

-        This should be called after the grid constructor and before using the
-        grid object. If @a takeOwnership is set to @true then the table will be
-        deleted by the wxGrid destructor.
+        This is equivalent to calling SetSortingColumn() with @c wxNOT_FOUND
+        first argument.
+     */
+    void UnsetSortingColumn();
+    //@}

 
 

-        Use this function instead of CreateGrid() when your application
-        involves complex or non-string data or data sets that are too large to
-        fit wholly in memory.
-    */
-    bool SetTable(wxGridTableBase* table,
-                  bool takeOwnership = false,
-                  wxGridSelectionModes selmode = wxGridSelectCells);

 
     /**
 
     /**

-        Call this in order to make the column labels use a native look by using
-        wxRenderer::DrawHeaderButton internally.
+        @name Accessors for component windows.

 
 

-        There is no equivalent method for drawing row columns as there is not
-        native look for that. This option is useful when using wxGrid for
-        displaying tables and not as a spread-sheet.
-    */
-    void SetUseNativeColLabels(bool native = true);
+        Return the various child windows of wxGrid.

 
 

-    /**
-        Displays the in-place cell edit control for the current cell.
-    */
-    void ShowCellEditControl();
+        wxGrid is an empty parent window for 4 children representing the column
+        labels window (top), the row labels window (left), the corner window
+        (top left) and the main grid window. It may be necessary to use these
+        individual windows and not the wxGrid window itself if you need to
+        handle events for them (this can be done using wxEvtHandler::Connect()
+        or wxWindow::PushEventHandler()) or do something else requiring the use
+        of the correct window pointer. Notice that you should not, however,
+        change these windows (e.g. reposition them or draw over them) because
+        they are managed by wxGrid itself.
+     */
+    //@{

 
     /**
 
     /**

-        Returns the column at the given pixel position.
+        Return the main grid window containing the grid cells.

 
 

-        @param x
-            The x position to evaluate.
-        @param clipToMinMax
-            If @true, rather than returning wxNOT_FOUND, it returns either the
-            first or last column depending on whether x is too far to the left
-            or right respectively.
-        @return
-            The column index or wxNOT_FOUND.
-    */
-    int XToCol(int x, bool clipToMinMax = false) const;
+        This window is always shown.
+     */
+    wxWindow *GetGridWindow() const;

 
     /**
 
     /**

-        Returns the column whose right hand edge is close to the given logical
-        x position.
+        Return the row labels window.

 
 

-        If no column edge is near to this position @c wxNOT_FOUND is returned.
-    */
-    int XToEdgeOfCol(int x) const;
+        This window is not shown if the row labels were hidden using
+        HideRowLabels().
+     */
+    wxWindow *GetGridRowLabelWindow() const;

 
 

-    //@{

     /**
     /**

-        Translates logical pixel coordinates to the grid cell coordinates.
+        Return the column labels window.

 
 

-        Notice that this function expects logical coordinates on input so if
-        you use this function in a mouse event handler you need to translate
-        the mouse position, which is expressed in device coordinates, to
-        logical ones.
+        This window is not shown if the columns labels were hidden using
+        HideColLabels().

 
 

-        @see XToCol(), YToRow()
+        Depending on whether UseNativeColHeader() was called or not this can be
+        either a wxHeaderCtrl or a plain wxWindow.  This function returns a valid
+        window pointer in either case but in the former case you can also use
+        GetGridColHeader() to access it if you need wxHeaderCtrl-specific
+        functionality.

      */
      */

-
-    // XYToCell(int, int, wxGridCellCoords&) overload is intentionally
-    // undocumented, using it is ugly and non-const reference parameters are
-    // not used in wxWidgets API
-
-    wxGridCellCoords XYToCell(int x, int y) const;
-    wxGridCellCoords XYToCell(const wxPoint& pos) const;
-
-    //@}
+    wxWindow *GetGridColLabelWindow() const;

 
     /**
 
     /**

-        Returns the row whose bottom edge is close to the given logical y
-        position.
+        Return the window in the top left grid corner.

 
 

-        If no row edge is near to this position @c wxNOT_FOUND is returned.
-    */
-    int YToEdgeOfRow(int y) const;
+        This window is shown only of both columns and row labels are shown and
+        normally doesn't contain anything. Clicking on it is handled by wxGrid
+        however and can be used to select the entire grid.
+     */
+    wxWindow *GetGridCornerLabelWindow() const;

 
     /**
 
     /**

-        Returns the grid row that corresponds to the logical y coordinate.
+        Return the header control used for column labels display.

 
 

-        Returns @c wxNOT_FOUND if there is no row at the y position.
-    */
-    int YToRow(int y, bool clipToMinMax = false) const;
+        This function can only be called if UseNativeColHeader() had been
+        called.
+     */
+    wxHeaderCtrl *GetGridColHeader() const;
+
+    //@}

 
 protected:
     /**
 
 protected:
     /**


@@ -2871,10 +4548,29 @@ public:
 
     This event class contains information about various grid events.
 
 
     This event class contains information about various grid events.
 

+    Notice that all grid event table macros are available in two versions:
+    @c EVT_GRID_XXX and @c EVT_GRID_CMD_XXX. The only difference between the
+    two is that the former doesn't allow to specify the grid window identifier
+    and so takes a single parameter, the event handler, but is not suitable if
+    there is more than one grid control in the window where the event table is
+    used (as it would catch the events from all the grids). The version with @c
+    CMD takes the id as first argument and the event handler as the second one
+    and so can be used with multiple grids as well. Otherwise there are no
+    difference between the two and only the versions without the id are
+    documented below for brevity.
+

     @beginEventTable{wxGridEvent}
     @beginEventTable{wxGridEvent}

-    @event{EVT_GRID_CELL_CHANGE(func)}
-        The user changed the data in a cell. Processes a
-        @c wxEVT_GRID_CELL_CHANGE event type.
+    @event{EVT_GRID_CELL_CHANGING(func)}
+        The user is about to change the data in a cell. The new cell value as
+        string is available from GetString() event object method. This event
+        can be vetoed if the change is not allowed.
+        Processes a @c wxEVT_GRID_CELL_CHANGING event type.
+    @event{EVT_GRID_CELL_CHANGED(func)}
+        The user changed the data in a cell. The old cell value as string is
+        available from GetString() event object method. Notice that vetoing
+        this event still works for backwards compatibility reasons but any new
+        code should only veto EVT_GRID_CELL_CHANGING event and not this one.
+        Processes a @c wxEVT_GRID_CELL_CHANGED event type.

     @event{EVT_GRID_CELL_LEFT_CLICK(func)}
         The user clicked a cell with the left mouse button. Processes a
         @c wxEVT_GRID_CELL_LEFT_CLICK event type.
     @event{EVT_GRID_CELL_LEFT_CLICK(func)}
         The user clicked a cell with the left mouse button. Processes a
         @c wxEVT_GRID_CELL_LEFT_CLICK event type.


@@ -2906,56 +4602,41 @@ public:
         The user double-clicked a label with the right mouse button. Processes
         a @c wxEVT_GRID_LABEL_RIGHT_DCLICK event type.
     @event{EVT_GRID_SELECT_CELL(func)}
         The user double-clicked a label with the right mouse button. Processes
         a @c wxEVT_GRID_LABEL_RIGHT_DCLICK event type.
     @event{EVT_GRID_SELECT_CELL(func)}

-        The user moved to, and selected a cell. Processes a
+        The given cell was made current, either by user or by the program via a
+        call to SetGridCursor() or GoToCell(). Processes a

         @c wxEVT_GRID_SELECT_CELL event type.
         @c wxEVT_GRID_SELECT_CELL event type.

-    @event{EVT_GRID_CMD_CELL_CHANGE(id, func)}
-        The user changed the data in a cell; variant taking a window
-        identifier. Processes a @c wxEVT_GRID_CELL_CHANGE event type.
-    @event{EVT_GRID_CMD_CELL_LEFT_CLICK(id, func)}
-        The user clicked a cell with the left mouse button; variant taking a
-        window identifier. Processes a @c wxEVT_GRID_CELL_LEFT_CLICK event
-        type.
-    @event{EVT_GRID_CMD_CELL_LEFT_DCLICK(id, func)}
-        The user double-clicked a cell with the left mouse button; variant
-        taking a window identifier. Processes a @c wxEVT_GRID_CELL_LEFT_DCLICK
-        event type.
-    @event{EVT_GRID_CMD_CELL_RIGHT_CLICK(id, func)}
-        The user clicked a cell with the right mouse button; variant taking a
-        window identifier. Processes a @c wxEVT_GRID_CELL_RIGHT_CLICK event
-        type.
-    @event{EVT_GRID_CMD_CELL_RIGHT_DCLICK(id, func)}
-        The user double-clicked a cell with the right mouse button; variant
-        taking a window identifier. Processes a @c wxEVT_GRID_CELL_RIGHT_DCLICK
-        event type.
-    @event{EVT_GRID_CMD_EDITOR_HIDDEN(id, func)}
-        The editor for a cell was hidden; variant taking a window identifier.
-        Processes a @c wxEVT_GRID_EDITOR_HIDDEN event type.
-    @event{EVT_GRID_CMD_EDITOR_SHOWN(id, func)}
-        The editor for a cell was shown; variant taking a window identifier.
-        Processes a @c wxEVT_GRID_EDITOR_SHOWN event type.
-    @event{EVT_GRID_CMD_LABEL_LEFT_CLICK(id, func)}
-        The user clicked a label with the left mouse button; variant taking a
-        window identifier. Processes a @c wxEVT_GRID_LABEL_LEFT_CLICK event
-        type.
-    @event{EVT_GRID_CMD_LABEL_LEFT_DCLICK(id, func)}
-        The user double-clicked a label with the left mouse button; variant
-        taking a window identifier. Processes a @c wxEVT_GRID_LABEL_LEFT_DCLICK
-        event type.
-    @event{EVT_GRID_CMD_LABEL_RIGHT_CLICK(id, func)}
-        The user clicked a label with the right mouse button; variant taking a
-        window identifier. Processes a @c wxEVT_GRID_LABEL_RIGHT_CLICK event
-        type.
-    @event{EVT_GRID_CMD_LABEL_RIGHT_DCLICK(id, func)}
-        The user double-clicked a label with the right mouse button; variant
-        taking a window identifier. Processes a
-        @c wxEVT_GRID_LABEL_RIGHT_DCLICK event type.
-    @event{EVT_GRID_CMD_SELECT_CELL(id, func)}
-        The user moved to, and selected a cell; variant taking a window
-        identifier. Processes a @c wxEVT_GRID_SELECT_CELL event type.
+    @event{EVT_GRID_COL_MOVE(func)}
+        The user tries to change the order of the columns in the grid by
+        dragging the column specified by GetCol(). This event can be vetoed to
+        either prevent the user from reordering the column change completely
+        (but notice that if you don't want to allow it at all, you simply
+        shouldn't call wxGrid::EnableDragColMove() in the first place), vetoed
+        but handled in some way in the handler, e.g. by really moving the
+        column to the new position at the associated table level, or allowed to
+        proceed in which case wxGrid::SetColPos() is used to reorder the
+        columns display order without affecting the use of the column indices
+        otherwise.
+        This event macro corresponds to @c wxEVT_GRID_COL_MOVE event type.
+    @event{EVT_GRID_COL_SORT(func)}
+        This event is generated when a column is clicked by the user and its
+        name is explained by the fact that the custom reaction to a click on a
+        column is to sort the grid contents by this column. However the grid
+        itself has no special support for sorting and it's up to the handler of
+        this event to update the associated table. But if the event is handled
+        (and not vetoed) the grid supposes that the table was indeed resorted
+        and updates the column to indicate the new sort order and refreshes
+        itself.
+        This event macro corresponds to @c wxEVT_GRID_COL_SORT event type.
+    @event{EVT_GRID_TABBING(func)}
+        This event is generated when the user presses TAB or Shift-TAB in the
+        grid. It can be used to customize the simple default TAB handling
+        logic, e.g. to go to the next non-empty cell instead of just the next
+        cell. See also wxGrid::SetTabBehaviour(). This event is new since
+        wxWidgets 2.9.5.

     @endEventTable
 
     @library{wxadv}
     @endEventTable
 
     @library{wxadv}

-    @category{grid}
+    @category{grid,events}

 */
 class wxGridEvent : public wxNotifyEvent
 {
 */
 class wxGridEvent : public wxNotifyEvent
 {


@@ -2969,8 +4650,7 @@ public:
     */
     wxGridEvent(int id, wxEventType type, wxObject* obj,
                 int row = -1, int col = -1, int x = -1, int y = -1,
     */
     wxGridEvent(int id, wxEventType type, wxObject* obj,
                 int row = -1, int col = -1, int x = -1, int y = -1,

-                bool sel = true, bool control = false, bool shift = false,
-                bool alt = false, bool meta = false);
+                bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());

 
     /**
         Returns @true if the Alt key was down at the time of the event.
 
     /**
         Returns @true if the Alt key was down at the time of the event.


@@ -2984,6 +4664,10 @@ public:
 
     /**
         Column at which the event occurred.
 
     /**
         Column at which the event occurred.

+
+        Notice that for a @c wxEVT_GRID_SELECT_CELL event this column is the
+        column of the newly selected cell while the previously selected cell
+        can be retrieved using wxGrid::GetGridCursorCol().

     */
     virtual int GetCol();
 
     */
     virtual int GetCol();
 


@@ -2994,6 +4678,10 @@ public:
 
     /**
         Row at which the event occurred.
 
     /**
         Row at which the event occurred.

+
+        Notice that for a @c wxEVT_GRID_SELECT_CELL event this row is the row
+        of the newly selected cell while the previously selected cell can be
+        retrieved using wxGrid::GetGridCursorRow().

     */
     virtual int GetRow();
 
     */
     virtual int GetRow();
 


@@ -3022,22 +4710,27 @@ public:
     This event class contains information about a row/column resize event.
 
     @beginEventTable{wxGridSizeEvent}
     This event class contains information about a row/column resize event.
 
     @beginEventTable{wxGridSizeEvent}

-    @event{EVT_GRID_COL_SIZE(func)}
-        The user resized a column by dragging it. Processes a
-        @c wxEVT_GRID_COL_SIZE event type.
-    @event{EVT_GRID_ROW_SIZE(func)}
-        The user resized a row by dragging it. Processes a
-        @c wxEVT_GRID_ROW_SIZE event type.

     @event{EVT_GRID_CMD_COL_SIZE(id, func)}
     @event{EVT_GRID_CMD_COL_SIZE(id, func)}

-        The user resized a column by dragging it; variant taking a window
-        identifier. Processes a @c wxEVT_GRID_COL_SIZE event type.
+        The user resized a column, corresponds to @c wxEVT_GRID_COL_SIZE event
+        type.

     @event{EVT_GRID_CMD_ROW_SIZE(id, func)}
     @event{EVT_GRID_CMD_ROW_SIZE(id, func)}

-        The user resized a row by dragging it; variant taking a window
-        identifier. Processes a @c wxEVT_GRID_ROW_SIZE event type.
+        The user resized a row, corresponds to @c wxEVT_GRID_ROW_SIZE event
+        type.
+    @event{EVT_GRID_COL_SIZE(func)}
+        Same as EVT_GRID_CMD_COL_SIZE() but uses `wxID_ANY` id.
+    @event{EVT_GRID_COL_AUTO_SIZE(func)}
+        This event is sent when a column must be resized to its best size, e.g.
+        when the user double clicks the column divider. The default
+        implementation simply resizes the column to fit the column label (but
+        not its contents as this could be too slow for big grids). This macro
+        corresponds to @c wxEVT_GRID_COL_AUTO_SIZE event type and is new since
+        wxWidgets 2.9.5.
+    @event{EVT_GRID_ROW_SIZE(func)}
+        Same as EVT_GRID_CMD_ROW_SIZE() but uses `wxID_ANY` id.

     @endEventTable
 
     @library{wxadv}
     @endEventTable
 
     @library{wxadv}

-    @category{grid}
+    @category{grid,events}

 */
 class wxGridSizeEvent : public wxNotifyEvent
 {
 */
 class wxGridSizeEvent : public wxNotifyEvent
 {


@@ -3051,8 +4744,7 @@ public:
     */
     wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
                     int rowOrCol = -1, int x = -1, int y = -1,
     */
     wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
                     int rowOrCol = -1, int x = -1, int y = -1,

-                    bool control = false, bool shift = false,
-                    bool alt = false, bool meta = false);
+                    const wxKeyboardState& kbd = wxKeyboardState());

 
     /**
         Returns @true if the Alt key was down at the time of the event.
 
     /**
         Returns @true if the Alt key was down at the time of the event.


@@ -3100,7 +4792,7 @@ public:
     @endEventTable
 
     @library{wxadv}
     @endEventTable
 
     @library{wxadv}

-    @category{grid}
+    @category{grid,events}

 */
 class wxGridRangeSelectEvent : public wxNotifyEvent
 {
 */
 class wxGridRangeSelectEvent : public wxNotifyEvent
 {


@@ -3116,9 +4808,7 @@ public:
                            wxObject* obj,
                            const wxGridCellCoords& topLeft,
                            const wxGridCellCoords& bottomRight,
                            wxObject* obj,
                            const wxGridCellCoords& topLeft,
                            const wxGridCellCoords& bottomRight,

-                           bool sel = true, bool control = false,
-                           bool shift = false, bool alt = false,
-                           bool meta = false);
+                           bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());

 
     /**
         Returns @true if the Alt key was down at the time of the event.
 
     /**
         Returns @true if the Alt key was down at the time of the event.


@@ -3191,7 +4881,7 @@ public:
     @endEventTable
 
     @library{wxadv}
     @endEventTable
 
     @library{wxadv}

-    @category{grid}
+    @category{grid,events}

 */
 class wxGridEditorCreatedEvent : public wxCommandEvent
 {
 */
 class wxGridEditorCreatedEvent : public wxCommandEvent
 {


@@ -3237,3 +4927,27 @@ public:
     void SetRow(int row);
 };
 
     void SetRow(int row);
 };
 

+
+wxEventType wxEVT_GRID_CELL_LEFT_CLICK;
+wxEventType wxEVT_GRID_CELL_RIGHT_CLICK;
+wxEventType wxEVT_GRID_CELL_LEFT_DCLICK;
+wxEventType wxEVT_GRID_CELL_RIGHT_DCLICK;
+wxEventType wxEVT_GRID_LABEL_LEFT_CLICK;
+wxEventType wxEVT_GRID_LABEL_RIGHT_CLICK;
+wxEventType wxEVT_GRID_LABEL_LEFT_DCLICK;
+wxEventType wxEVT_GRID_LABEL_RIGHT_DCLICK;
+wxEventType wxEVT_GRID_ROW_SIZE;
+wxEventType wxEVT_GRID_COL_SIZE;
+wxEventType wxEVT_GRID_COL_AUTO_SIZE;
+wxEventType wxEVT_GRID_RANGE_SELECT;
+wxEventType wxEVT_GRID_CELL_CHANGING;
+wxEventType wxEVT_GRID_CELL_CHANGED;
+wxEventType wxEVT_GRID_SELECT_CELL;
+wxEventType wxEVT_GRID_EDITOR_SHOWN;
+wxEventType wxEVT_GRID_EDITOR_HIDDEN;
+wxEventType wxEVT_GRID_EDITOR_CREATED;
+wxEventType wxEVT_GRID_CELL_BEGIN_DRAG;
+wxEventType wxEVT_GRID_COL_MOVE;
+wxEventType wxEVT_GRID_COL_SORT;
+wxEventType wxEVT_GRID_TABBING;
+