don't place NULL pointers in the GDK window array in GTKGetWindow()

[wxWidgets.git] / interface / wx / grid.h
diff --git a/interface/wx/grid.h b/interface/wx/grid.h

index 9d1eeb0ebc151d242ffd95da581696f5b8870ace..5fbea265acb5f13ed66f1a4138b9a98c3b0b4485 100644 (file)
--- a/interface/wx/grid.h
+++ b/interface/wx/grid.h
@@ -1,22 +1,85 @@
  /////////////////////////////////////////////////////////////////////////////
  // Name:        grid.h
  /////////////////////////////////////////////////////////////////////////////
  // Name:        grid.h
-// Purpose:     interface of wxGridCellFloatRenderer
+// Purpose:     interface of wxGrid and related classes
  // Author:      wxWidgets team
  // RCS-ID:      $Id$
  // Licence:     wxWindows license
  /////////////////////////////////////////////////////////////////////////////
  
  // Author:      wxWidgets team
  // RCS-ID:      $Id$
  // Licence:     wxWindows license
  /////////////////////////////////////////////////////////////////////////////
  
+/**
+    @class wxGridCellRenderer
+
+    This class is responsible for actually drawing the cell in the grid. You
+    may pass it to the wxGridCellAttr (below) to change the format of one given
+    cell or to wxGrid::SetDefaultRenderer() to change the view of all cells.
+    This is an abstract class, and you will normally use one of the predefined
+    derived classes or derive your own class from it.
+
+    @library{wxadv}
+    @category{grid}
+
+    @see wxGridCellBoolRenderer, wxGridCellFloatRenderer,
+         wxGridCellNumberRenderer, wxGridCellStringRenderer
+*/
+class wxGridCellRenderer
+{
+public:
+    /**
+        This function must be implemented in derived classes to return a copy
+        of itself.
+    */
+    virtual wxGridCellRenderer* Clone() const = 0;
+
+    /**
+        Draw the given cell on the provided DC inside the given rectangle using
+        the style specified by the attribute and the default or selected state
+        corresponding to the isSelected value.
+
+        This pure virtual function has a default implementation which will
+        prepare the DC using the given attribute: it will draw the rectangle
+        with the background colour from attr and set the text colour and font.
+    */
+    virtual void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
+                      const wxRect& rect, int row, int col,
+                      bool isSelected) = 0;
+
+    /**
+        Get the preferred size of the cell for its contents.
+    */
+    virtual wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
+                               int row, int col) = 0;
+};
+
+/**
+    @class wxGridCellBoolRenderer
+
+    This class may be used to format boolean data in a cell.
+
+    @library{wxadv}
+    @category{grid}
+
+    @see wxGridCellRenderer, wxGridCellFloatRenderer, wxGridCellNumberRenderer,
+         wxGridCellStringRenderer
+*/
+class wxGridCellBoolRenderer : public wxGridCellRenderer
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxGridCellBoolRenderer();
+};
+
  /**
      @class wxGridCellFloatRenderer
  /**
      @class wxGridCellFloatRenderer
-    @wxheader{grid.h}
  
      This class may be used to format floating point data in a cell.
  
      @library{wxadv}
  
      This class may be used to format floating point data in a cell.
  
      @library{wxadv}
-    @category{FIXME}
+    @category{grid}
  
  
-    @see wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellStringRenderer,
-    wxGridCellBoolRenderer
+    @see wxGridCellRenderer, wxGridCellBoolRenderer, wxGridCellNumberRenderer,
+         wxGridCellStringRenderer
  */
  class wxGridCellFloatRenderer : public wxGridCellStringRenderer
  {
  */
  class wxGridCellFloatRenderer : public wxGridCellStringRenderer
  {
@@ -30,1725 +93,2412 @@ public:
      wxGridCellFloatRenderer(int width = -1, int precision = -1);
  
      /**
      wxGridCellFloatRenderer(int width = -1, int precision = -1);
  
      /**
-        Returns the precision ( see @ref constr() wxGridCellFloatRenderer ).
+        Returns the precision.
      */
      int GetPrecision() const;
  
      /**
      */
      int GetPrecision() const;
  
      /**
-        Returns the width ( see @ref constr() wxGridCellFloatRenderer ).
+        Returns the width.
      */
      int GetWidth() const;
  
      /**
          Parameters string format is "width[,precision]".
      */
      */
      int GetWidth() const;
  
      /**
          Parameters string format is "width[,precision]".
      */
-    void SetParameters(const wxString& params);
+    virtual void SetParameters(const wxString& params);
  
      /**
  
      /**
-        Sets the precision ( see @ref constr() wxGridCellFloatRenderer ).
+        Sets the precision.
      */
      void SetPrecision(int precision);
  
      /**
      */
      void SetPrecision(int precision);
  
      /**
-        Sets the width ( see @ref constr() wxGridCellFloatRenderer )
+        Sets the width.
      */
      void SetWidth(int width);
  };
  
      */
      void SetWidth(int width);
  };
  
+/**
+    @class wxGridCellNumberRenderer
+
+    This class may be used to format integer data in a cell.
+
+    @library{wxadv}
+    @category{grid}
  
  
+    @see wxGridCellRenderer, wxGridCellBoolRenderer, wxGridCellFloatRenderer,
+         wxGridCellStringRenderer
+*/
+class wxGridCellNumberRenderer : public wxGridCellStringRenderer
+{
+public:
+    /**
+        Default constructor.
+    */
+    wxGridCellNumberRenderer();
+};
  
  /**
  
  /**
-    @class wxGridTableBase
-    @wxheader{grid.h}
+    @class wxGridCellStringRenderer
  
  
-    Grid table classes.
+    This class may be used to format string data in a cell; it is the default
+    for string cells.
  
      @library{wxadv}
  
      @library{wxadv}
-    @category{FIXME}
+    @category{grid}
+
+    @see wxGridCellRenderer, wxGridCellBoolRenderer, wxGridCellFloatRenderer,
+         wxGridCellNumberRenderer
  */
  */
-class wxGridTableBase : public wxObject
+class wxGridCellStringRenderer : public wxGridCellRenderer
  {
  public:
      /**
  {
  public:
      /**
-
+        Default constructor.
      */
      */
-    wxGridTableBase();
+    wxGridCellStringRenderer();
+};
  
  
-    /**
  
  
-    */
-    ~wxGridTableBase();
  
  
-    /**
+/**
+    @class wxGridCellEditor
  
  
-    */
-    bool AppendCols(size_t numCols = 1);
+    This class is responsible for providing and manipulating the in-place edit
+    controls for the grid.  Instances of wxGridCellEditor (actually, instances
+    of derived classes since it is an abstract class) can be associated with
+    the cell attributes for individual cells, rows, columns, or even for the
+    entire grid.
  
  
-    /**
+    @library{wxadv}
+    @category{grid}
  
  
+    @see wxGridCellBoolEditor, wxGridCellChoiceEditor, wxGridCellFloatEditor,
+         wxGridCellNumberEditor, wxGridCellTextEditor
+*/
+class wxGridCellEditor
+{
+public:
+    /**
+        Default constructor.
      */
      */
-    bool AppendRows(size_t numRows = 1);
+    wxGridCellEditor();
  
      /**
  
      /**
+        Fetch the value from the table and prepare the edit control to begin
+        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()
      */
      */
-    bool CanGetValueAs(int row, int col, const wxString& typeName);
+    virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
  
      /**
  
      /**
-        Does this table allow attributes?  Default implementation creates
-        a wxGridCellAttrProvider if necessary.
+        Create a new object which is the copy of this one.
      */
      */
-    bool CanHaveAttributes();
+    virtual wxGridCellEditor* Clone() const = 0;
  
      /**
  
      /**
-
+        Creates the actual edit control.
      */
      */
-    bool CanSetValueAs(int row, int col, const wxString& typeName);
+    virtual void Create(wxWindow* parent, wxWindowID id,
+                        wxEvtHandler* evtHandler) = 0;
  
      /**
  
      /**
-
+        Final cleanup.
      */
      */
-    void Clear();
+    virtual void Destroy();
  
      /**
  
      /**
+        End editing the cell.
  
  
-    */
-    bool DeleteCols(size_t pos = 0, size_t numCols = 1);
+        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.
      */
      */
-    bool DeleteRows(size_t pos = 0, size_t numRows = 1);
+    virtual bool EndEdit(int row, int col, const wxGrid* grid,
+                         const wxString& oldval, wxString* newval) = 0;
  
      /**
  
      /**
-        by default forwarded to wxGridCellAttrProvider if any. May be
-        overridden to handle attributes directly in the table.
-    */
-    wxGridCellAttr* GetAttr(int row, int col);
+        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;
  
      /**
  
      /**
-        get the currently used attr provider (may be @NULL)
+        Some types of controls on some platforms may need some help with the
+        Return key.
      */
      */
-    wxGridCellAttrProvider* GetAttrProvider() const;
+    virtual void HandleReturn(wxKeyEvent& event);
  
      /**
  
      /**
-
+        Returns @true if the edit control has been created.
      */
      */
-    wxString GetColLabelValue(int col);
+    bool IsCreated();
  
      /**
  
      /**
-
+        Draws the part of the cell not occupied by the control: the base class
+        version just fills it with background colour from the attribute.
      */
      */
-    int GetNumberCols();
+    virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr* attr);
  
      /**
  
      /**
-        You must override these functions in a derived table class.
+        Reset the value in the control back to its starting value.
      */
      */
-    int GetNumberRows();
+    virtual void Reset() = 0;
  
      /**
  
      /**
-
+        Size and position the edit control.
      */
      */
-    wxString GetRowLabelValue(int row);
+    virtual void SetSize(const wxRect& rect);
  
      /**
  
      /**
-        Data type determination and value access.
+        Show or hide the edit control, use the specified attributes to set
+        colours/fonts for it.
      */
      */
-    wxString GetTypeName(int row, int col);
+    virtual void Show(bool show, wxGridCellAttr* attr = NULL);
  
      /**
  
      /**
-
+        If the editor is enabled by clicking on the cell, this method will be
+        called.
      */
      */
-    wxString GetValue(int row, int col);
+    virtual void StartingClick();
  
      /**
  
      /**
-
+        If the editor is enabled by pressing keys on the grid, this will be
+        called to let the editor do something about that first key if desired.
      */
      */
-    bool GetValueAsBool(int row, int col);
+    virtual void StartingKey(wxKeyEvent& event);
+
+protected:
  
      /**
  
      /**
-        For user defined types
+        The destructor is private because only DecRef() can delete us.
      */
      */
-    void* GetValueAsCustom(int row, int col,
-                           const wxString& typeName);
+    virtual ~wxGridCellEditor();
+};
  
  
-    /**
+/**
+    @class wxGridCellBoolEditor
  
  
-    */
-    double GetValueAsDouble(int row, int col);
+    Grid cell editor for boolean data.
  
  
-    /**
+    @library{wxadv}
+    @category{grid}
  
  
+    @see wxGridCellEditor, wxGridCellChoiceEditor, wxGridCellFloatEditor,
+         wxGridCellNumberEditor, wxGridCellTextEditor
+*/
+class wxGridCellBoolEditor : public wxGridCellEditor
+{
+public:
+    /**
+        Default constructor.
      */
      */
-    long GetValueAsLong(int row, int col);
+    wxGridCellBoolEditor();
  
      /**
  
      /**
-
+        Returns @true if the given @a value is equal to the string
+        representation of the truth value we currently use (see
+        UseStringValues()).
      */
      */
-    wxGrid* GetView() const;
+    static bool IsTrueValue(const wxString& value);
  
      /**
  
      /**
-
+        This method allows you to customize the values returned by GetValue()
+        for the cell using this editor. By default, the default values of the
+        arguments are used, i.e. @c "1" is returned if the cell is checked and
+        an empty string otherwise.
      */
      */
-    bool InsertCols(size_t pos = 0, size_t numCols = 1);
+    static void UseStringValues(const wxString& valueTrue = "1",
+                                const wxString& valueFalse = wxEmptyString);
+};
  
  
-    /**
+/**
+    @class wxGridCellChoiceEditor
  
  
-    */
-    bool InsertRows(size_t pos = 0, size_t numRows = 1);
+    Grid cell editor for string data providing the user a choice from a list of
+    strings.
  
  
-    /**
+    @library{wxadv}
+    @category{grid}
  
  
+    @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellFloatEditor,
+         wxGridCellNumberEditor, wxGridCellTextEditor
+*/
+class wxGridCellChoiceEditor : public wxGridCellEditor
+{
+public:
+    /**
+        @param count
+            Number of strings from which the user can choose.
+        @param choices
+            An array of strings from which the user can choose.
+        @param allowOthers
+            If allowOthers is @true, the user can type a string not in choices
+            array.
      */
      */
-    bool IsEmptyCell(int row, int col);
-
+    wxGridCellChoiceEditor(size_t count = 0,
+                           const wxString choices[] = NULL,
+                           bool allowOthers = false);
      /**
      /**
-        these functions take ownership of the pointer
+        @param choices
+            An array of strings from which the user can choose.
+        @param allowOthers
+            If allowOthers is @true, the user can type a string not in choices
+            array.
      */
      */
-    void SetAttr(wxGridCellAttr* attr, int row, int col);
+    wxGridCellChoiceEditor(const wxArrayString& choices,
+                           bool allowOthers = false);
  
      /**
  
      /**
-        Attribute handling
-        give us the attr provider to use - we take ownership of the pointer
+        Parameters string format is "item1[,item2[...,itemN]]"
      */
      */
-    void SetAttrProvider(wxGridCellAttrProvider* attrProvider);
+    virtual void SetParameters(const wxString& params);
+};
  
  
-    /**
+/**
+    @class wxGridCellTextEditor
  
  
-    */
-    void SetColAttr(wxGridCellAttr* attr, int col);
+    Grid cell editor for string/text data.
  
  
-    /**
-        , @e wxString)
-    */
-    void SetColLabelValue() const;
+    @library{wxadv}
+    @category{grid}
  
  
+    @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellChoiceEditor,
+         wxGridCellFloatEditor, wxGridCellNumberEditor
+*/
+class wxGridCellTextEditor : public wxGridCellEditor
+{
+public:
      /**
      /**
-
+        Default constructor.
      */
      */
-    void SetRowAttr(wxGridCellAttr* attr, int row);
+    wxGridCellTextEditor();
  
      /**
  
      /**
-        , @e wxString)
+        The parameters string format is "n" where n is a number representing
+        the maximum width.
      */
      */
-    void SetRowLabelValue() const;
+    virtual void SetParameters(const wxString& params);
+};
  
  
-    /**
+/**
+    @class wxGridCellFloatEditor
  
  
-    */
-    void SetValue(int row, int col, const wxString& value);
+    The editor for floating point numbers data.
  
  
-    /**
+    @library{wxadv}
+    @category{grid}
  
  
+    @see wxGridCellEditor, wxGridCellNumberEditor, wxGridCellBoolEditor,
+    wxGridCellTextEditor, wxGridCellChoiceEditor
+*/
+class wxGridCellFloatEditor : public wxGridCellTextEditor
+{
+public:
+    /**
+        @param width
+            Minimum number of characters to be shown.
+        @param precision
+            Number of digits after the decimal dot.
      */
      */
-    void SetValueAsBool(int row, int col, bool value);
+    wxGridCellFloatEditor(int width = -1, int precision = -1);
  
      /**
  
      /**
-
+        Parameters string format is "width,precision"
      */
      */
-    void SetValueAsCustom(int row, int col, const wxString& typeName,
-                          void* value);
+    virtual void SetParameters(const wxString& params);
+};
  
  
-    /**
+/**
+    @class wxGridCellNumberEditor
  
  
-    */
-    void SetValueAsDouble(int row, int col, double value);
+    Grid cell editor for numeric integer data.
  
  
-    /**
+    @library{wxadv}
+    @category{grid}
  
  
+    @see wxGridCellEditor, wxGridCellBoolEditor, wxGridCellChoiceEditor,
+         wxGridCellFloatEditor, wxGridCellTextEditor
+*/
+class wxGridCellNumberEditor : public wxGridCellTextEditor
+{
+public:
+    /**
+        Allows you to specify the range for acceptable data. Values equal to
+        -1 for both @a min and @a max indicate that no range checking should be
+        done.
      */
      */
-    void SetValueAsLong(int row, int col, long value);
+    wxGridCellNumberEditor(int min = -1, int max = -1);
+
  
      /**
  
      /**
-        Overriding these is optional
+        Parameters string format is "min,max".
      */
      */
-    void SetView(wxGrid* grid);
+    virtual void SetParameters(const wxString& params);
  
  
-    /**
+protected:
  
  
+    /**
+        If the return value is @true, the editor uses a wxSpinCtrl to get user
+        input, otherwise it uses a wxTextCtrl.
      */
      */
-    void UpdateAttrCols(size_t pos, int numCols);
+    bool HasRange() const;
  
      /**
  
      /**
-        change row/col number in attribute if needed
+        String representation of the value.
      */
      */
-    void UpdateAttrRows(size_t pos, int numRows);
+    wxString GetString() const;
  };
  
  
  
  /**
  };
  
  
  
  /**
-    @class wxGridCellEditor
-    @wxheader{grid.h}
+    @class wxGridCellAttr
  
  
-    This class is responsible for providing and manipulating
-    the in-place edit controls for the grid.  Instances of wxGridCellEditor
-    (actually, instances of derived classes since it is an abstract class) can be
-    associated with the cell attributes for individual cells, rows, columns, or
-    even for the entire grid.
+    This class can be used to alter the cells' appearance in the grid by
+    changing their attributes from the defaults. An object of this class may be
+    returned by wxGridTableBase::GetAttr().
  
      @library{wxadv}
  
      @library{wxadv}
-    @category{FIXME}
-
-    @see wxGridCellTextEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
-    wxGridCellNumberEditor, wxGridCellChoiceEditor
+    @category{grid}
  */
  */
-class wxGridCellEditor
+class wxGridCellAttr
  {
  public:
      /**
  {
  public:
      /**
+        Default constructor.
+    */
+    wxGridCellAttr(wxGridCellAttr* attrDefault = NULL);
+    /**
+        Constructor specifying some of the often used attributes.
+    */
+    wxGridCellAttr(const wxColour& colText, const wxColour& colBack,
+                   const wxFont& font, int hAlign, int vAlign);
  
  
+    /**
+        Creates a new copy of this object.
      */
      */
-    wxGridCellEditor();
+    wxGridCellAttr* Clone() const;
  
      /**
  
      /**
-        The dtor is private because only DecRef() can delete us.
+        This class is reference counted: it is created with ref count of 1, so
+        calling DecRef() once will delete it. Calling IncRef() allows to lock
+        it until the matching DecRef() is called.
      */
      */
-    ~wxGridCellEditor();
+    void DecRef();
  
      /**
  
      /**
-        Fetch the value from the table and prepare the edit control
-        to begin editing. Set the focus to the edit control.
+        See SetAlignment() for the returned values.
      */
      */
-    void BeginEdit(int row, int col, wxGrid* grid);
+    void GetAlignment(int* hAlign, int* vAlign) const;
  
      /**
  
      /**
-        Create a new object which is the copy of this one.
+        Returns the background colour.
      */
      */
-    wxGridCellEditor* Clone() const;
+    const wxColour& GetBackgroundColour() const;
  
      /**
  
      /**
-        Creates the actual edit control.
+        Returns the cell editor.
      */
      */
-    void Create(wxWindow* parent, wxWindowID id,
-                wxEvtHandler* evtHandler);
+    wxGridCellEditor* GetEditor(const wxGrid* grid, int row, int col) const;
  
      /**
  
      /**
-        Final cleanup.
+        Returns the font.
      */
      */
-    void Destroy();
+    const wxFont& GetFont() const;
  
      /**
  
      /**
-        Complete the editing of the current cell. Returns @true if the value has
-        changed. If necessary, the control may be destroyed.
+        Returns the cell renderer.
      */
      */
-    bool EndEdit(int row, int col, wxGrid* grid);
+    wxGridCellRenderer* GetRenderer(const wxGrid* grid, int row, int col) const;
  
      /**
  
      /**
-        Some types of controls on some platforms may need some help
-        with the Return key.
+        Returns the text colour.
      */
      */
-    void HandleReturn(wxKeyEvent& event);
+    const wxColour& GetTextColour() const;
  
      /**
  
      /**
+        Returns @true if this attribute has a valid alignment set.
+    */
+    bool HasAlignment() const;
  
  
+    /**
+        Returns @true if this attribute has a valid background colour set.
      */
      */
-    bool IsCreated();
+    bool HasBackgroundColour() const;
  
      /**
  
      /**
-        Draws the part of the cell not occupied by the control: the base class
-        version just fills it with background colour from the attribute.
+        Returns @true if this attribute has a valid cell editor set.
      */
      */
-    void PaintBackground(const wxRect& rectCell,
-                         wxGridCellAttr* attr);
+    bool HasEditor() const;
  
      /**
  
      /**
-        Reset the value in the control back to its starting value.
+        Returns @true if this attribute has a valid font set.
      */
      */
-    void Reset();
+    bool HasFont() const;
  
      /**
  
      /**
-        Size and position the edit control.
+        Returns @true if this attribute has a valid cell renderer set.
      */
      */
-    void SetSize(const wxRect& rect);
+    bool HasRenderer() const;
  
      /**
  
      /**
-        Show or hide the edit control, use the specified attributes to set
-        colours/fonts for it.
+        Returns @true if this attribute has a valid text colour set.
      */
      */
-    void Show(bool show, wxGridCellAttr* attr = NULL);
+    bool HasTextColour() const;
  
      /**
  
      /**
-        If the editor is enabled by clicking on the cell, this method will be
-        called.
+        This class is reference counted: it is created with ref count of 1, so
+        calling DecRef() once will delete it. Calling IncRef() allows to lock
+        it until the matching DecRef() is called.
      */
      */
-    void StartingClick();
+    void IncRef();
  
      /**
  
      /**
-        If the editor is enabled by pressing keys on the grid,
-        this will be called to let the editor do something about
-        that first key if desired.
+        Returns @true if this cell is set as read-only.
      */
      */
-    void StartingKey(wxKeyEvent& event);
-};
+    bool IsReadOnly() const;
  
  
+    /**
+        Sets the alignment. @a hAlign can be one of @c wxALIGN_LEFT,
+        @c wxALIGN_CENTRE or @c wxALIGN_RIGHT and @a vAlign can be one of
+        @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
+    */
+    void SetAlignment(int hAlign, int vAlign);
  
  
+    /**
+        Sets the background colour.
+    */
+    void SetBackgroundColour(const wxColour& colBack);
  
  
-/**
-    @class wxGridCellTextEditor
-    @wxheader{grid.h}
+    /**
+        @todo Needs documentation.
+    */
+    void SetDefAttr(wxGridCellAttr* defAttr);
  
  
-    The editor for string/text data.
+    /**
+        Sets the editor to be used with the cells with this attribute.
+    */
+    void SetEditor(wxGridCellEditor* editor);
  
  
-    @library{wxadv}
-    @category{FIXME}
+    /**
+        Sets the font.
+    */
+    void SetFont(const wxFont& font);
  
  
-    @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
-    wxGridCellNumberEditor, wxGridCellChoiceEditor
-*/
-class wxGridCellTextEditor : public wxGridCellEditor
-{
-public:
      /**
      /**
-        Default constructor.
+        Sets the cell as read-only.
      */
      */
-    wxGridCellTextEditor();
+    void SetReadOnly(bool isReadOnly = true);
  
      /**
  
      /**
-        The parameters string format is "n" where n is a number representing the
-        maximum width.
+        Sets the renderer to be used for cells with this attribute. Takes
+        ownership of the pointer.
      */
      */
-    void SetParameters(const wxString& params);
+    void SetRenderer(wxGridCellRenderer* renderer);
+
+    /**
+        Sets the text colour.
+    */
+    void SetTextColour(const wxColour& colText);
  };
  
  
  
  /**
  };
  
  
  
  /**
-    @class wxGridCellStringRenderer
-    @wxheader{grid.h}
+    @class wxGridTableBase
  
  
-    This class may be used to format string data in a cell; it is the default
-    for string cells.
+    The almost abstract base class for grid tables.
  
  
-    @library{wxadv}
-    @category{FIXME}
+    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 wxGridCellRenderer, wxGridCellNumberRenderer, wxGridCellFloatRenderer,
-    wxGridCellBoolRenderer
+    @see wxGridStringTable
+
+    @library{wxadv}
+    @category{grid}
  */
  */
-class wxGridCellStringRenderer : public wxGridCellRenderer
+class wxGridTableBase : public wxObject
  {
  public:
      /**
  {
  public:
      /**
-        Default constructor
-    */
-    wxGridCellStringRenderer();
-};
+        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.
  
  
-/**
-    @class wxGridCellChoiceEditor
-    @wxheader{grid.h}
+        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;
  
  
-    The editor for string data allowing to choose from a list of strings.
+    /**
+        Must be overridden to return the number of columns in the table.
  
  
-    @library{wxadv}
-    @category{FIXME}
+        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;
  
  
-    @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
-    wxGridCellTextEditor, wxGridCellNumberEditor
-*/
-class wxGridCellChoiceEditor : public wxGridCellEditor
-{
-public:
+    /**
+        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
+     */
      //@{
      //@{
+
      /**
      /**
-        @param count
-            Number of strings from which the user can choose.
-        @param choices
-            An array of strings from which the user can choose.
-        @param allowOthers
-            If allowOthers is @true, the user can type a string not in choices array.
-    */
-    wxGridCellChoiceEditor(size_t count = 0,
-                           const wxString choices[] = NULL,
-                           bool allowOthers = false);
-    wxGridCellChoiceEditor(const wxArrayString& choices,
-                           bool allowOthers = false);
-    //@}
+        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);
  
      /**
  
      /**
-        Parameters string format is "item1[,item2[...,itemN]]"
-    */
-    void SetParameters(const wxString& params);
-};
+        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;
  
  
-/**
-    @class wxGridEditorCreatedEvent
-    @wxheader{grid.h}
+    /**
+        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);
  
  
-    @library{wxadv}
-    @category{FIXME}
-*/
-class wxGridEditorCreatedEvent : public wxCommandEvent
-{
-public:
-    //@{
      /**
      /**
+        Returns true if the value of the given cell can be accessed as if it
+        were of the specified type.
  
  
-    */
-    wxGridEditorCreatedEvent();
-    wxGridEditorCreatedEvent(int id, wxEventType type,
-                             wxObject* obj,
-                             int row,
-                             int col,
-                             wxControl* ctrl);
-    //@}
+        By default the cells can only be accessed as strings. Note that a cell
+        could be accessible in different ways, e.g. a numeric cell may return
+        @true for @c wxGRID_VALUE_NUMBER but also for @c wxGRID_VALUE_STRING
+        indicating that the value can be coerced to a string form.
+     */
+    virtual bool CanGetValueAs(int row, int col, const wxString& typeName);
  
      /**
  
      /**
-        Returns the column at which the event occurred.
-    */
-    int GetCol();
+        Returns true if the value of the given cell can be set as if it were of
+        the specified type.
+
+        @see CanGetValueAs()
+     */
+    virtual bool CanSetValueAs(int row, int col, const wxString& typeName);
  
      /**
  
      /**
-        Returns the edit control.
-    */
-    wxControl* GetControl();
+        Returns the value of the given cell as a long.
+
+        This should only be called if CanGetValueAs() returns @true when called
+        with @c wxGRID_VALUE_NUMBER argument. Default implementation always
+        return 0.
+     */
+    virtual long GetValueAsLong(int row, int col);
  
      /**
  
      /**
-        Returns the row at which the event occurred.
-    */
-    int GetRow();
+        Returns the value of the given cell as a double.
+
+        This should only be called if CanGetValueAs() returns @true when called
+        with @c wxGRID_VALUE_FLOAT argument. Default implementation always
+        return 0.0.
+     */
+    virtual double GetValueAsDouble(int row, int col);
  
      /**
  
      /**
-        Sets the column at which the event occurred.
-    */
-    void SetCol(int col);
+        Returns the value of the given cell as a boolean.
+
+        This should only be called if CanGetValueAs() returns @true when called
+        with @c wxGRID_VALUE_BOOL argument. Default implementation always
+        return false.
+     */
+    virtual bool GetValueAsBool(int row, int col);
  
      /**
  
      /**
-        Sets the edit control.
-    */
-    void SetControl(wxControl* ctrl);
+        Returns the value of the given cell as a user-defined type.
+
+        This should only be called if CanGetValueAs() returns @true when called
+        with @a typeName. Default implementation always return @NULL.
+     */
+    virtual void *GetValueAsCustom(int row, int col, const wxString& typeName);
  
      /**
  
      /**
-        Sets the row at which the event occurred.
-    */
-    void SetRow(int row);
-};
+        Sets the value of the given cell as a long.
  
  
+        This should only be called if CanSetValueAs() returns @true when called
+        with @c wxGRID_VALUE_NUMBER argument. Default implementation doesn't do
+        anything.
+     */
+    virtual void SetValueAsLong(int row, int col, long value);
  
  
+    /**
+        Sets the value of the given cell as a double.
  
  
-/**
-    @class wxGridRangeSelectEvent
-    @wxheader{grid.h}
+        This should only be called if CanSetValueAs() returns @true when called
+        with @c wxGRID_VALUE_FLOAT argument. Default implementation doesn't do
+        anything.
+     */
+    virtual void SetValueAsDouble(int row, int col, double value);
  
  
+    /**
+        Sets the value of the given cell as a boolean.
+
+        This should only be called if CanSetValueAs() returns @true when called
+        with @c wxGRID_VALUE_BOOL argument. Default implementation doesn't do
+        anything.
+     */
+    virtual void SetValueAsBool( int row, int col, bool value );
  
  
-    @library{wxadv}
-    @category{FIXME}
-*/
-class wxGridRangeSelectEvent : public wxNotifyEvent
-{
-public:
-    //@{
      /**
      /**
+        Sets the value of the given cell as a user-defined type.
+
+        This should only be called if CanSetValueAs() returns @true when called
+        with @a typeName. Default implementation doesn't do anything.
+     */
+    virtual void SetValueAsCustom(int row, int col, const wxString& typeName,
+                                  void *value);
  
  
-    */
-    wxGridRangeSelectEvent();
-    wxGridRangeSelectEvent(int id, wxEventType type,
-                           wxObject* obj,
-                           const wxGridCellCoords& topLeft,
-                           const wxGridCellCoords& bottomRight,
-                           bool sel = true,
-                           bool control = false,
-                           bool shift = false,
-                           bool alt = false,
-                           bool meta = false);
      //@}
  
      //@}
  
+
      /**
      /**
-        Returns @true if the Alt key was down at the time of the event.
-    */
-    bool AltDown();
+        Called by the grid when the table is associated with it.
+
+        The default implementation stores the pointer and returns it from its
+        GetView() and so only makes sense if the table cannot be associated
+        with more than one grid at a time.
+     */
+    virtual void SetView(wxGrid *grid);
  
      /**
  
      /**
-        Returns @true if the Control key was down at the time of the event.
-    */
-    bool ControlDown();
+        Returns the last grid passed to SetView().
+     */
+    virtual wxGrid *GetView() const;
+
  
      /**
  
      /**
-        Top left corner of the rectangular area that was (de)selected.
-    */
-    wxGridCellCoords GetBottomRightCoords();
+        @name Table Structure Modifiers
+
+        Notice that none of these functions are pure virtual as they don't have
+        to be implemented if the table structure is never modified after
+        creation, i.e. neither rows nor columns are never added or deleted but
+        that you do need to implement them if they are called, i.e. if your
+        code either calls them directly or uses the matching wxGrid methods, as
+        by default they simply do nothing which is definitely inappropriate.
+     */
+    //@{
  
      /**
  
      /**
-        Bottom row of the rectangular area that was (de)selected.
-    */
-    int GetBottomRow();
+        Clear the table contents.
+
+        This method is used by wxGrid::ClearGrid().
+     */
+    virtual void Clear();
  
      /**
  
      /**
-        Left column of the rectangular area that was (de)selected.
-    */
-    int GetLeftCol();
+        Insert additional rows into the table.
+
+        @param pos
+            The position of the first new row.
+        @param numRows
+            The number of rows to insert.
+     */
+    virtual bool InsertRows(size_t pos = 0, size_t numRows = 1);
  
      /**
  
      /**
-        Right column of the rectangular area that was (de)selected.
-    */
-    int GetRightCol();
+        Append additional rows at the end of the table.
+
+        This method is provided in addition to InsertRows() as some data models
+        may only support appending rows to them but not inserting them at
+        arbitrary locations. In such case you may implement this method only
+        and leave InsertRows() unimplemented.
+
+        @param numRows
+            The number of rows to add.
+     */
+    virtual bool AppendRows(size_t numRows = 1);
  
      /**
  
      /**
-        Top left corner of the rectangular area that was (de)selected.
-    */
-    wxGridCellCoords GetTopLeftCoords();
+        Delete rows from the table.
+
+        @param pos
+            The first row to delete.
+        @param numRows
+            The number of rows to delete.
+     */
+    virtual bool DeleteRows(size_t pos = 0, size_t numRows = 1);
  
      /**
  
      /**
-        Top row of the rectangular area that was (de)selected.
-    */
-    int GetTopRow();
+        Exactly the same as InsertRows() but for columns.
+     */
+    virtual bool InsertCols(size_t pos = 0, size_t numCols = 1);
  
      /**
  
      /**
-        Returns @true if the Meta key was down at the time of the event.
-    */
-    bool MetaDown();
+        Exactly the same as AppendRows() but for columns.
+     */
+    virtual bool AppendCols(size_t numCols = 1);
  
      /**
  
      /**
-        Returns @true if the area was selected, @false otherwise.
-    */
-    bool Selecting();
+        Exactly the same as DeleteRows() but for columns.
+     */
+    virtual bool DeleteCols(size_t pos = 0, size_t numCols = 1);
+
+    //@}
  
      /**
  
      /**
-        Returns @true if the Shift key was down at the time of the event.
-    */
-    bool ShiftDown();
-};
+        @name Table Row and Column Labels
  
  
+        By default the numbers are used for labeling rows and Latin letters for
+        labeling columns. If the table has more than 26 columns, the pairs of
+        letters are used starting from the 27-th one and so on, i.e. the
+        sequence of labels is A, B, ..., Z, AA, AB, ..., AZ, BA, ..., ..., ZZ,
+        AAA, ...
+     */
+    //@{
  
  
+    /**
+        Return the label of the specified row.
+     */
+    virtual wxString GetRowLabelValue(int row);
  
  
-/**
-    @class wxGridCellRenderer
-    @wxheader{grid.h}
+    /**
+        Return the label of the specified column.
+     */
+    virtual wxString GetColLabelValue(int col);
  
  
-    This class is responsible for actually drawing the cell
-    in the grid. You may pass it to the wxGridCellAttr (below) to change the
-    format of one given cell or to wxGrid::SetDefaultRenderer() to change the
-    view of all cells. This is an abstract class, and you will normally use one of
-    the
-    predefined derived classes or derive your own class from it.
+    /**
+        Set the given label for the specified row.
  
  
-    @library{wxadv}
-    @category{FIXME}
+        The default version does nothing, i.e. the label is not stored. You
+        must override this method in your derived class if you wish
+        wxGrid::SetRowLabelValue() to work.
+     */
+    virtual void SetRowLabelValue(int row, const wxString& label);
  
  
-    @see wxGridCellStringRenderer, wxGridCellNumberRenderer,
-    wxGridCellFloatRenderer, wxGridCellBoolRenderer
-*/
-class wxGridCellRenderer
-{
-public:
      /**
      /**
+        Exactly the same as SetRowLabelValue() but for columns.
+     */
+    virtual void SetColLabelValue(int col, const wxString& label);
+
+    //@}
  
  
-    */
-    wxGridCellRenderer* Clone() const;
  
      /**
  
      /**
-        Draw the given cell on the provided DC inside the given rectangle
-        using the style specified by the attribute and the default or selected
-        state corresponding to the isSelected value.
-        This pure virtual function has a default implementation which will
-        prepare the DC using the given attribute: it will draw the rectangle
-        with the background colour from attr and set the text colour and font.
-    */
-    void Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
-              const wxRect& rect, int row, int col,
-              bool isSelected);
+        @name Attributes Management
+
+        By default the attributes management is delegated to
+        wxGridCellAttrProvider class. You may override the methods in this
+        section to handle the attributes directly if, for example, they can be
+        computed from the cell values.
+     */
+    //@{
  
      /**
  
      /**
-        Get the preferred size of the cell for its contents.
-    */
-    wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
-                       int row, int col);
-};
+        Associate this attributes provider with the table.
+
+        The table takes ownership of @a attrProvider pointer and will delete it
+        when it doesn't need it any more. The pointer can be @NULL, however
+        this won't disable attributes management in the table but will just
+        result in a default attributes being recreated the next time any of the
+        other functions in this section is called. To completely disable the
+        attributes support, should this be needed, you need to override
+        CanHaveAttributes() to return @false.
+     */
+    void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
+
+    /**
+        Returns the attribute provider currently being used.
+
+        This function may return @NULL if the attribute provider hasn't been
+        neither associated with this table by SetAttrProvider() nor created on
+        demand by any other methods.
+     */
+    wxGridCellAttrProvider *GetAttrProvider() const;
+
+    /**
+        Return the attribute for the given cell.
+
+        By default this function is simply forwarded to
+        wxGridCellAttrProvider::GetAttr() but it may be overridden to handle
+        attributes directly in the table.
+     */
+    virtual wxGridCellAttr *GetAttr(int row, int col,
+                                    wxGridCellAttr::wxAttrKind kind);
+
+    /**
+        Set attribute of the specified cell.
+
+        By default this function is simply forwarded to
+        wxGridCellAttrProvider::SetAttr().
+
+        The table takes ownership of @a attr, i.e. will call DecRef() on it.
+     */
+    virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
+
+    /**
+        Set attribute of the specified row.
  
  
+        By default this function is simply forwarded to
+        wxGridCellAttrProvider::SetRowAttr().
  
  
+        The table takes ownership of @a attr, i.e. will call DecRef() on it.
+     */
+    virtual void SetRowAttr(wxGridCellAttr *attr, int row);
+
+    /**
+        Set attribute of the specified column.
+
+        By default this function is simply forwarded to
+        wxGridCellAttrProvider::SetColAttr().
+
+        The table takes ownership of @a attr, i.e. will call DecRef() on it.
+     */
+    virtual void SetColAttr(wxGridCellAttr *attr, int col);
+
+    //@}
+
+    /**
+        Returns true if this table supports attributes or false otherwise.
+
+        By default, the table automatically creates a wxGridCellAttrProvider
+        when this function is called if it had no attribute provider before and
+        returns @true.
+     */
+    virtual bool CanHaveAttributes();
+};
  
  /**
  
  /**
-    @class wxGridCellNumberEditor
-    @wxheader{grid.h}
+    @class wxGridSizesInfo
  
  
-    The editor for numeric integer data.
+    wxGridSizesInfo stores information about sizes of all wxGrid rows or
+    columns.
  
  
-    @library{wxadv}
-    @category{FIXME}
+    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.
  
  
-    @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellBoolEditor,
-    wxGridCellTextEditor, wxGridCellChoiceEditor
-*/
-class wxGridCellNumberEditor : public wxGridCellTextEditor
+    This structure is particularly useful for serializing the sizes of all
+    wxGrid elements at once.
+
+    @library{wxadv}
+    @category{grid}
+ */
+struct wxGridSizesInfo
  {
  {
-public:
      /**
      /**
-        Allows to specify the range for acceptable data;
-        if min == max == -1, no range checking is done
-    */
-    wxGridCellNumberEditor(int min = -1, int max = -1);
+        Default constructor.
+
+        m_sizeDefault and m_customSizes must be initialized later.
+     */
+    wxGridSizesInfo();
  
      /**
  
      /**
-        String representation of the value.
-    */
-    wxString GetString() const;
+        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);
  
      /**
  
      /**
-        If the return value is @true, the editor uses a wxSpinCtrl to get user input,
-        otherwise it uses a wxTextCtrl.
-    */
-    bool HasRange() const;
+        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;
  
      /**
  
      /**
-        Parameters string format is "min,max".
-    */
-    void SetParameters(const wxString& params);
-};
+        Map with element indices as keys and their sizes as values.
  
  
+        This map only contains the elements with non-default size.
+     */
+    wxUnsignedToIntHashMap m_customSizes;
+};
  
  
  /**
  
  
  /**
-    @class wxGridSizeEvent
-    @wxheader{grid.h}
+    @class wxGrid
  
  
-    This event class contains information about a row/column resize event.
+    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 rendereing 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}
  
      @library{wxadv}
-    @category{FIXME}
+    @category{grid}
+
+    @see @ref overview_grid, wxGridUpdateLocker
  */
  */
-class wxGridSizeEvent : public wxNotifyEvent
+class wxGrid : public wxScrolledWindow
  {
  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.
+
+            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
+    };
+
+
+    /**
+        @name Constructors and Initialization
+     */
      //@{
      //@{
+
+    /**
+        Default constructor.
+
+        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.
      */
      */
-    wxGridSizeEvent();
-    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);
-    //@}
+    wxGrid(wxWindow* parent, wxWindowID id,
+           const wxPoint& pos = wxDefaultPosition,
+           const wxSize& size = wxDefaultSize,
+           long style = wxWANTS_CHARS,
+           const wxString& name = wxGridNameStr);
  
      /**
  
      /**
-        Returns @true if the Alt key was down at the time of the event.
+        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()).
      */
      */
-    bool AltDown();
+    virtual ~wxGrid();
  
      /**
  
      /**
-        Returns @true if the Control key was down at the time of the event.
-    */
-    bool ControlDown();
+        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);
  
      /**
  
      /**
-        Position in pixels at which the event occurred.
+        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().
      */
      */
-    wxPoint GetPosition();
+    bool CreateGrid(int numRows, int numCols,
+                    wxGridSelectionModes selmode = wxGridSelectCells);
  
      /**
  
      /**
-        Row or column at that was resized.
+        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.
      */
      */
-    int GetRowOrCol();
+    bool SetTable(wxGridTableBase* table, bool takeOwnership = false,
+                  wxGridSelectionModes selmode = wxGridSelectCells);
+
+    //@}
+
  
      /**
  
      /**
-        Returns @true if the Meta key was down at the time of the event.
-    */
-    bool MetaDown();
+        @name Grid Line Formatting
+     */
+    //@{
  
      /**
  
      /**
-        Returns @true if the Shift key was down at the time of the event.
+        Turns the drawing of grid lines on or off.
      */
      */
-    bool ShiftDown();
-};
+    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.
  
  
-/**
-    @class wxGridCellNumberRenderer
-    @wxheader{grid.h}
+        See GetRowGridLinePen() for an example.
+    */
+    virtual wxPen GetColGridLinePen(int col);
  
  
-    This class may be used to format integer data in a cell.
+    /**
+        Returns the pen used for grid lines.
  
  
-    @library{wxadv}
-    @category{FIXME}
+        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();
  
  
-    @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
-    wxGridCellBoolRenderer
-*/
-class wxGridCellNumberRenderer : public wxGridCellStringRenderer
-{
-public:
      /**
      /**
-        Default constructor
+        Returns the colour used for grid lines.
+
+        @see GetDefaultGridLinePen()
      */
      */
-    wxGridCellNumberRenderer();
-};
+    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.
  
  
-/**
-    @class wxGridCellAttr
-    @wxheader{grid.h}
+        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);
  
  
-    This class can be used to alter the cells' appearance in
-    the grid by changing their colour/font/... from default. An object of this
-    class may be returned by wxGridTableBase::GetAttr.
+    /**
+        Returns @true if drawing of grid lines is turned on, @false otherwise.
+    */
+    bool GridLinesEnabled() const;
  
  
-    @library{wxadv}
-    @category{FIXME}
-*/
-class wxGridCellAttr
-{
-public:
-    //@{
      /**
      /**
-        Constructor specifying some of the often used attributes.
+        Sets the colour used to draw grid lines.
      */
      */
-    wxGridCellAttr();
-    wxGridCellAttr(const wxColour& colText,
-                   const wxColour& colBack,
-                   const wxFont& font,
-                   int hAlign, int vAlign);
+    void SetGridLineColour(const wxColour& colour);
+
      //@}
  
      //@}
  
+
      /**
      /**
-        Creates a new copy of this object.
-    */
-    wxGridCellAttr* Clone() const;
+        @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 DecRef();
+    void GetColLabelAlignment(int* horiz, int* vert) const;
  
      /**
  
      /**
-        See SetAlignment() for the returned values.
+        Returns the orientation of the column labels (either @c wxHORIZONTAL or
+        @c wxVERTICAL).
      */
      */
-    void GetAlignment(int* hAlign, int* vAlign) const;
+    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.
      */
      */
-    const wxColour GetBackgroundColour() const;
+    wxString GetColLabelValue(int col) const;
  
      /**
  
      /**
-
+        Returns the colour used for the background of row and column labels.
      */
      */
-    wxGridCellEditor* GetEditor(wxGrid* grid, int row, int col) const;
+    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.
      */
      */
-    const wxFont GetFont() const;
+    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.
      */
      */
-    wxGridCellRenderer* GetRenderer(wxGrid* grid, int row, int col) const;
+    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.
      */
      */
-    const wxColour GetTextColour() const;
+    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.
      */
      */
-    bool HasAlignment() const;
+    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.
      */
      */
-    bool HasBackgroundColour() const;
+    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.
      */
      */
-    bool HasEditor() const;
+    void SetColLabelAlignment(int horiz, int vert);
  
      /**
  
      /**
-
+        Sets the orientation of the column labels (either @c wxHORIZONTAL or
+        @c wxVERTICAL).
      */
      */
-    bool HasFont() const;
+    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.
      */
      */
-    bool HasRenderer() const;
+    void SetColLabelValue(int col, const wxString& value);
  
      /**
  
      /**
-        accessors
+        Sets the background colour for row and column labels.
      */
      */
-    bool HasTextColour() const;
+    void SetLabelBackgroundColour(const wxColour& colour);
  
      /**
  
      /**
-        This class is ref counted: it is created with ref count of 1, so
-        calling DecRef() once will delete it. Calling IncRef() allows to lock
-        it until the matching DecRef() is called
+        Sets the font for row and column labels.
      */
      */
-    void IncRef();
+    void SetLabelFont(const wxFont& font);
  
      /**
  
      /**
-
+        Sets the colour for row and column label text.
      */
      */
-    bool IsReadOnly() const;
+    void SetLabelTextColour(const wxColour& colour);
  
      /**
  
      /**
-        Sets the alignment. @a hAlign can be one of @c wxALIGN_LEFT,
-        @c wxALIGN_CENTRE or @c wxALIGN_RIGHT and @a vAlign can be one
+        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.
      */
          of @c wxALIGN_TOP, @c wxALIGN_CENTRE or @c wxALIGN_BOTTOM.
      */
-    void SetAlignment(int hAlign, int vAlign);
+    void SetRowLabelAlignment(int horiz, int vert);
  
      /**
  
      /**
-        Sets the background colour.
+        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 SetBackgroundColour(const wxColour& colBack);
+    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 SetDefAttr(wxGridCellAttr* defAttr);
+    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.
+
+        Also note that currently @c wxEVT_GRID_LABEL_LEFT_DCLICK and
+        @c wxEVT_GRID_LABEL_RIGHT_DCLICK events are 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);
+
+    //@}
  
  
-    */
-    void SetEditor(wxGridCellEditor* editor);
  
      /**
  
      /**
-        Sets the font.
-    */
-    void SetFont(const wxFont& font);
+        @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 SetReadOnly(bool isReadOnly = true);
+    void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
  
      /**
  
      /**
-        takes ownership of the pointer
+        Returns the background colour of the cell at the specified location.
      */
      */
-    void SetRenderer(wxGridCellRenderer* renderer);
+    wxColour GetCellBackgroundColour(int row, int col) const;
  
      /**
  
      /**
-        Sets the text colour.
+        Returns the font for text in the grid cell at the specified location.
      */
      */
-    void SetTextColour(const wxColour& colText);
-};
+    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.
  
  
-/**
-    @class wxGridCellBoolRenderer
-    @wxheader{grid.h}
+        Horizontal alignment will be one of @c wxALIGN_LEFT, @c wxALIGN_CENTRE
+        or @c wxALIGN_RIGHT.
  
  
-    This class may be used to format boolean data in a cell.
-    for string cells.
+        Vertical alignment will be one of @c wxALIGN_TOP, @c wxALIGN_CENTRE or
+        @c wxALIGN_BOTTOM.
  
  
-    @library{wxadv}
-    @category{FIXME}
+        @see SetDefaultCellAlignment()
+    */
+    void GetDefaultCellAlignment(int* horiz, int* vert) const;
  
  
-    @see wxGridCellRenderer, wxGridCellStringRenderer, wxGridCellFloatRenderer,
-    wxGridCellNumberRenderer
-*/
-class wxGridCellBoolRenderer : public wxGridCellRenderer
-{
-public:
      /**
      /**
-        Default constructor
+        Returns the current default background colour for grid cells.
      */
      */
-    wxGridCellBoolRenderer();
-};
+    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;
  
  
-/**
-    @class wxGridEvent
-    @wxheader{grid.h}
+    /**
+        Sets the horizontal and vertical alignment for grid cell text at the
+        specified location.
  
  
-    This event class contains information about various grid events.
+        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);
  
  
-    @library{wxadv}
-    @category{FIXME}
-*/
-class wxGridEvent : public wxNotifyEvent
-{
-public:
-    //@{
      /**
      /**
+        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.
      */
      */
-    wxGridEvent();
-    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);
-    //@}
+    void SetDefaultCellAlignment(int horiz, int vert);
  
      /**
  
      /**
-        Returns @true if the Alt key was down at the time of the event.
+        Sets the default background colour for grid cells.
      */
      */
-    bool AltDown();
+    void SetDefaultCellBackgroundColour(const wxColour& colour);
  
      /**
  
      /**
-        Returns @true if the Control key was down at the time of the event.
+        Sets the default font to be used for grid cell text.
      */
      */
-    bool ControlDown();
+    void SetDefaultCellFont(const wxFont& font);
  
      /**
  
      /**
-        Column at which the event occurred.
+        Sets the current default colour for grid cell text.
      */
      */
-    int GetCol();
+    void SetDefaultCellTextColour(const wxColour& colour);
+
+    //@}
+
  
      /**
  
      /**
-        Position in pixels at which the event occurred.
+        @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.
      */
      */
-    wxPoint GetPosition();
+    bool CanEnableCellControl() const;
  
      /**
  
      /**
-        Row at which the event occurred.
+        Disables in-place editing of grid cells.
+
+        Equivalent to calling EnableCellEditControl(@false).
      */
      */
-    int GetRow();
+    void DisableCellEditControl();
  
      /**
  
      /**
-        Returns @true if the Meta key was down at the time of the event.
+        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.
      */
      */
-    bool MetaDown();
+    void EnableCellEditControl(bool enable = true);
  
      /**
  
      /**
-        Returns @true if the user is selecting grid cells, @false -- if
-        deselecting.
+        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.
      */
      */
-    bool Selecting();
+    void EnableEditing(bool edit);
  
      /**
  
      /**
-        Returns @true if the Shift key was down at the time of the event.
+        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.
      */
      */
-    bool ShiftDown();
-};
+    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.
  
  
-/**
-    @class wxGridCellFloatEditor
-    @wxheader{grid.h}
+        The caller must call DecRef() on the returned pointer.
+    */
+    wxGridCellRenderer* GetCellRenderer(int row, int col) const;
  
  
-    The editor for floating point numbers data.
+    /**
+        Returns the string contained in the cell at the specified location.
  
  
-    @library{wxadv}
-    @category{FIXME}
+        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 wxGridCellEditor, wxGridCellNumberEditor, wxGridCellBoolEditor,
-    wxGridCellTextEditor, wxGridCellChoiceEditor
-*/
-class wxGridCellFloatEditor : public wxGridCellTextEditor
-{
-public:
+        See wxGridTableBase::CanGetValueAs() and the @ref overview_grid for
+        more information.
+    */
+    wxString GetCellValue(int row, int col) const;
      /**
      /**
-        @param width
-            Minimum number of characters to be shown.
-        @param precision
-            Number of digits after the decimal dot.
+        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.
      */
      */
-    wxGridCellFloatEditor(int width = -1, int precision = -1);
+    wxString GetCellValue(const wxGridCellCoords& coords) const;
  
      /**
  
      /**
-        Parameters string format is "width,precision"
+        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.
      */
      */
-    void SetParameters(const wxString& params);
-};
+    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.
  
  
-/**
-    @class wxGrid
-    @wxheader{grid.h}
+        Notice that the same may be achieved in a usually simpler way by
+        associating a custom editor with the given cell or cells.
  
  
-    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_gridoverview 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.
-
-    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.
-
-    wxGridCellEditor is the abstract base
-    class for editing the value of a cell. The following editors are
-    predefined:
-    wxGridCellTextEditor
-    wxGridCellBoolEditor
-    wxGridCellChoiceEditor
-    wxGridCellNumberEditor.
+        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.
  
  
-    @library{wxadv}
-    @category{miscwnd}
+        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.
  
  
-    @see @ref overview_gridoverview "wxGrid overview"
-*/
-class wxGrid : public wxScrolledWindow
-{
-public:
-    //@{
-    /**
-        Constructor to create a grid object. Call either CreateGrid() or
-        SetTable() directly after this to initialize the grid before using
-        it.
+        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.
      */
      */
-    wxGrid();
-    wxGrid(wxWindow* parent, wxWindowID id,
-           const wxPoint& pos = wxDefaultPosition,
-           const wxSize& size = wxDefaultSize,
-           long style = wxWANTS_CHARS,
-           const wxString& name = wxPanelNameStr);
-    //@}
+    wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const;
  
      /**
  
      /**
-        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 wxGrid::SetTable).
+        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.
      */
      */
-    ~wxGrid();
+    virtual wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
  
      /**
  
      /**
-        Appends one or more new columns to the right of the grid and returns @true if
-        successful. The 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.
+        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.
      */
      */
-    bool AppendCols(int numCols = 1, bool updateLabels = true);
+    wxGridCellRenderer* GetDefaultRenderer() const;
  
      /**
  
      /**
-        Appends one or more new rows to the bottom of the grid and returns @true if
-        successful. The 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.
+        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.
      */
      */
-    bool AppendRows(int numRows = 1, bool updateLabels = true);
+    virtual wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
  
      /**
  
      /**
-        Automatically sets the height and width of all rows and columns to fit their
-        contents.
+        Returns the default renderer for the cell containing values of the
+        given type.
+
+        @see GetDefaultEditorForType()
      */
      */
-    void AutoSize();
+    virtual wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
  
      /**
  
      /**
-        Automatically adjusts width of the column to fit its label.
+        Hides the in-place cell edit control.
      */
      */
-    void AutoSizeColLabelSize(int col);
+    void HideCellEditControl();
  
      /**
  
      /**
-        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.
+        Returns @true if the in-place edit control is currently enabled.
      */
      */
-    void AutoSizeColumn(int col, bool setAsMin = true);
+    bool IsCellEditControlEnabled() const;
  
      /**
  
      /**
-        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.
+        Returns @true if the current cell is read-only.
+
+        @see SetReadOnly(), IsReadOnly()
      */
      */
-    void AutoSizeColumns(bool setAsMin = true);
+    bool IsCurrentCellReadOnly() const;
  
      /**
  
      /**
-        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.
+        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.
      */
      */
-    void AutoSizeRow(int row, bool setAsMin = true);
+    bool IsEditable() const;
  
      /**
  
      /**
-        Automatically adjusts height of the row to fit its label.
+        Returns @true if the cell at the specified location can't be edited.
+
+        @see SetReadOnly(), IsCurrentCellReadOnly()
      */
      */
-    void AutoSizeRowLabelSize(int col);
+    bool IsReadOnly(int row, int col) const;
  
      /**
  
      /**
-        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.
+        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 AutoSizeRows(bool setAsMin = true);
+    void RegisterDataType(const wxString& typeName,
+                          wxGridCellRenderer* renderer,
+                          wxGridCellEditor* editor);
  
      /**
  
      /**
-        AutoSizeColumn()
+        Sets the value of the current grid cell to the current in-place edit
+        control value.
  
  
-        AutoSizeRow()
+        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();
  
  
-        AutoSizeColumns()
+    /**
+        Sets the editor for the grid cell at the specified location.
  
  
-        AutoSizeRows()
+        The grid will take ownership of the pointer.
  
  
-        AutoSize()
+        See wxGridCellEditor and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    void SetCellEditor(int row, int col, wxGridCellEditor* editor);
  
  
-        SetColMinimalWidth()
+    /**
+        Sets the renderer for the grid cell at the specified location.
  
  
-        SetRowMinimalHeight()
+        The grid will take ownership of the pointer.
  
  
-        SetColMinimalAcceptableWidth()
+        See wxGridCellRenderer and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    void SetCellRenderer(int row, int col, wxGridCellRenderer* renderer);
  
  
-        SetRowMinimalAcceptableHeight()
+    /**
+        Sets the string value for the cell at the specified location.
  
  
-        GetColMinimalAcceptableWidth()
+        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.
  
  
-        GetRowMinimalAcceptableHeight()
+        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);
      /**
      /**
-        Increments the grid's batch count. 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.
+        @deprecated Please use SetCellValue(int,int,const wxString&) or
+                    SetCellValue(const wxGridCellCoords&,const wxString&)
+                    instead.
  
  
-        @see wxGridUpdateLocker
-    */
-    void BeginBatch();
+        Sets the string value for the cell at the specified location.
  
  
-    /**
-        This function returns the rectangle that encloses the block of cells
-        limited by TopLeft and BottomRight cell in device coords and clipped
-        to the client size of the grid window.
-    */
-    wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
-                             const wxGridCellCoords& bottomRight) const;
+        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.
  
  
-    /**
-        Returns @true if columns can be moved by dragging with the mouse. Columns can be
-        moved
-        by dragging on their labels.
+        See wxGridTableBase::CanSetValueAs() and the @ref overview_grid for
+        more information.
      */
      */
-    bool CanDragColMove() const;
+    void SetCellValue(const wxString& val, int row, int col);
  
      /**
  
      /**
-        Returns @true if columns can be resized by dragging with the mouse. 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).
-    */
-    bool CanDragColSize() const;
+        Sets the specified column to display boolean values.
  
  
-    /**
-        Return @true if the dragging of grid lines to resize rows and columns is enabled
-        or @false otherwise.
+        @see SetColFormatCustom()
      */
      */
-    bool CanDragGridSize() const;
+    void SetColFormatBool(int col);
  
      /**
  
      /**
-        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).
-    */
-    bool CanDragRowSize() const;
+        Sets the specified column to display data in a custom format.
  
  
-    /**
-        Returns @true if the in-place edit control for the current grid cell can be used
-        and
-        @false otherwise (e.g. if the current cell is read-only).
+        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.
      */
      */
-    bool CanEnableCellControl() const;
+    void SetColFormatCustom(int col, const wxString& typeName);
  
      /**
  
      /**
-        Do we have some place to store attributes in?
+        Sets the specified column to display floating point values with the
+        given width and precision.
+
+        @see SetColFormatCustom()
      */
      */
-    bool CanHaveAttributes() const;
+    void SetColFormatFloat(int col, int width = -1, int precision = -1);
  
      /**
  
      /**
-        EnableDragRowSize()
+        Sets the specified column to display integer values.
  
  
-        EnableDragColSize()
+        @see SetColFormatCustom()
+    */
+    void SetColFormatNumber(int col);
  
  
-        CanDragRowSize()
+    /**
+        Sets the default editor for grid cells.
  
  
-        CanDragColSize()
+        The grid will take ownership of the pointer.
  
  
-        EnableDragColMove()
+        See wxGridCellEditor and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    void SetDefaultEditor(wxGridCellEditor* editor);
  
  
-        CanDragColMove()
+    /**
+        Sets the default renderer for grid cells.
  
  
-        EnableDragGridSize()
+        The grid will take ownership of the pointer.
  
  
-        CanDragGridSize()
+        See wxGridCellRenderer and the @ref overview_grid for more information
+        about cell editors and renderers.
+    */
+    void SetDefaultRenderer(wxGridCellRenderer* renderer);
  
  
-        GetColAt()
+    /**
+        Makes the cell at the specified location read-only or editable.
  
  
-        SetColPos()
+        @see IsReadOnly()
+    */
+    void SetReadOnly(int row, int col, bool isReadOnly = true);
  
  
-        GetColPos()
+    /**
+        Displays the in-place cell edit control for the current cell.
+    */
+    void ShowCellEditControl();
  
  
-        EnableDragCell()
+    //@}
  
  
-        CanDragCell()
-    */
  
  
+    /**
+        @name Column and Row Sizes
  
  
+        @see @ref overview_grid_resizing
+     */
      //@{
      //@{
+
      /**
      /**
-        Return the rectangle corresponding to the grid cell's size and position in
-        logical
-        coordinates.
+        Automatically sets the height and width of all rows and columns to fit
+        their contents.
      */
      */
-    wxRect CellToRect(int row, int col) const;
-    const wxRect  CellToRect(const wxGridCellCoords& coords) const;
-    //@}
+    void AutoSize();
  
      /**
  
      /**
-        Clears all data in the underlying grid table and repaints the grid. 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.
+        Automatically adjusts width of the column to fit its label.
      */
      */
-    void ClearGrid();
+    void AutoSizeColLabelSize(int col);
  
      /**
  
      /**
-        Deselects all cells that are currently selected.
+        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 ClearSelection();
+    void AutoSizeColumn(int col, bool setAsMin = true);
  
      /**
  
      /**
-        @ref ctor() wxGrid
-
-        @ref dtor() ~wxGrid
-
-        CreateGrid()
-
-        SetTable()
+        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);
  
      /**
  
      /**
-        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().
+        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.
      */
      */
-    bool CreateGrid(int numRows, int numCols,
-                    wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells);
+    void AutoSizeRow(int row, bool setAsMin = true);
  
      /**
  
      /**
-        MoveCursorUp()
-
-        MoveCursorDown()
+        Automatically adjusts height of the row to fit its label.
+    */
+    void AutoSizeRowLabelSize(int col);
  
  
-        MoveCursorLeft()
+    /**
+        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);
  
  
-        MoveCursorRight()
+    /**
+        Returns the current height of the column labels.
+    */
+    int GetColLabelSize() const;
  
  
-        MoveCursorPageUp()
+    /**
+        Returns the minimal width to which a column may be resized.
  
  
-        MoveCursorPageDown()
+        Use SetColMinimalAcceptableWidth() to change this value globally or
+        SetColMinimalWidth() to do it for individual columns.
  
  
-        MoveCursorUpBlock()
+        @see GetRowMinimalAcceptableHeight()
+    */
+    int GetColMinimalAcceptableWidth() const;
  
  
-        MoveCursorDownBlock()
+    /**
+        Returns the width of the specified column.
+    */
+    int GetColSize(int col) const;
  
  
-        MoveCursorLeftBlock()
+    /**
+        Returns @true if the specified column is not currently hidden.
+     */
+    bool IsColShown(int col) const;
  
  
-        MoveCursorRightBlock()
+    /**
+        Returns the default height for column labels.
      */
      */
-
+    int GetDefaultColLabelSize() const;
  
      /**
  
      /**
-        Deletes one or more columns from a grid starting at the specified position and
-        returns
-        @true if successful. The 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.
+        Returns the current default width for grid columns.
      */
      */
-    bool DeleteCols(int pos = 0, int numCols = 1,
-                    bool updateLabels = true);
+    int GetDefaultColSize() const;
  
      /**
  
      /**
-        Deletes one or more rows from a grid starting at the specified position and
-        returns
-        @true if successful. The 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.
+        Returns the default width for the row labels.
      */
      */
-    bool DeleteRows(int pos = 0, int numRows = 1,
-                    bool updateLabels = true);
+    int GetDefaultRowLabelSize() const;
  
      /**
  
      /**
-        Disables in-place editing of grid cells.
-        Equivalent to calling EnableCellEditControl(@false).
+        Returns the current default height for grid rows.
      */
      */
-    void DisableCellEditControl();
+    int GetDefaultRowSize() const;
  
      /**
  
      /**
-        Disables column moving by dragging with the mouse. Equivalent to passing @false
-        to
-        EnableDragColMove().
+        Returns the minimal size to which rows can be resized.
+
+        Use SetRowMinimalAcceptableHeight() to change this value globally or
+        SetRowMinimalHeight() to do it for individual cells.
+
+        @see GetColMinimalAcceptableWidth()
      */
      */
-    void DisableDragColMove();
+    int GetRowMinimalAcceptableHeight() const;
  
      /**
  
      /**
-        Disables column sizing by dragging with the mouse. Equivalent to passing @false
-        to
-        EnableDragColSize().
+        Returns the current width of the row labels.
      */
      */
-    void DisableDragColSize();
+    int GetRowLabelSize() const;
  
      /**
  
      /**
-        Disable mouse dragging of grid lines to resize rows and columns. Equivalent to
-        passing
-        @false to EnableDragGridSize()
+        Returns the height of the specified row.
      */
      */
-    void DisableDragGridSize();
+    int GetRowSize(int row) const;
  
      /**
  
      /**
-        Disables row sizing by dragging with the mouse. Equivalent to passing @false to
-        EnableDragRowSize().
-    */
-    void DisableDragRowSize();
+        Returns @true if the specified row is not currently hidden.
+     */
+    bool IsRowShown(int row) const;
  
      /**
  
      /**
-        Enables or disables in-place editing of grid cell data. The grid will issue
-        either a
-        wxEVT_GRID_EDITOR_SHOWN or wxEVT_GRID_EDITOR_HIDDEN event.
+        Sets the height of the column labels.
+
+        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 EnableCellEditControl(bool enable = true);
+    void SetColLabelSize(int height);
  
      /**
  
      /**
-        Enables or disables column moving by dragging with the mouse.
+        Sets the minimal @a width to which the user can resize columns.
+
+        @see GetColMinimalAcceptableWidth()
      */
      */
-    void EnableDragColMove(bool enable = true);
+    void SetColMinimalAcceptableWidth(int width);
  
      /**
  
      /**
-        Enables or disables column sizing by dragging with the mouse.
+        Sets the minimal @a width for the specified column @a col.
+
+        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.
+
+        @a width must be greater than the minimal acceptable column width as
+        returned by GetColMinimalAcceptableWidth().
      */
      */
-    void EnableDragColSize(bool enable = true);
+    void SetColMinimalWidth(int col, int width);
  
      /**
  
      /**
-        Enables or disables row and column resizing by dragging gridlines with the
-        mouse.
+        Sets the width of the specified column.
+
+        @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.
      */
      */
-    void EnableDragGridSize(bool enable = true);
+    void SetColSize(int col, int width);
  
      /**
  
      /**
-        Enables or disables row sizing by dragging with the mouse.
-    */
-    void EnableDragRowSize(bool enable = true);
+        Hides the specified column.
+
+        To show the column later you need to call SetColSize() with non-0
+        width or ShowCol().
+
+        @param col
+            The column index.
+     */
+    void HideCol(int col);
  
      /**
  
      /**
-        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().
-        For more information about controlling grid cell attributes see the
-        wxGridCellAttr cell attribute class and the
-        @ref overview_gridoverview.
-    */
-    void EnableEditing(bool edit);
+        Shows the previously hidden column by resizing it to non-0 size.
+
+        @see HideCol(), SetColSize()
+     */
+    void ShowCol(int col);
+
  
      /**
  
      /**
-        Turns the drawing of grid lines on or off.
+        Sets the default width for columns in the grid.
+
+        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 EnableGridLines(bool enable = true);
+    void SetDefaultColSize(int width, bool resizeExistingCols = false);
  
      /**
  
      /**
-        Decrements the grid's batch count. 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.
+        Sets the default height for rows in the grid.
  
  
-        @see wxGridUpdateLocker
+        This will only affect rows subsequently added to the grid unless
+        @a resizeExistingRows is @true.
+
+        If @a height is less than GetRowMinimalAcceptableHeight(), then the
+        minimal acceptable heihgt is used instead of it.
      */
      */
-    void EndBatch();
+    void SetDefaultRowSize(int height, bool resizeExistingRows = false);
  
      /**
  
      /**
-        Overridden wxWindow method.
+        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 Fit();
+    void SetRowLabelSize(int width);
  
      /**
  
      /**
-        Causes immediate repainting of the grid. Use this instead of the usual
-        wxWindow::Refresh.
+        Sets the minimal row @a height used by default.
+
+        See SetColMinimalAcceptableWidth() for more information.
      */
      */
-    void ForceRefresh();
+    void SetRowMinimalAcceptableHeight(int height);
  
      /**
  
      /**
-        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.
+        Sets the minimal @a height for the specified @a row.
+
+        See SetColMinimalWidth() for more information.
      */
      */
-    int GetBatchCount() const;
+    void SetRowMinimalHeight(int row, int height);
  
      /**
  
      /**
-        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 wxALIGN_LEFT, wxALIGN_CENTRE or
-        wxALIGN_RIGHT.
+        Sets the height of the specified row.
  
  
-        Vertical alignment will be one of wxALIGN_TOP, wxALIGN_CENTRE or wxALIGN_BOTTOM.
+        See SetColSize() for more information.
      */
      */
-    void GetCellAlignment(int row, int col, int* horiz, int* vert) const;
+    void SetRowSize(int row, int height);
  
      /**
  
      /**
-        Returns the background colour of the cell at the specified location.
-    */
-    wxColour GetCellBackgroundColour(int row, int col) const;
+        Hides the specified row.
+
+        To show the row later you need to call SetRowSize() with non-0
+        width or ShowRow().
+
+        @param col
+            The row index.
+     */
+    void HideRow(int col);
  
      /**
  
      /**
-        Returns a pointer to the editor for the cell at the specified location.
-        See wxGridCellEditor and
-        the @ref overview_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
-    */
-    wxGridCellEditor* GetCellEditor(int row, int col) const;
+        Shows the previously hidden row by resizing it to non-0 size.
+
+        @see HideRow(), SetRowSize()
+     */
+    void ShowRow(int col);
  
      /**
  
      /**
-        Returns the font for text in the grid cell at the specified location.
-    */
-    wxFont GetCellFont(int row, int col) const;
+        Get size information for all columns at once.
+
+        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 a pointer to the renderer for the grid cell at the specified location.
-        See wxGridCellRenderer and
-        the @ref overview_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
-    */
-    wxGridCellRenderer* GetCellRenderer(int row, int col) const;
+        Get size information for all row at once.
+
+        @sa wxGridSizesInfo, GetColSizes()
+     */
+    wxGridSizesInfo GetRowSizes() const;
  
      /**
  
      /**
-        Returns the text colour for the grid cell at the specified location.
-    */
-    wxColour GetCellTextColour(int row, int col) const;
+        Restore all columns sizes.
+
+        This is usually called with wxGridSizesInfo object previously returned
+        by GetColSizes().
+
+        @sa SetRowSizes()
+     */
+    void SetColSizes(const wxGridSizesInfo& sizeInfo);
  
  
-    //@{
      /**
      /**
-        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_gridoverview "wxGrid overview" for more information.
-    */
-    wxString GetCellValue(int row, int col) const;
-    const wxString  GetCellValue(const wxGridCellCoords& coords) const;
+        Restore all rows sizes.
+
+        @sa SetColSizes()
+     */
+    void SetRowSizes(const wxGridSizesInfo& sizeInfo);
+
      //@}
  
      //@}
  
-    /**
-        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.
-    */
-    wxPen GetColGridLinePen(int col);
+        @name User-Resizing and Dragging
  
  
-    /**
-        Sets the arguments to the current column label alignment values.
-        Horizontal alignment will be one of wxALIGN_LEFT, wxALIGN_CENTRE or
-        wxALIGN_RIGHT.
+        Functions controlling various interactive mouse operations.
  
  
-        Vertical alignment will be one of wxALIGN_TOP, wxALIGN_CENTRE or wxALIGN_BOTTOM.
-    */
-    void GetColLabelAlignment(int* horiz, int* vert) const;
+        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.
  
  
-    /**
-        Returns the current height of the column labels.
-    */
-    int GetColLabelSize() const;
+        Columns can also be moved to interactively change their order but this
+        needs to be explicitly enabled with EnableDragColMove().
+     */
+    //@{
  
      /**
  
      /**
-        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.
+        Return @true if the dragging of cells is enabled or @false otherwise.
      */
      */
-    wxString GetColLabelValue(int col) const;
+    bool CanDragCell() const;
  
      /**
  
      /**
+        Returns @true if columns can be moved by dragging with the mouse.
  
  
+        Columns can be moved by dragging on their labels.
      */
      */
-    int GetColLeft(int col) const;
+    bool CanDragColMove() const;
  
      /**
  
      /**
-        This returns the value of the lowest column width that can be handled
-        correctly. See
-        member SetColMinimalAcceptableWidth() for details.
-    */
-    int GetColMinimalAcceptableWidth() const;
+        Returns @true if the given column can be resized by dragging with the
+        mouse.
  
  
-    /**
-        Get the minimal width of the given column/row.
+        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 GetColMinimalWidth(int col) 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 @true if the given row can be resized by dragging with the
+        mouse.
  
  
+        This is the same as CanDragColSize() but for rows.
      */
      */
-    int GetColRight(int col) const;
+    bool CanDragRowSize(int row) const;
  
      /**
  
      /**
-        Returns the width of the specified column.
-    */
-    int GetColSize(int col) const;
+        Disable interactive resizing of the specified column.
+
+        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).
+
+        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 resizeable 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.
+
+        Also notice that disabling interactive column resizing will not prevent
+        the program from changing the column size.
+
+        @see EnableDragColSize()
+     */
+    void DisableColResize(int col);
  
      /**
  
      /**
-        Sets the arguments to the current default horizontal and vertical text alignment
-        values.
-        Horizontal alignment will be one of wxALIGN_LEFT, wxALIGN_CENTRE or
-        wxALIGN_RIGHT.
+        Disable interactive resizing of the specified row.
  
  
-        Vertical alignment will be one of wxALIGN_TOP, wxALIGN_CENTRE or wxALIGN_BOTTOM.
-    */
-    void GetDefaultCellAlignment(int* horiz, int* vert) const;
+        This is the same as DisableColResize() but for rows.
+
+        @see EnableDragRowSize()
+     */
+    void DisableRowResize(int row);
  
      /**
  
      /**
-        Returns the current default background colour for grid cells.
+        Disables column moving by dragging with the mouse.
+
+        Equivalent to passing @false to EnableDragColMove().
      */
      */
-    wxColour GetDefaultCellBackgroundColour() const;
+    void DisableDragColMove();
  
      /**
  
      /**
-        Returns the current default font for grid cell text.
+        Disables column sizing by dragging with the mouse.
+
+        Equivalent to passing @false to EnableDragColSize().
      */
      */
-    wxFont GetDefaultCellFont() const;
+    void DisableDragColSize();
  
      /**
  
      /**
-        Returns the current default colour for grid cell text.
+        Disable mouse dragging of grid lines to resize rows and columns.
+
+        Equivalent to passing @false to EnableDragGridSize()
      */
      */
-    wxColour GetDefaultCellTextColour() const;
+    void DisableDragGridSize();
  
      /**
  
      /**
-        Returns the default height for column labels.
+        Disables row sizing by dragging with the mouse.
+
+        Equivalent to passing @false to EnableDragRowSize().
      */
      */
-    int GetDefaultColLabelSize() const;
+    void DisableDragRowSize();
  
      /**
  
      /**
-        Returns the current default width for grid columns.
+        Enables or disables cell dragging with the mouse.
      */
      */
-    int GetDefaultColSize() const;
+    void EnableDragCell(bool enable = true);
  
      /**
  
      /**
-        Returns a pointer to the current default grid cell editor.
-        See wxGridCellEditor and
-        the @ref overview_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
+        Enables or disables column moving by dragging with the mouse.
      */
      */
-    wxGridCellEditor* GetDefaultEditor() const;
+    void EnableDragColMove(bool enable = true);
  
  
-    //@{
      /**
      /**
+        Enables or disables column sizing by dragging with the mouse.
  
  
+        @see DisableColResize()
      */
      */
-    wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
-    const wxGridCellEditor*  GetDefaultEditorForCell(const wxGridCellCoords& c) const;
-    //@}
+    void EnableDragColSize(bool enable = true);
  
      /**
  
      /**
-
+        Enables or disables row and column resizing by dragging gridlines with
+        the mouse.
      */
      */
-    wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
+    void EnableDragGridSize(bool enable = true);
  
      /**
  
      /**
-        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.
+        Enables or disables row sizing by dragging with the mouse.
  
  
-        @see GetColGridLinePen(), GetRowGridLinePen()
+        @see DisableRowResize()
      */
      */
-    wxPen GetDefaultGridLinePen();
+    void EnableDragRowSize(bool enable = true);
  
      /**
  
      /**
-        Returns a pointer to the current default grid cell renderer.
-        See wxGridCellRenderer and
-        the @ref overview_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
+        Returns the column ID of the specified column position.
      */
      */
-    wxGridCellRenderer* GetDefaultRenderer() const;
+    int GetColAt(int colPos) const;
  
      /**
  
      /**
+        Returns the position of the specified column.
+    */
+    int GetColPos(int colID) const;
  
  
+    /**
+        Sets the position of the specified column.
      */
      */
-    wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
+    void SetColPos(int colID, int newPos);
  
      /**
  
      /**
+        Sets the positions of all columns at once.
  
  
+        This method takes an array containing the indices of the columns in
+        their display order, i.e. uses the same convention as
+        wxHeaderCtrl::SetColumnsOrder().
      */
      */
-    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.
@@ -1761,1052 +2511,1341 @@ public:
      int GetGridCursorRow() const;
  
      /**
      int GetGridCursorRow() const;
  
      /**
-        Returns the colour used for grid lines.
-
-        @see GetDefaultGridLinePen()
-    */
-    wxColour GetGridLineColour() 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 @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);
      /**
      /**
-        Returns the colour used for the background of row and column labels.
-    */
-    wxColour GetLabelBackgroundColour() 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 @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 font used for 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.
      */
      */
-    wxFont GetLabelFont() const;
+    bool MoveCursorDown(bool expandSelection);
  
      /**
  
      /**
-        Returns the colour used for row and column label text.
+        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.
      */
      */
-    wxColour GetLabelTextColour() const;
+    bool MoveCursorDownBlock(bool expandSelection);
  
      /**
  
      /**
-        Returns the total number of grid columns (actually the number of columns in the
-        underlying grid
-        table).
+        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.
      */
      */
-    int GetNumberCols() const;
+    bool MoveCursorLeft(bool expandSelection);
  
      /**
  
      /**
-        Returns the total number of grid rows (actually the number of rows in the
-        underlying grid table).
+        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.
+
+        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 MoveCursorLeftBlock(bool expandSelection);
  
      /**
  
      /**
+        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.
      */
      */
-    wxGridCellAttr* GetOrCreateCellAttr(int row, int col) const;
+    bool MoveCursorRight(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.
-        Example:
+        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.
      */
      */
-    wxPen GetRowGridLinePen(int row);
+    bool MoveCursorRightBlock(bool expandSelection);
  
      /**
  
      /**
-        Sets the arguments to the current row label alignment values.
-        Horizontal alignment will be one of wxLEFT, wxCENTRE or wxRIGHT.
+        Moves the grid cursor up by one row.
  
  
-        Vertical alignment will be one of wxTOP, wxCENTRE or wxBOTTOM.
+        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 MoveCursorUp(bool expandSelection);
  
      /**
  
      /**
-        Returns the current width of the row labels.
+        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.
      */
      */
-    int GetRowLabelSize() const;
+    bool MoveCursorUpBlock(bool expandSelection);
  
      /**
  
      /**
-        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 down by some number of rows so that the previous
+        bottom visible row becomes the top visible row.
      */
      */
-    wxString GetRowLabelValue(int row) const;
+    bool MovePageDown();
  
      /**
  
      /**
-        This returns the value of the lowest row width that can be handled correctly.
-        See
-        member SetRowMinimalAcceptableHeight() for details.
+        Moves the grid cursor up by some number of rows so that the previous
+        top visible row becomes the bottom visible row.
      */
      */
-    int GetRowMinimalAcceptableHeight() const;
+    bool MovePageUp();
  
      /**
  
      /**
+        Set the grid cursor to the specified cell.
  
  
-    */
-    int GetRowMinimalHeight(int col) const;
+        The grid cursor indicates the current cell and can be moved by the user
+        using the arrow keys or the mouse.
  
  
-    /**
-        Returns the height of the specified row.
-    */
-    int GetRowSize(int row) 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 number of pixels per horizontal scroll increment. The default is 15.
+        Set the grid cursor to the specified cell.
  
  
-        @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
-    */
-    int GetScrollLineX() const;
+        The grid cursor indicates the current cell and can be moved by the user
+        using the arrow keys or the mouse.
  
  
-    /**
-        Returns the number of pixels per vertical scroll increment. The default is 15.
+        Calling this function generates a @c wxEVT_GRID_SELECT_CELL event and
+        if the event handler vetoes this event, the cursor is not moved.
  
  
-        @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
+        This function doesn't make the target call visible, use GoToCell() to
+        do this.
      */
      */
-    int GetScrollLineY() const;
+    void SetGridCursor(const wxGridCellCoords& coords);
  
  
-    /**
-        Returns an array of singly selected cells.
-    */
-    wxGridCellCoordsArray GetSelectedCells() const;
+    //@}
  
  
-    /**
-        Returns an array of selected cols.
-    */
-    wxArrayInt GetSelectedCols() const;
  
      /**
  
      /**
-        Returns an array of selected rows.
-    */
-    wxArrayInt GetSelectedRows() const;
+        @name User Selection
+     */
+    //@{
  
      /**
  
      /**
-        Access or update the selection fore/back colours
+        Deselects all cells that are currently selected.
      */
      */
-    wxColour GetSelectionBackground() const;
+    void ClearSelection();
  
      /**
  
      /**
-        Returns an array of the bottom right corners of blocks of selected cells,
-        see GetSelectionBlockTopLeft().
-    */
-    wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
+        Returns an array of individually selected cells.
  
  
-    /**
-        Returns an array of the top left corners of blocks of selected cells,
-        see GetSelectionBlockBottomRight().
+        Notice that this array does @em not contain all the selected cells in
+        general as it doesn't include the cells selected as part of column, row
+        or block selection. You must use this method, GetSelectedCols(),
+        GetSelectedRows() and GetSelectionBlockTopLeft() and
+        GetSelectionBlockBottomRight() methods to obtain the entire selection
+        in general.
+
+        Please notice this behaviour is by design and is needed in order to
+        support grids of arbitrary size (when an entire column is selected in
+        a grid with a million of columns, we don't want to create an array with
+        a million of entries in this function, instead it returns an empty
+        array and GetSelectedCols() returns an array containing one element).
      */
      */
-    wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
+    wxGridCellCoordsArray GetSelectedCells() const;
  
      /**
  
      /**
+        Returns an array of selected columns.
  
  
+        Please notice that this method alone is not sufficient to find all the
+        selected columns as it contains only the columns which were
+        individually selected but not those being part of the block selection
+        or being selected in virtue of all of their cells being selected
+        individually, please see GetSelectedCells() for more details.
      */
      */
-    wxColour GetSelectionForeground() const;
+    wxArrayInt GetSelectedCols() const;
  
      /**
  
      /**
-        Returns the current selection mode, see SetSelectionMode().
-    */
-    wxGrid::wxGridSelectionModes GetSelectionMode() const;
+        Returns an array of selected rows.
  
  
-    /**
-        Returns a base pointer to the current table object.
+        Please notice that this method alone is not sufficient to find all the
+        selected rows as it contains only the rows which were individually
+        selected but not those being part of the block selection or being
+        selected in virtue of all of their cells being selected individually,
+        please see GetSelectedCells() for more details.
      */
      */
-    wxGridTableBase* GetTable() const;
+    wxArrayInt GetSelectedRows() const;
  
      /**
  
      /**
-        Returned number of whole cols visible.
+        Returns the colour used for drawing the selection background.
      */
      */
-    int GetViewWidth() const;
+    wxColour GetSelectionBackground() const;
  
      /**
  
      /**
-        EnableGridLines()
-
-        GridLinesEnabled()
+        Returns an array of the bottom right corners of blocks of selected
+        cells.
  
  
-        SetGridLineColour()
+        Please see GetSelectedCells() for more information about the selection
+        representation in wxGrid.
  
  
-        GetGridLineColour()
+        @see GetSelectionBlockTopLeft()
+    */
+    wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
  
  
-        GetDefaultGridLinePen()
+    /**
+        Returns an array of the top left corners of blocks of selected cells.
  
  
-        GetRowGridLinePen()
+        Please see GetSelectedCells() for more information about the selection
+        representation in wxGrid.
  
  
-        GetColGridLinePen()
+        @see GetSelectionBlockBottomRight()
      */
      */
-
+    wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
  
      /**
  
      /**
-        Returns @true if drawing of grid lines is turned on, @false otherwise.
+        Returns the colour used for drawing the selection foreground.
      */
      */
-    bool GridLinesEnabled() const;
+    wxColour GetSelectionForeground() const;
  
      /**
  
      /**
-        Hides the in-place cell edit control.
+        Returns the current selection mode.
+
+        @see SetSelectionMode().
      */
      */
-    void HideCellEditControl();
+    wxGridSelectionModes GetSelectionMode() 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.
+        Returns @true if the given cell is selected.
      */
      */
-    void HideColLabels();
-
+    bool IsInSelection(int row, int col) const;
      /**
      /**
-        Hides the row labels by calling SetRowLabelSize()
-        with a size of 0. Show labels again by calling that method with
-        a width greater than 0.
+        Returns @true if the given cell is selected.
      */
      */
-    void HideRowLabels();
+    bool IsInSelection(const wxGridCellCoords& coords) const;
  
      /**
  
      /**
-        Init the m_colWidths/Rights arrays
+        Returns @true if there are currently any selected cells, rows, columns
+        or blocks.
      */
      */
-    void InitColWidths();
+    bool IsSelection() const;
  
      /**
  
      /**
-        @note @e never access m_row/col arrays directly because they are created
-        on demand, @e always use accessor functions instead!
-        Init the m_rowHeights/Bottoms arrays with default values.
+        Selects all cells in the grid.
      */
      */
-    void InitRowHeights();
+    void SelectAll();
+
+    /**
+        Selects a rectangular block of cells.
  
  
+        If @a addToSelected is @false then any existing selection will be
+        deselected; if @true the column will be added to the existing
+        selection.
+    */
+    void SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
+                     bool addToSelected = false);
      /**
      /**
-        Inserts one or more new columns into a grid with the first new column at the
-        specified position and returns @true if successful. The updateLabels argument is
-        not
-        used at present.
-        The sequence of actions begins with the grid object 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.
+        Selects a rectangular block of cells.
+
+        If @a addToSelected is @false then any existing selection will be
+        deselected; if @true the column will be added to the existing
+        selection.
      */
      */
-    bool InsertCols(int pos = 0, int numCols = 1,
-                    bool updateLabels = true);
+    void SelectBlock(const wxGridCellCoords& topLeft,
+                     const wxGridCellCoords& bottomRight,
+                     bool addToSelected = false);
  
      /**
  
      /**
-        Inserts one or more new rows into a grid with the first new row at the specified
-        position and returns @true if successful. The updateLabels argument is not used
-        at
-        present.
-        The sequence of actions begins with the grid object requesting the underlying
-        grid
-        table to insert new rows. 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::InsertRows in your derived
-        table class.
+        Selects the specified column.
+
+        If @a addToSelected is @false then any existing selection will be
+        deselected; if @true the column will be added to the existing
+        selection.
+
+        This method won't select anything if the current selection mode is
+        wxGridSelectRows.
      */
      */
-    bool InsertRows(int pos = 0, int numRows = 1,
-                    bool updateLabels = true);
+    void SelectCol(int col, bool addToSelected = false);
  
      /**
  
      /**
-        Returns @true if the in-place edit control is currently enabled.
+        Selects the specified row.
+
+        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 IsCellEditControlEnabled() const;
+    void SelectRow(int row, bool addToSelected = false);
  
      /**
  
      /**
-        Returns @true if the current cell has been set to read-only
-        (see wxGrid::SetReadOnly).
+        Set the colour to be used for drawing the selection background.
      */
      */
-    bool IsCurrentCellReadOnly() const;
+    void SetSelectionBackground(const wxColour& c);
  
      /**
  
      /**
-        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.
+        Set the colour to be used for drawing the selection foreground.
      */
      */
-    bool IsEditable() const;
+    void SetSelectionForeground(const wxColour& c);
  
  
-    //@{
      /**
      /**
-        Is this cell currently selected.
+        Set the selection behaviour of the grid.
+
+        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 IsInSelection(int row, int col) const;
-    const bool IsInSelection(const wxGridCellCoords& coords) const;
+    void SetSelectionMode(wxGridSelectionModes selmode);
+
      //@}
  
      //@}
  
+
      /**
      /**
-        Returns @true if the cell at the specified location can't be edited.
-        See also IsReadOnly().
+        @name Scrolling
+     */
+    //@{
+
+    /**
+        Returns the number of pixels per horizontal scroll increment.
+
+        The default is 15.
+
+        @see GetScrollLineY(), SetScrollLineX(), SetScrollLineY()
      */
      */
-    bool IsReadOnly(int row, int col) const;
+    int GetScrollLineX() const;
  
      /**
  
      /**
-        Returns @true if there are currently rows, columns or blocks of cells selected.
+        Returns the number of pixels per vertical scroll increment.
+
+        The default is 15.
+
+        @see GetScrollLineX(), SetScrollLineX(), SetScrollLineY()
      */
      */
-    bool IsSelection() const;
+    int GetScrollLineY() const;
  
  
-    //@{
      /**
      /**
-        Returns @true if a cell is either wholly visible (the default) or at least
-        partially
+        Returns @true if a cell is either entirely or at least partially
          visible in the grid window.
          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.
      */
      bool IsVisible(int row, int col, bool wholeCellVisible = true) const;
      */
      bool IsVisible(int row, int col, bool wholeCellVisible = true) const;
-    const bool IsVisible(const wxGridCellCoords& coords,
-                         bool wholeCellVisible = true) const;
-    //@}
+    /**
+        Returns @true if a cell is either entirely 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.
+    */
+    bool IsVisible(const wxGridCellCoords& coords,
+                   bool wholeCellVisible = true) const;
  
  
-    //@{
      /**
          Brings the specified cell into the visible grid cell area with minimal
      /**
          Brings the specified cell into the visible grid cell area with minimal
-        scrolling. Does
-        nothing if the cell is already visible.
+        scrolling.
+
+        Does nothing if the cell is already visible.
      */
      void MakeCellVisible(int row, int col);
      */
      void MakeCellVisible(int row, int col);
+    /**
+        Brings the specified cell into the visible grid cell area with minimal
+        scrolling.
+
+        Does nothing if the cell is already visible.
+    */
      void MakeCellVisible(const wxGridCellCoords& coords);
      void MakeCellVisible(const wxGridCellCoords& coords);
-    //@}
  
      /**
  
      /**
-        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.
+        Sets the number of pixels per horizontal scroll increment.
+
+        The default is 15.
+
+        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
      */
      */
-    bool MoveCursorDown(bool expandSelection);
+    void SetScrollLineX(int x);
  
      /**
  
      /**
-        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.
+        Sets the number of pixels per vertical scroll increment.
+
+        The default is 15.
+
+        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
      */
      */
-    bool MoveCursorDownBlock(bool expandSelection);
+    void SetScrollLineY(int y);
+
+    //@}
+
  
      /**
  
      /**
-        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.
-    */
-    bool MoveCursorLeft(bool expandSelection);
+        @name Cell and Device Coordinate Translation
+     */
+    //@{
  
      /**
  
      /**
-        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. If a block of cells was previously selected
-        it
-        will expand if the argument is @true or be cleared if the argument is @false.
+        Convert grid cell coordinates to grid window pixel coordinates.
+
+        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.
+
+        @see CellToRect()
      */
      */
-    bool MoveCursorLeftBlock(bool expandSelection);
+    wxRect BlockToDeviceRect(const wxGridCellCoords& topLeft,
+                             const wxGridCellCoords& bottomRight) const;
  
      /**
  
      /**
-        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.
-    */
-    bool MoveCursorRight(bool expandSelection);
+        Return the rectangle corresponding to the grid cell's size and position
+        in logical coordinates.
  
  
+        @see BlockToDeviceRect()
+    */
+    wxRect CellToRect(int row, int col) const;
      /**
      /**
-        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.
+        Return the rectangle corresponding to the grid cell's size and position
+        in logical coordinates.
+
+        @see BlockToDeviceRect()
      */
      */
-    bool MoveCursorRightBlock(bool expandSelection);
+    wxRect CellToRect(const wxGridCellCoords& coords) const;
  
      /**
  
      /**
-        Moves the grid cursor up 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.
+        Returns the column at the given pixel position.
+
+        @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.
      */
      */
-    bool MoveCursorUp(bool expandSelection);
+    int XToCol(int x, bool clipToMinMax = false) const;
  
      /**
  
      /**
-        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.
+        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.
      */
      */
-    bool MoveCursorUpBlock(bool expandSelection);
+    int XToEdgeOfCol(int x) const;
  
      /**
  
      /**
-        Moves the grid cursor down by some number of rows so that the previous bottom
-        visible row
-        becomes the top visible row.
-    */
-    bool MovePageDown();
+        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(int x, int y) const;
      /**
      /**
-        Moves the grid cursor up by some number of rows so that the previous top
-        visible row
-        becomes the bottom visible row.
-    */
-    bool MovePageUp();
+        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
  
      /**
  
      /**
-        Methods for a registry for mapping data types to Renderers/Editors
+        Returns the row whose bottom edge is close to the given logical @a y
+        position.
+
+        If no row edge is near to this position @c wxNOT_FOUND is returned.
      */
      */
-    void RegisterDataType(const wxString& typeName,
-                          wxGridCellRenderer* renderer,
-                          wxGridCellEditor* editor);
+    int YToEdgeOfRow(int y) const;
  
      /**
  
      /**
-        SetRowLabelValue()
+        Returns the grid row that corresponds to the logical @a y coordinate.
  
  
-        SetColLabelValue()
+        Returns @c wxNOT_FOUND if there is no row at the @a y position.
+    */
+    int YToRow(int y, bool clipToMinMax = false) const;
  
  
-        GetRowLabelValue()
+    //@}
  
  
-        GetColLabelValue()
  
  
-        SetUseNativeColLabels()
+    /**
+        @name Miscellaneous Functions
+     */
+    //@{
  
  
-        HideColLabels()
+    /**
+        Appends one or more new columns to the right of the grid.
  
  
-        HideRowLabels()
+        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.
  
  
-        SetRowLabelSize()
+        @return @true on success or @false if appending columns failed.
+    */
+    bool AppendCols(int numCols = 1, bool updateLabels = true);
  
  
-        SetColLabelSize()
+    /**
+        Appends one or more new rows to the bottom of the grid.
  
  
-        GetRowLabelSize()
+        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.
  
  
-        GetColLabelSize()
+        @return @true on success or @false if appending rows failed.
+    */
+    bool AppendRows(int numRows = 1, bool updateLabels = true);
  
  
-        AutoSizeRowLabelSize()
+    /**
+        Return @true if the horizontal grid lines stop at the last column
+        boundary or @false if they continue to the end of the window.
  
  
-        AutoSizeColLabelSize()
+        The default is to clip grid lines.
  
  
-        GetDefaultRowLabelSize()
+        @see ClipHorzGridLines(), AreVertGridLinesClipped()
+     */
+    bool AreHorzGridLinesClipped() const;
  
  
-        GetDefaultColLabelSize()
+    /**
+        Return @true if the vertical grid lines stop at the last row
+        boundary or @false if they continue to the end of the window.
  
  
-        SetRowLabelAlignment()
+        The default is to clip grid lines.
  
  
-        SetColLabelAlignment()
+        @see ClipVertGridLines(), AreHorzGridLinesClipped()
+     */
+    bool AreVertGridLinesClipped() const;
  
  
-        GetRowLabelAlignment()
+    /**
+        Increments the grid's batch count.
  
  
-        GetColLabelAlignment()
+        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.
  
  
-        SetLabelFont()
+        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 BeginBatch();
  
  
-        SetLabelTextColour()
+    /**
+        Clears all data in the underlying grid table and repaints the grid.
  
  
-        SetLabelBackgroundColour()
+        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 ClearGrid();
  
  
-        GetLabelFont()
+    /**
+        Change whether the horizontal grid lines are clipped by the end of the
+        last column.
  
  
-        GetLabelBackgroundColour()
+        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.
  
  
-        GetLabelTextColour()
+        @see AreHorzGridLinesClipped(), ClipVertGridLines()
+     */
+    void ClipHorzGridLines(bool clip);
  
  
-        SetColLabelTextOrientation()
+    /**
+        Change whether the vertical grid lines are clipped by the end of the
+        last row.
  
  
-        GetColLabelTextOrientation()
-    */
+        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);
  
      /**
  
      /**
-        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.
+        Deletes one or more columns 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::DeleteCols(). See InsertCols() for further
+        information.
+
+        @return @true on success or @false if deleting columns failed.
      */
      */
-    void SaveEditControlValue();
+    bool DeleteCols(int pos = 0, int numCols = 1, bool updateLabels = true);
  
      /**
  
      /**
-        Selects all cells in the grid.
+        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.
+
+        @return @true on success or @false if appending rows failed.
      */
      */
-    void SelectAll();
+    bool DeleteRows(int pos = 0, int numRows = 1, bool updateLabels = true);
  
  
-    //@{
      /**
      /**
-        Selects a rectangular block of cells. If addToSelected is @false then any
-        existing selection will be
-        deselected; if @true the column will be added to the existing selection.
+        Decrements the grid's batch count.
+
+        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.
+
+        @see wxGridUpdateLocker
      */
      */
-    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 EndBatch();
  
      /**
  
      /**
-        Selects the specified column. If addToSelected is @false then any existing
-        selection will be
-        deselected; if @true the column will be added to the existing selection.
+        Overridden wxWindow method.
      */
      */
-    void SelectCol(int col, bool addToSelected = false);
+    virtual void Fit();
  
      /**
  
      /**
-        Selects the specified row. If addToSelected is @false then any existing
-        selection will be
-        deselected; if @true the row will be added to the existing selection.
+        Causes immediate repainting of the grid.
+
+        Use this instead of the usual wxWindow::Refresh().
      */
      */
-    void SelectRow(int row, bool addToSelected = false);
+    void ForceRefresh();
  
      /**
  
      /**
-        ClearSelection()
-
-        IsSelection()
+        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();
  
  
-        SelectAll()
+    /**
+        Returns the total number of grid columns.
  
  
-        SelectBlock()
+        This is the same as the number of columns in the underlying grid table.
+    */
+    int GetNumberCols() const;
  
  
-        SelectCol()
+    /**
+        Returns the total number of grid rows.
  
  
-        SelectRow()
+        This is the same as the number of rows in the underlying grid table.
      */
      */
-
+    int GetNumberRows() const;
  
      /**
  
      /**
-        This function returns the rectangle that encloses the selected cells
-        in device coords and clipped to the client size of the grid window.
+        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.
+
+        This function may only be called if CanHaveAttributes() returns @true.
      */
      */
-    wxRect SelectionToDeviceRect() const;
+    wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
  
  
-    //@{
      /**
      /**
-        Sets the horizontal and vertical alignment for grid cell text at the specified
-        location.
-        Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
-        wxALIGN_RIGHT.
+        Returns a base pointer to the current table object.
  
  
-        Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
-        wxALIGN_BOTTOM.
+        The returned pointer is still owned by the grid.
      */
      */
-    void SetCellAlignment(int row, int col, int horiz, int vert);
-    void SetCellAlignment(int align, int row, int col);
-    //@}
+    wxGridTableBase *GetTable() const;
  
      /**
  
      /**
+        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 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.
+
+        @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 SetCellBackgroundColour(int row, int col,
-                                 const wxColour& colour);
+    bool InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true);
  
      /**
  
      /**
-        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_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
+        Inserts one or more new rows into a grid with the first new row at the
+        specified position.
+
+        Notice that you must implement wxGridTableBase::InsertRows() if you use
+        a grid with a custom table, please see InsertCols() for more
+        information.
+
+        @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 SetCellEditor(int row, int col, wxGridCellEditor* editor);
+    bool InsertRows(int pos = 0, int numRows = 1, bool updateLabels = true);
  
      /**
  
      /**
-        Sets the font for text in the grid cell at the specified location.
+        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 SetCellFont(int row, int col, const wxFont& font);
+    void SetColAttr(int col, wxGridCellAttr* attr);
  
      /**
  
      /**
-        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_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
+        Sets the extra margins used around the grid area.
+
+        A grid may occupy more space than needed for its data display and
+        this function allows to set how big this extra space is
      */
      */
-    void SetCellRenderer(int row, int col,
-                         wxGridCellRenderer* renderer);
+    void SetMargins(int extraWidth, int extraHeight);
  
  
-    //@{
      /**
      /**
-        Sets the text colour for the grid cell at the specified location.
+        Sets the cell attributes for all cells in the specified row.
+
+        The grid takes ownership of the attribute pointer.
+
+        See the wxGridCellAttr class for more information about controlling
+        cell attributes.
      */
      */
-    void SetCellTextColour(int row, int col, const wxColour& colour);
-    void SetCellTextColour(const wxColour& val, int row, int col);
-    void SetCellTextColour(const wxColour& colour);
+    void SetRowAttr(int row, wxGridCellAttr* attr);
+
      //@}
  
      //@}
  
+
+    /**
+        @name Sorting support.
+
+        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.
+
+        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.
+
+        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 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.
-        The last form is for backward compatibility only.
-        See wxGridTableBase::CanSetValueAs
-        and the @ref overview_gridoverview "wxGrid overview" for more information.
-    */
-    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);
-    //@}
+        Return the column in which the sorting indicator is currently
+        displayed.
+
+        Returns @c wxNOT_FOUND if sorting indicator is not currently displayed
+        at all.
+
+        @see SetSortingColumn()
+     */
+    int GetSortingColumn() const;
  
      /**
  
      /**
-        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_gridoverview.
-    */
-    void SetColAttr(int col, wxGridCellAttr* attr);
+        Return @true if this column is currently used for sorting.
+
+        @see GetSortingColumn()
+     */
+    bool IsSortingBy(int col) const;
  
      /**
  
      /**
-        Sets the specified column to display boolean values. wxGrid displays boolean
-        values with a checkbox.
-    */
-    void SetColFormatBool(int col);
+        Return @true if the current sorting order is ascending or @false if it
+        is descending.
+
+        It only makes sense to call this function if GetSortingColumn() returns
+        a valid column index and not @c wxNOT_FOUND.
+
+        @see SetSortingColumn()
+     */
+    bool IsSortOrderAscending() const;
  
      /**
  
      /**
-        Sets the specified column to display data in a custom format.
-        See the @ref overview_gridoverview "wxGrid overview" for more information on
-        working
-        with custom data types.
-    */
-    void SetColFormatCustom(int col, const wxString& typeName);
+        Set the column to display the sorting indicator in and its direction.
+
+        @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.
+
+        @see GetSortingColumn(), IsSortOrderAscending()
+     */
+    void SetSortingColumn(int col, bool ascending = true);
  
      /**
  
      /**
-        Sets the specified column to display floating point values with the given width
-        and precision.
-    */
-    void SetColFormatFloat(int col, int width = -1,
-                           int precision = -1);
+        Remove any currently shown sorting indicator.
+
+        This is equivalent to calling SetSortingColumn() with @c wxNOT_FOUND
+        first argument.
+     */
+    void UnsetSortingColumn();
+    //@}
+
  
      /**
  
      /**
-        Sets the specified column to display integer values.
-    */
-    void SetColFormatNumber(int col);
+        @name Accessors for component windows.
+
+        Return the various child windows of wxGrid.
+
+        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.
+     */
+    //@{
  
      /**
  
      /**
-        Sets the horizontal and vertical alignment of column label text.
-        Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
-        wxALIGN_RIGHT.
-        Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
-        wxALIGN_BOTTOM.
-    */
-    void SetColLabelAlignment(int horiz, int vert);
+        Return the main grid window containing the grid cells.
+
+        This window is always shown.
+     */
+    wxWindow *GetGridWindow() const;
+
+    /**
+        Return the row labels window.
+
+        This window is not shown if the row labels were hidden using
+        HideRowLabels().
+     */
+    wxWindow *GetGridRowLabelWindow() const;
  
      /**
  
      /**
-        Sets the height of the column labels.
-        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);
+        Return the column labels window.
+
+        This window is not shown if the columns labels were hidden using
+        HideColLabels().
+
+        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.
+     */
+    wxWindow *GetGridColLabelWindow() const;
  
      /**
  
      /**
-        Set the value for the given column label. If you are using a derived grid table
-        you must
-        override wxGridTableBase::SetColLabelValue
-        for this to have any effect.
-    */
-    void SetColLabelValue(int col, const wxString& value);
+        Return the window in the top left grid corner.
+
+        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;
  
      /**
  
      /**
-        This modifies the minimum column width that can be handled correctly.
-        Specifying a low value here
-        allows smaller grid cells to be dealt with correctly. Specifying a value here
-        which is much smaller
-        than the actual minimum size will incur a performance penalty in the functions
-        which perform
-        grid cell index lookup on the basis of screen coordinates.
-        This should normally be called when creating the grid because it will not
-        resize existing columns
-        with sizes smaller than the value specified here.
-    */
-    void SetColMinimalAcceptableWidth(int width);
+        Return the header control used for column labels display.
+
+        This function can only be called if UseNativeColHeader() had been
+        called.
+     */
+    wxHeaderCtrl *GetGridColHeader() const;
+
+    //@}
  
  
+protected:
      /**
      /**
-        Sets the minimal width for the specified column. This should normally be called
-        when creating the grid
-        because it will not resize a column that is already narrower than the minimal
-        width.
-        The width argument must be higher than the minimimal acceptable column width,
-        see
-        GetColMinimalAcceptableWidth().
+        Returns @true if this grid has support for cell attributes.
+
+        The grid supports attributes if it has the associated table which, in
+        turn, has attributes support, i.e. wxGridTableBase::CanHaveAttributes()
+        returns @true.
      */
      */
-    void SetColMinimalWidth(int col, int width);
+    bool CanHaveAttributes() const;
  
      /**
  
      /**
-        Sets the position of the specified column.
+        Get the minimal width of the given column/row.
+
+        The value returned by this function may be different than that returned
+        by GetColMinimalAcceptableWidth() if SetColMinimalWidth() had been
+        called for this column.
      */
      */
-    void SetColPos(int colID, int newPos);
+    int GetColMinimalWidth(int col) const;
  
      /**
  
      /**
-        Sets the width of the specified column.
-        This function does not refresh the grid. If you are calling it outside of a
-        BeginBatch / EndBatch
-        block you can use ForceRefresh() to see the changes.
-        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.
+        Returns the coordinate of the right border specified column.
      */
      */
-    void SetColSize(int col, int width);
+    int GetColRight(int col) const;
  
      /**
  
      /**
-        Sets the default horizontal and vertical alignment for grid cell text.
-        Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
-        wxALIGN_RIGHT.
-        Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
-        wxALIGN_BOTTOM.
+        Returns the coordinate of the left border specified column.
      */
      */
-    void SetDefaultCellAlignment(int horiz, int vert);
+    int GetColLeft(int col) const;
  
      /**
  
      /**
-        Sets the default background colour for grid cells.
+        Returns the minimal size for the given column.
+
+        The value returned by this function may be different than that returned
+        by GetRowMinimalAcceptableHeight() if SetRowMinimalHeight() had been
+        called for this row.
      */
      */
-    void SetDefaultCellBackgroundColour(const wxColour& colour);
+    int GetRowMinimalHeight(int col) const;
+};
+
+
+
+/**
+    @class wxGridUpdateLocker
+
+    This small class can be used to prevent wxGrid from redrawing during its
+    lifetime by calling wxGrid::BeginBatch() in its constructor and
+    wxGrid::EndBatch() in its destructor. It is typically used in a function
+    performing several operations with a grid which would otherwise result in
+    flicker. For example:
  
  
+    @code
+    void MyFrame::Foo()
+    {
+        m_grid = new wxGrid(this, ...);
+
+        wxGridUpdateLocker noUpdates(m_grid);
+        m_grid-AppendColumn();
+        // ... many other operations with m_grid ...
+        m_grid-AppendRow();
+
+        // destructor called, grid refreshed
+    }
+    @endcode
+
+    Using this class is easier and safer than calling wxGrid::BeginBatch() and
+    wxGrid::EndBatch() because you don't risk missing the call the latter (due
+    to an exception for example).
+
+    @library{wxadv}
+    @category{grid}
+*/
+class wxGridUpdateLocker
+{
+public:
      /**
      /**
-        Sets the default font to be used for grid cell text.
+        Creates an object preventing the updates of the specified @a grid. The
+        parameter could be @NULL in which case nothing is done. If @a grid is
+        non-@NULL then the grid must exist for longer than this
+        wxGridUpdateLocker object itself.
+
+        The default constructor could be followed by a call to Create() to set
+        the grid object later.
      */
      */
-    void SetDefaultCellFont(const wxFont& font);
+    wxGridUpdateLocker(wxGrid* grid = NULL);
  
      /**
  
      /**
-        Sets the current default colour for grid cell text.
+        Destructor reenables updates for the grid this object is associated
+        with.
      */
      */
-    void SetDefaultCellTextColour(const wxColour& colour);
+    ~wxGridUpdateLocker();
  
      /**
  
      /**
-        Sets the default width for columns in the grid. This will only affect columns
-        subsequently added to
-        the grid unless resizeExistingCols is @true.
+        This method can be called if the object had been constructed using the
+        default constructor. It must not be called more than once.
      */
      */
-    void SetDefaultColSize(int width,
-                           bool resizeExistingCols = false);
+    void Create(wxGrid* grid);
+};
+
+
  
  
+/**
+    @class wxGridEvent
+
+    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}
+    @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_DCLICK(func)}
+        The user double-clicked a cell with the left mouse button. Processes a
+        @c wxEVT_GRID_CELL_LEFT_DCLICK event type.
+    @event{EVT_GRID_CELL_RIGHT_CLICK(func)}
+        The user clicked a cell with the right mouse button. Processes a
+        @c wxEVT_GRID_CELL_RIGHT_CLICK event type.
+    @event{EVT_GRID_CELL_RIGHT_DCLICK(func)}
+        The user double-clicked a cell with the right mouse button. Processes a
+        @c wxEVT_GRID_CELL_RIGHT_DCLICK event type.
+    @event{EVT_GRID_EDITOR_HIDDEN(func)}
+        The editor for a cell was hidden. Processes a
+        @c wxEVT_GRID_EDITOR_HIDDEN event type.
+    @event{EVT_GRID_EDITOR_SHOWN(func)}
+        The editor for a cell was shown. Processes a
+        @c wxEVT_GRID_EDITOR_SHOWN event type.
+    @event{EVT_GRID_LABEL_LEFT_CLICK(func)}
+        The user clicked a label with the left mouse button. Processes a
+        @c wxEVT_GRID_LABEL_LEFT_CLICK event type.
+    @event{EVT_GRID_LABEL_LEFT_DCLICK(func)}
+        The user double-clicked a label with the left mouse button. Processes a
+        @c wxEVT_GRID_LABEL_LEFT_DCLICK event type.
+    @event{EVT_GRID_LABEL_RIGHT_CLICK(func)}
+        The user clicked a label with the right mouse button. Processes a
+        @c wxEVT_GRID_LABEL_RIGHT_CLICK event type.
+    @event{EVT_GRID_LABEL_RIGHT_DCLICK(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
+        @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.
+    @endEventTable
+
+    @library{wxadv}
+    @category{grid,events}
+*/
+class wxGridEvent : public wxNotifyEvent
+{
+public:
      /**
      /**
-        Sets the default editor for grid cells. The grid will take ownership of the
-        pointer.
-        See wxGridCellEditor and
-        the @ref overview_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
+        Default constructor.
      */
      */
-    void SetDefaultEditor(wxGridCellEditor* editor);
-
+    wxGridEvent();
      /**
      /**
-        Sets the default renderer for grid cells. The grid will take ownership of the
-        pointer.
-        See wxGridCellRenderer and
-        the @ref overview_gridoverview "wxGrid overview" for more information about
-        cell editors and renderers.
+        Constructor for initializing all event attributes.
      */
      */
-    void SetDefaultRenderer(wxGridCellRenderer* renderer);
+    wxGridEvent(int id, wxEventType type, wxObject* obj,
+                int row = -1, int col = -1, int x = -1, int y = -1,
+                bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());
  
      /**
  
      /**
-        Sets the default height for rows in the grid. This will only affect rows
-        subsequently added
-        to the grid unless resizeExistingRows is @true.
+        Returns @true if the Alt key was down at the time of the event.
      */
      */
-    void SetDefaultRowSize(int height,
-                           bool resizeExistingRows = false);
+    bool AltDown() const;
  
      /**
  
      /**
-        Set the grid cursor to the specified cell.
-        This function calls MakeCellVisible().
+        Returns @true if the Control key was down at the time of the event.
      */
      */
-    void SetGridCursor(int row, int col);
+    bool ControlDown() const;
  
      /**
  
      /**
-        Sets the colour used to draw grid lines.
+        Column at which the event occurred.
      */
      */
-    void SetGridLineColour(const wxColour& colour);
+    virtual int GetCol();
  
      /**
  
      /**
-        Sets the background colour for row and column labels.
+        Position in pixels at which the event occurred.
      */
      */
-    void SetLabelBackgroundColour(const wxColour& colour);
+    wxPoint GetPosition();
  
      /**
  
      /**
-        Sets the font for row and column labels.
+        Row at which the event occurred.
      */
      */
-    void SetLabelFont(const wxFont& font);
+    virtual int GetRow();
  
      /**
  
      /**
-        Sets the colour for row and column label text.
+        Returns @true if the Meta key was down at the time of the event.
      */
      */
-    void SetLabelTextColour(const wxColour& colour);
+    bool MetaDown() const;
  
      /**
  
      /**
-        A grid may occupy more space than needed for its rows/columns. This
-        function allows to set how big this extra space is
+        Returns @true if the user is selecting grid cells, or @false if
+        deselecting.
      */
      */
-    void SetMargins(int extraWidth, int extraHeight);
+    bool Selecting();
  
      /**
  
      /**
-        Common part of AutoSizeColumn/Row() and GetBestSize()
+        Returns @true if the Shift key was down at the time of the event.
      */
      */
-    int SetOrCalcColumnSizes(bool calcOnly, bool setAsMin = true);
+    bool ShiftDown() const;
+};
  
  
-    /**
  
  
-    */
-    int SetOrCalcRowSizes(bool calcOnly, bool setAsMin = true);
  
  
+/**
+    @class wxGridSizeEvent
+
+    This event class contains information about a row/column resize event.
+
+    @beginEventTable{wxGridSizeEvent}
+    @event{EVT_GRID_CMD_COL_SIZE(id, func)}
+        The user resized a column, corresponds to @c wxEVT_GRID_COL_SIZE event
+        type.
+    @event{EVT_GRID_CMD_ROW_SIZE(id, func)}
+        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_ROW_SIZE(func)}
+        Same as EVT_GRID_CMD_ROW_SIZE() but uses `wxID_ANY` id.
+    @endEventTable
+
+    @library{wxadv}
+    @category{grid,events}
+*/
+class wxGridSizeEvent : public wxNotifyEvent
+{
+public:
      /**
      /**
-        Makes the cell at the specified location read-only or editable.
-        See also IsReadOnly().
+        Default constructor.
      */
      */
-    void SetReadOnly(int row, int col, bool isReadOnly = true);
-
+    wxGridSizeEvent();
      /**
      /**
-        Sets the cell attributes for all cells in the specified row.
-        See the wxGridCellAttr class for more information
-        about controlling cell attributes.
+        Constructor for initializing all event attributes.
      */
      */
-    void SetRowAttr(int row, wxGridCellAttr* attr);
+    wxGridSizeEvent(int id, wxEventType type, wxObject* obj,
+                    int rowOrCol = -1, int x = -1, int y = -1,
+                    const wxKeyboardState& kbd = wxKeyboardState());
  
      /**
  
      /**
-        Sets the horizontal and vertical alignment of row label text.
-        Horizontal alignment should be one of wxALIGN_LEFT, wxALIGN_CENTRE or
-        wxALIGN_RIGHT.
-        Vertical alignment should be one of wxALIGN_TOP, wxALIGN_CENTRE or
-        wxALIGN_BOTTOM.
+        Returns @true if the Alt key was down at the time of the event.
      */
      */
-    void SetRowLabelAlignment(int horiz, int vert);
+    bool AltDown() const;
  
      /**
  
      /**
-        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.
+        Returns @true if the Control key was down at the time of the event.
      */
      */
-    void SetRowLabelSize(int width);
+    bool ControlDown() const;
  
      /**
  
      /**
-        Set 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.
+        Position in pixels at which the event occurred.
      */
      */
-    void SetRowLabelValue(int row, const wxString& value);
+    wxPoint GetPosition();
  
      /**
  
      /**
-        This modifies the minimum row width that can be handled correctly. Specifying a
-        low value here
-        allows smaller grid cells to be dealt with correctly. Specifying a value here
-        which is much smaller
-        than the actual minimum size will incur a performance penalty in the functions
-        which perform
-        grid cell index lookup on the basis of screen coordinates.
-        This should normally be called when creating the grid because it will not
-        resize existing rows
-        with sizes smaller than the value specified here.
+        Row or column at that was resized.
      */
      */
-    void SetRowMinimalAcceptableHeight(int height);
+    int GetRowOrCol();
  
      /**
  
      /**
-        Sets the minimal height for the specified row. This should normally be called
-        when creating the grid
-        because it will not resize a row that is already shorter than the minimal
-        height.
-        The height argument must be higher than the minimimal acceptable row height, see
-        GetRowMinimalAcceptableHeight().
+        Returns @true if the Meta key was down at the time of the event.
      */
      */
-    void SetRowMinimalHeight(int row, int height);
+    bool MetaDown() const;
  
      /**
  
      /**
-        Sets the height of the specified row.
-        This function does not refresh the grid. If you are calling it outside of a
-        BeginBatch / EndBatch
-        block you can use ForceRefresh() to see the changes.
-        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.
+        Returns @true if the Shift key was down at the time of the event.
      */
      */
-    void SetRowSize(int row, int height);
+    bool ShiftDown() const;
+};
  
  
-    /**
-        Sets the number of pixels per horizontal scroll increment. The default is 15.
-        Sometimes wxGrid has trouble setting the scrollbars correctly due to rounding
-        errors: setting this to 1 can help.
  
  
-        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineY()
-    */
-    void SetScrollLineX(int x);
  
  
-    /**
-        Sets the number of pixels per vertical scroll increment. The default is 15.
-        Sometimes wxGrid has trouble setting the scrollbars correctly due to rounding
-        errors: setting this to 1 can help.
+/**
+    @class wxGridRangeSelectEvent
  
  
-        @see GetScrollLineX(), GetScrollLineY(), SetScrollLineX()
-    */
-    void SetScrollLineY(int y);
+    @beginEventTable{wxGridRangeSelectEvent}
+    @event{EVT_GRID_RANGE_SELECT(func)}
+        The user selected a group of contiguous cells. Processes a
+        @c wxEVT_GRID_RANGE_SELECT event type.
+    @event{EVT_GRID_CMD_RANGE_SELECT(id, func)}
+        The user selected a group of contiguous cells; variant taking a window
+        identifier. Processes a @c wxEVT_GRID_RANGE_SELECT event type.
+    @endEventTable
  
  
+    @library{wxadv}
+    @category{grid,events}
+*/
+class wxGridRangeSelectEvent : public wxNotifyEvent
+{
+public:
      /**
      /**
-
+        Default constructor.
      */
      */
-    void SetSelectionBackground(const wxColour& c);
+    wxGridRangeSelectEvent();
+    /**
+        Constructor for initializing all event attributes.
+    */
+    wxGridRangeSelectEvent(int id, wxEventType type,
+                           wxObject* obj,
+                           const wxGridCellCoords& topLeft,
+                           const wxGridCellCoords& bottomRight,
+                           bool sel = true, const wxKeyboardState& kbd = wxKeyboardState());
  
      /**
  
      /**
+        Returns @true if the Alt key was down at the time of the event.
+    */
+    bool AltDown() const;
  
  
+    /**
+        Returns @true if the Control key was down at the time of the event.
      */
      */
-    void SetSelectionForeground(const wxColour& c);
+    bool ControlDown() const;
  
      /**
  
      /**
-        Set the selection behaviour of the grid.
+        Top left corner of the rectangular area that was (de)selected.
+    */
+    wxGridCellCoords GetBottomRightCoords();
  
  
-        @param wxGridSelectCells()
-            The default mode where individual cells are selected.
-        @param wxGridSelectRows()
-            Selections will consist of whole rows.
-        @param wxGridSelectColumns()
-            Selections will consist of whole columns.
+    /**
+        Bottom row of the rectangular area that was (de)selected.
      */
      */
-    void SetSelectionMode(wxGrid::wxGridSelectionModes selmode);
+    int GetBottomRow();
  
      /**
  
      /**
-        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 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.
+        Left column of the rectangular area that was (de)selected.
      */
      */
-    bool SetTable(wxGridTableBase* table, bool takeOwnership = false,
-                  wxGrid::wxGridSelectionModes selmode = wxGrid::wxGridSelectCells);
+    int GetLeftCol();
  
      /**
  
      /**
-        Call this in order to make the column labels use a native look by using
-        wxRenderer::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.
+        Right column of the rectangular area that was (de)selected.
      */
      */
-    void SetUseNativeColLabels(bool native = true);
+    int GetRightCol();
  
      /**
  
      /**
-        Displays the in-place cell edit control for the current cell.
+        Top left corner of the rectangular area that was (de)selected.
      */
      */
-    void ShowCellEditControl();
+    wxGridCellCoords GetTopLeftCoords();
  
      /**
  
      /**
-        @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.
+        Top row of the rectangular area that was (de)selected.
      */
      */
-    int XToCol(int x, bool clipToMinMax = false) const;
+    int GetTopRow();
  
      /**
  
      /**
-        Returns the column whose right hand edge is close to the given logical x
-        position.
-        If no column edge is near to this position @c wxNOT_FOUND is returned.
+        Returns @true if the Meta key was down at the time of the event.
      */
      */
-    int XToEdgeOfCol(int x) const;
+    bool MetaDown() const;
  
      /**
  
      /**
-        Returns the row whose bottom edge is close to the given logical y position.
-        If no row edge is near to this position @c wxNOT_FOUND is returned.
+        Returns @true if the area was selected, @false otherwise.
      */
      */
-    int YToEdgeOfRow(int y) const;
+    bool Selecting();
  
      /**
  
      /**
-        Returns the grid row that corresponds to the logical y coordinate. Returns
-        @c wxNOT_FOUND if there is no row at the y position.
+        Returns @true if the Shift key was down at the time of the event.
      */
      */
-    int YToRow(int y) const;
+    bool ShiftDown() const;
  };
  
  
  
  /**
  };
  
  
  
  /**
-    @class wxGridCellBoolEditor
-    @wxheader{grid.h}
+    @class wxGridEditorCreatedEvent
  
  
-    The editor for boolean data.
+    @beginEventTable{wxGridEditorCreatedEvent}
+    @event{EVT_GRID_EDITOR_CREATED(func)}
+        The editor for a cell was created. Processes a
+        @c wxEVT_GRID_EDITOR_CREATED event type.
+    @event{EVT_GRID_CMD_EDITOR_CREATED(id, func)}
+        The editor for a cell was created; variant taking a window identifier.
+        Processes a @c wxEVT_GRID_EDITOR_CREATED event type.
+    @endEventTable
  
      @library{wxadv}
  
      @library{wxadv}
-    @category{FIXME}
-
-    @see wxGridCellEditor, wxGridCellFloatEditor, wxGridCellNumberEditor,
-    wxGridCellTextEditor, wxGridCellChoiceEditor
+    @category{grid,events}
  */
  */
-class wxGridCellBoolEditor : public wxGridCellEditor
+class wxGridEditorCreatedEvent : public wxCommandEvent
  {
  public:
      /**
          Default constructor.
      */
  {
  public:
      /**
          Default constructor.
      */
-    wxGridCellBoolEditor();
-
+    wxGridEditorCreatedEvent();
      /**
      /**
-        Returns @true if the given @a value is equal to the string representation of
-        the truth value we currently use (see
-        wxGridCellBoolEditor::UseStringValues).
+        Constructor for initializing all event attributes.
      */
      */
-    static bool IsTrueValue(const wxString& value);
+    wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj,
+                             int row, int col, wxControl* ctrl);
  
      /**
  
      /**
-        ,  wxString&@e valueFalse = _T(""))
-        This method allows to customize the values returned by GetValue() method for
-        the cell using this editor. By default, the default values of the arguments are
-        used, i.e. @c "1" is returned if the cell is checked and an empty string
-        otherwise, using this method allows to change this.
+        Returns the column at which the event occurred.
      */
      */
-    static void UseStringValues() const;
-};
-
-
-
-/**
-    @class wxGridUpdateLocker
-    @wxheader{grid.h}
-
-    This small class can be used to prevent wxGrid from redrawing
-    during its lifetime by calling wxGrid::BeginBatch
-    in its constructor and wxGrid::EndBatch in its
-    destructor. It is typically used in a function performing several operations
-    with a grid which would otherwise result in flicker. For example:
-
-    @code
-    void MyFrame::Foo()
-        {
-            m_grid = new wxGrid(this, ...);
-
-            wxGridUpdateLocker noUpdates(m_grid);
-            m_grid-AppendColumn();
-            ... many other operations with m_grid...
-            m_grid-AppendRow();
+    int GetCol();
  
  
-            // destructor called, grid refreshed
-        }
-    @endcode
+    /**
+        Returns the edit control.
+    */
+    wxControl* GetControl();
  
  
-    Using this class is easier and safer than calling
-    wxGrid::BeginBatch and wxGrid::EndBatch
-    because you don't risk not to call the latter (due to an exception for example).
+    /**
+        Returns the row at which the event occurred.
+    */
+    int GetRow();
  
  
-    @library{wxadv}
-    @category{FIXME}
-*/
-class wxGridUpdateLocker
-{
-public:
      /**
      /**
-        Creates an object preventing the updates of the specified @e grid. The
-        parameter could be @NULL in which case nothing is done. If @a grid is
-        non-@NULL then the grid must exist for longer than wxGridUpdateLocker object
-        itself.
-        The default constructor could be followed by a call to
-        Create() to set the
-        grid object later.
+        Sets the column at which the event occurred.
      */
      */
-    wxGridUpdateLocker(wxGrid* grid = NULL);
+    void SetCol(int col);
  
      /**
  
      /**
-        Destructor reenables updates for the grid this object is associated with.
+        Sets the edit control.
      */
      */
-    ~wxGridUpdateLocker();
+    void SetControl(wxControl* ctrl);
  
      /**
  
      /**
-        This method can be called if the object had been constructed using the default
-        constructor. It must not be called more than once.
+        Sets the row at which the event occurred.
      */
      */
-    void Create(wxGrid* grid);
+    void SetRow(int row);
  };
  
  };