pass wxIntPtr, not wxUIntPtr, to wxListCtrl::SortItems() callback as it's more compat...

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

/////////////////////////////////////////////////////////////////////////////\r
// Name:        wx/generic/private/grid.h\r
// Purpose:     Private wxGrid structures\r
// Author:      Michael Bedward (based on code by Julian Smart, Robin Dunn)\r
// Modified by: Santiago Palacios\r
// Created:     1/08/1999\r
// RCS-ID:      $Id$\r
// Copyright:   (c) Michael Bedward\r
// Licence:     wxWindows licence\r
/////////////////////////////////////////////////////////////////////////////\r
\r
#ifndef _WX_GENERIC_GRID_PRIVATE_H_\r
#define _WX_GENERIC_GRID_PRIVATE_H_\r
\r
#include "wx/defs.h"\r
\r
#if wxUSE_GRID\r
\r
// ----------------------------------------------------------------------------\r
// array classes\r
// ----------------------------------------------------------------------------\r
\r
WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridCellAttr *, wxArrayAttrs,\r
                                 class WXDLLIMPEXP_ADV);\r
\r
struct wxGridCellWithAttr\r
{\r
    wxGridCellWithAttr(int row, int col, wxGridCellAttr *attr_)\r
        : coords(row, col), attr(attr_)\r
    {\r
        wxASSERT( attr );\r
    }\r
\r
    wxGridCellWithAttr(const wxGridCellWithAttr& other)\r
        : coords(other.coords),\r
          attr(other.attr)\r
    {\r
        attr->IncRef();\r
    }\r
\r
    wxGridCellWithAttr& operator=(const wxGridCellWithAttr& other)\r
    {\r
        coords = other.coords;\r
        if (attr != other.attr)\r
        {\r
            attr->DecRef();\r
            attr = other.attr;\r
            attr->IncRef();\r
        }\r
        return *this;\r
    }\r
\r
    void ChangeAttr(wxGridCellAttr* new_attr)\r
    {\r
        if (attr != new_attr)\r
        {\r
            // "Delete" (i.e. DecRef) the old attribute.\r
            attr->DecRef();\r
            attr = new_attr;\r
            // Take ownership of the new attribute, i.e. no IncRef.\r
        }\r
    }\r
\r
    ~wxGridCellWithAttr()\r
    {\r
        attr->DecRef();\r
    }\r
\r
    wxGridCellCoords coords;\r
    wxGridCellAttr  *attr;\r
};\r
\r
WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellWithAttr, wxGridCellWithAttrArray,\r
                              class WXDLLIMPEXP_ADV);\r
\r
\r
// ----------------------------------------------------------------------------\r
// private classes\r
// ----------------------------------------------------------------------------\r
\r
// header column providing access to the column information stored in wxGrid\r
// via wxHeaderColumn interface\r
class wxGridHeaderColumn : public wxHeaderColumn\r
{\r
public:\r
    wxGridHeaderColumn(wxGrid *grid, int col)\r
        : m_grid(grid),\r
          m_col(col)\r
    {\r
    }\r
\r
    virtual wxString GetTitle() const { return m_grid->GetColLabelValue(m_col); }\r
    virtual wxBitmap GetBitmap() const { return wxNullBitmap; }\r
    virtual int GetWidth() const { return m_grid->GetColSize(m_col); }\r
    virtual int GetMinWidth() const { return 0; }\r
    virtual wxAlignment GetAlignment() const\r
    {\r
        int horz,\r
            vert;\r
        m_grid->GetColLabelAlignment(&horz, &vert);\r
\r
        return static_cast<wxAlignment>(horz);\r
    }\r
\r
    virtual int GetFlags() const\r
    {\r
        // we can't know in advance whether we can sort by this column or not\r
        // with wxGrid API so suppose we can by default\r
        int flags = wxCOL_SORTABLE;\r
        if ( m_grid->CanDragColSize() )\r
            flags |= wxCOL_RESIZABLE;\r
        if ( m_grid->CanDragColMove() )\r
            flags |= wxCOL_REORDERABLE;\r
        if ( GetWidth() == 0 )\r
            flags |= wxCOL_HIDDEN;\r
\r
        return flags;\r
    }\r
\r
    virtual bool IsSortKey() const\r
    {\r
        return m_grid->IsSortingBy(m_col);\r
    }\r
\r
    virtual bool IsSortOrderAscending() const\r
    {\r
        return m_grid->IsSortOrderAscending();\r
    }\r
\r
private:\r
    // these really should be const but are not because the column needs to be\r
    // assignable to be used in a wxVector (in STL build, in non-STL build we\r
    // avoid the need for this)\r
    wxGrid *m_grid;\r
    int m_col;\r
};\r
\r
// header control retreiving column information from the grid\r
class wxGridHeaderCtrl : public wxHeaderCtrl\r
{\r
public:\r
    wxGridHeaderCtrl(wxGrid *owner)\r
        : wxHeaderCtrl(owner,\r
                       wxID_ANY,\r
                       wxDefaultPosition,\r
                       wxDefaultSize,\r
                       wxHD_ALLOW_HIDE |\r
                       (owner->CanDragColMove() ? wxHD_ALLOW_REORDER : 0))\r
    {\r
    }\r
\r
protected:\r
    virtual const wxHeaderColumn& GetColumn(unsigned int idx) const\r
    {\r
        return m_columns[idx];\r
    }\r
\r
private:\r
    wxGrid *GetOwner() const { return static_cast<wxGrid *>(GetParent()); }\r
\r
    // override the base class method to update our m_columns array\r
    virtual void OnColumnCountChanging(unsigned int count)\r
    {\r
        const unsigned countOld = m_columns.size();\r
        if ( count < countOld )\r
        {\r
            // just discard the columns which don't exist any more (notice that\r
            // we can't use resize() here as it would require the vector\r
            // value_type, i.e. wxGridHeaderColumn to be default constructible,\r
            // which it is not)\r
            m_columns.erase(m_columns.begin() + count, m_columns.end());\r
        }\r
        else // new columns added\r
        {\r
            // add columns for the new elements\r
            for ( unsigned n = countOld; n < count; n++ )\r
                m_columns.push_back(wxGridHeaderColumn(GetOwner(), n));\r
        }\r
    }\r
\r
    // override to implement column auto sizing\r
    virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle)\r
    {\r
        // TODO: currently grid doesn't support computing the column best width\r
        //       from its contents so we just use the best label width as is\r
        GetOwner()->SetColSize(idx, widthTitle);\r
\r
        return true;\r
    }\r
\r
    // overridden to react to the actions using the columns popup menu\r
    virtual void UpdateColumnVisibility(unsigned int idx, bool show)\r
    {\r
        GetOwner()->SetColSize(idx, show ? wxGRID_AUTOSIZE : 0);\r
\r
        // as this is done by the user we should notify the main program about\r
        // it\r
        GetOwner()->SendEvent(wxEVT_GRID_COL_SIZE, -1, idx);\r
    }\r
\r
    // overridden to react to the columns order changes in the customization\r
    // dialog\r
    virtual void UpdateColumnsOrder(const wxArrayInt& order)\r
    {\r
        GetOwner()->SetColumnsOrder(order);\r
    }\r
\r
\r
    // event handlers forwarding wxHeaderCtrl events to wxGrid\r
    void OnClick(wxHeaderCtrlEvent& event)\r
    {\r
        GetOwner()->DoColHeaderClick(event.GetColumn());\r
    }\r
\r
    void OnBeginResize(wxHeaderCtrlEvent& event)\r
    {\r
        GetOwner()->DoStartResizeCol(event.GetColumn());\r
\r
        event.Skip();\r
    }\r
\r
    void OnResizing(wxHeaderCtrlEvent& event)\r
    {\r
        GetOwner()->DoUpdateResizeColWidth(event.GetWidth());\r
    }\r
\r
    void OnEndResize(wxHeaderCtrlEvent& event)\r
    {\r
        GetOwner()->DoEndDragResizeCol();\r
\r
        event.Skip();\r
    }\r
\r
    void OnBeginReorder(wxHeaderCtrlEvent& event)\r
    {\r
        GetOwner()->DoStartMoveCol(event.GetColumn());\r
    }\r
\r
    void OnEndReorder(wxHeaderCtrlEvent& event)\r
    {\r
        GetOwner()->DoEndMoveCol(event.GetNewOrder());\r
    }\r
\r
    wxVector<wxGridHeaderColumn> m_columns;\r
\r
    DECLARE_EVENT_TABLE()\r
    wxDECLARE_NO_COPY_CLASS(wxGridHeaderCtrl);\r
};\r
\r
// common base class for various grid subwindows\r
class WXDLLIMPEXP_ADV wxGridSubwindow : public wxWindow\r
{\r
public:\r
    wxGridSubwindow(wxGrid *owner,\r
                    int additionalStyle = 0,\r
                    const wxString& name = wxPanelNameStr)\r
        : wxWindow(owner, wxID_ANY,\r
                   wxDefaultPosition, wxDefaultSize,\r
                   wxBORDER_NONE | additionalStyle,\r
                   name)\r
    {\r
        m_owner = owner;\r
    }\r
\r
    virtual bool AcceptsFocus() const { return false; }\r
\r
    wxGrid *GetOwner() { return m_owner; }\r
\r
protected:\r
    void OnMouseCaptureLost(wxMouseCaptureLostEvent& event);\r
\r
    wxGrid *m_owner;\r
\r
    DECLARE_EVENT_TABLE()\r
    wxDECLARE_NO_COPY_CLASS(wxGridSubwindow);\r
};\r
\r
class WXDLLIMPEXP_ADV wxGridRowLabelWindow : public wxGridSubwindow\r
{\r
public:\r
    wxGridRowLabelWindow(wxGrid *parent)\r
      : wxGridSubwindow(parent)\r
    {\r
    }\r
\r
\r
private:\r
    void OnPaint( wxPaintEvent& event );\r
    void OnMouseEvent( wxMouseEvent& event );\r
    void OnMouseWheel( wxMouseEvent& event );\r
\r
    DECLARE_EVENT_TABLE()\r
    wxDECLARE_NO_COPY_CLASS(wxGridRowLabelWindow);\r
};\r
\r
\r
class WXDLLIMPEXP_ADV wxGridColLabelWindow : public wxGridSubwindow\r
{\r
public:\r
    wxGridColLabelWindow(wxGrid *parent)\r
        : wxGridSubwindow(parent)\r
    {\r
    }\r
\r
\r
private:\r
    void OnPaint( wxPaintEvent& event );\r
    void OnMouseEvent( wxMouseEvent& event );\r
    void OnMouseWheel( wxMouseEvent& event );\r
\r
    DECLARE_EVENT_TABLE()\r
    wxDECLARE_NO_COPY_CLASS(wxGridColLabelWindow);\r
};\r
\r
\r
class WXDLLIMPEXP_ADV wxGridCornerLabelWindow : public wxGridSubwindow\r
{\r
public:\r
    wxGridCornerLabelWindow(wxGrid *parent)\r
        : wxGridSubwindow(parent)\r
    {\r
    }\r
\r
private:\r
    void OnMouseEvent( wxMouseEvent& event );\r
    void OnMouseWheel( wxMouseEvent& event );\r
    void OnPaint( wxPaintEvent& event );\r
\r
    DECLARE_EVENT_TABLE()\r
    wxDECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow);\r
};\r
\r
class WXDLLIMPEXP_ADV wxGridWindow : public wxGridSubwindow\r
{\r
public:\r
    wxGridWindow(wxGrid *parent)\r
        : wxGridSubwindow(parent,\r
                          wxWANTS_CHARS | wxCLIP_CHILDREN,\r
                          "GridWindow")\r
    {\r
    }\r
\r
\r
    virtual void ScrollWindow( int dx, int dy, const wxRect *rect );\r
\r
    virtual bool AcceptsFocus() const { return true; }\r
\r
private:\r
    void OnPaint( wxPaintEvent &event );\r
    void OnMouseWheel( wxMouseEvent& event );\r
    void OnMouseEvent( wxMouseEvent& event );\r
    void OnKeyDown( wxKeyEvent& );\r
    void OnKeyUp( wxKeyEvent& );\r
    void OnChar( wxKeyEvent& );\r
    void OnEraseBackground( wxEraseEvent& );\r
    void OnFocus( wxFocusEvent& );\r
\r
    DECLARE_EVENT_TABLE()\r
    wxDECLARE_NO_COPY_CLASS(wxGridWindow);\r
};\r
\r
// ----------------------------------------------------------------------------\r
// the internal data representation used by wxGridCellAttrProvider\r
// ----------------------------------------------------------------------------\r
\r
// this class stores attributes set for cells\r
class WXDLLIMPEXP_ADV wxGridCellAttrData\r
{\r
public:\r
    void SetAttr(wxGridCellAttr *attr, int row, int col);\r
    wxGridCellAttr *GetAttr(int row, int col) const;\r
    void UpdateAttrRows( size_t pos, int numRows );\r
    void UpdateAttrCols( size_t pos, int numCols );\r
\r
private:\r
    // searches for the attr for given cell, returns wxNOT_FOUND if not found\r
    int FindIndex(int row, int col) const;\r
\r
    wxGridCellWithAttrArray m_attrs;\r
};\r
\r
// this class stores attributes set for rows or columns\r
class WXDLLIMPEXP_ADV wxGridRowOrColAttrData\r
{\r
public:\r
    // empty ctor to suppress warnings\r
    wxGridRowOrColAttrData() {}\r
    ~wxGridRowOrColAttrData();\r
\r
    void SetAttr(wxGridCellAttr *attr, int rowOrCol);\r
    wxGridCellAttr *GetAttr(int rowOrCol) const;\r
    void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );\r
\r
private:\r
    wxArrayInt m_rowsOrCols;\r
    wxArrayAttrs m_attrs;\r
};\r
\r
// NB: this is just a wrapper around 3 objects: one which stores cell\r
//     attributes, and 2 others for row/col ones\r
class WXDLLIMPEXP_ADV wxGridCellAttrProviderData\r
{\r
public:\r
    wxGridCellAttrData m_cellAttrs;\r
    wxGridRowOrColAttrData m_rowAttrs,\r
                           m_colAttrs;\r
};\r
\r
// ----------------------------------------------------------------------------\r
// operations classes abstracting the difference between operating on rows and\r
// columns\r
// ----------------------------------------------------------------------------\r
\r
// This class allows to write a function only once because by using its methods\r
// it will apply to both columns and rows.\r
//\r
// This is an abstract interface definition, the two concrete implementations\r
// below should be used when working with rows and columns respectively.\r
class wxGridOperations\r
{\r
public:\r
    // Returns the operations in the other direction, i.e. wxGridRowOperations\r
    // if this object is a wxGridColumnOperations and vice versa.\r
    virtual wxGridOperations& Dual() const = 0;\r
\r
    // Return the number of rows or columns.\r
    virtual int GetNumberOfLines(const wxGrid *grid) const = 0;\r
\r
    // Return the selection mode which allows selecting rows or columns.\r
    virtual wxGrid::wxGridSelectionModes GetSelectionMode() const = 0;\r
\r
    // Make a wxGridCellCoords from the given components: thisDir is row or\r
    // column and otherDir is column or row\r
    virtual wxGridCellCoords MakeCoords(int thisDir, int otherDir) const = 0;\r
\r
    // Calculate the scrolled position of the given abscissa or ordinate.\r
    virtual int CalcScrolledPosition(wxGrid *grid, int pos) const = 0;\r
\r
    // Selects the horizontal or vertical component from the given object.\r
    virtual int Select(const wxGridCellCoords& coords) const = 0;\r
    virtual int Select(const wxPoint& pt) const = 0;\r
    virtual int Select(const wxSize& sz) const = 0;\r
    virtual int Select(const wxRect& r) const = 0;\r
    virtual int& Select(wxRect& r) const = 0;\r
\r
    // Returns width or height of the rectangle\r
    virtual int& SelectSize(wxRect& r) const = 0;\r
\r
    // Make a wxSize such that Select() applied to it returns first component\r
    virtual wxSize MakeSize(int first, int second) const = 0;\r
\r
    // Sets the row or column component of the given cell coordinates\r
    virtual void Set(wxGridCellCoords& coords, int line) const = 0;\r
\r
\r
    // Draws a line parallel to the row or column, i.e. horizontal or vertical:\r
    // pos is the horizontal or vertical position of the line and start and end\r
    // are the coordinates of the line extremities in the other direction\r
    virtual void\r
        DrawParallelLine(wxDC& dc, int start, int end, int pos) const = 0;\r
\r
    // Draw a horizontal or vertical line across the given rectangle\r
    // (this is implemented in terms of above and uses Select() to extract\r
    // start and end from the given rectangle)\r
    void DrawParallelLineInRect(wxDC& dc, const wxRect& rect, int pos) const\r
    {\r
        const int posStart = Select(rect.GetPosition());\r
        DrawParallelLine(dc, posStart, posStart + Select(rect.GetSize()), pos);\r
    }\r
\r
\r
    // Return the index of the row or column at the given pixel coordinate.\r
    virtual int\r
        PosToLine(const wxGrid *grid, int pos, bool clip = false) const = 0;\r
\r
    // Get the top/left position, in pixels, of the given row or column\r
    virtual int GetLineStartPos(const wxGrid *grid, int line) const = 0;\r
\r
    // Get the bottom/right position, in pixels, of the given row or column\r
    virtual int GetLineEndPos(const wxGrid *grid, int line) const = 0;\r
\r
    // Get the height/width of the given row/column\r
    virtual int GetLineSize(const wxGrid *grid, int line) const = 0;\r
\r
    // Get wxGrid::m_rowBottoms/m_colRights array\r
    virtual const wxArrayInt& GetLineEnds(const wxGrid *grid) const = 0;\r
\r
    // Get default height row height or column width\r
    virtual int GetDefaultLineSize(const wxGrid *grid) const = 0;\r
\r
    // Return the minimal acceptable row height or column width\r
    virtual int GetMinimalAcceptableLineSize(const wxGrid *grid) const = 0;\r
\r
    // Return the minimal row height or column width\r
    virtual int GetMinimalLineSize(const wxGrid *grid, int line) const = 0;\r
\r
    // Set the row height or column width\r
    virtual void SetLineSize(wxGrid *grid, int line, int size) const = 0;\r
\r
    // Set the row default height or column default width\r
    virtual void SetDefaultLineSize(wxGrid *grid, int size, bool resizeExisting) const = 0;\r
\r
    // True if rows/columns can be resized by user\r
    virtual bool CanResizeLines(const wxGrid *grid) const = 0;\r
\r
\r
    // Return the index of the line at the given position\r
    //\r
    // NB: currently this is always identity for the rows as reordering is only\r
    //     implemented for the lines\r
    virtual int GetLineAt(const wxGrid *grid, int line) const = 0;\r
\r
\r
    // Get the row or column label window\r
    virtual wxWindow *GetHeaderWindow(wxGrid *grid) const = 0;\r
\r
    // Get the width or height of the row or column label window\r
    virtual int GetHeaderWindowSize(wxGrid *grid) const = 0;\r
\r
\r
    // This class is never used polymorphically but give it a virtual dtor\r
    // anyhow to suppress g++ complaints about it\r
    virtual ~wxGridOperations() { }\r
};\r
\r
class wxGridRowOperations : public wxGridOperations\r
{\r
public:\r
    virtual wxGridOperations& Dual() const;\r
\r
    virtual int GetNumberOfLines(const wxGrid *grid) const\r
        { return grid->GetNumberRows(); }\r
\r
    virtual wxGrid::wxGridSelectionModes GetSelectionMode() const\r
        { return wxGrid::wxGridSelectRows; }\r
\r
    virtual wxGridCellCoords MakeCoords(int thisDir, int otherDir) const\r
        { return wxGridCellCoords(thisDir, otherDir); }\r
\r
    virtual int CalcScrolledPosition(wxGrid *grid, int pos) const\r
        { return grid->CalcScrolledPosition(wxPoint(pos, 0)).x; }\r
\r
    virtual int Select(const wxGridCellCoords& c) const { return c.GetRow(); }\r
    virtual int Select(const wxPoint& pt) const { return pt.x; }\r
    virtual int Select(const wxSize& sz) const { return sz.x; }\r
    virtual int Select(const wxRect& r) const { return r.x; }\r
    virtual int& Select(wxRect& r) const { return r.x; }\r
    virtual int& SelectSize(wxRect& r) const { return r.width; }\r
    virtual wxSize MakeSize(int first, int second) const\r
        { return wxSize(first, second); }\r
    virtual void Set(wxGridCellCoords& coords, int line) const\r
        { coords.SetRow(line); }\r
\r
    virtual void DrawParallelLine(wxDC& dc, int start, int end, int pos) const\r
        { dc.DrawLine(start, pos, end, pos); }\r
\r
    virtual int PosToLine(const wxGrid *grid, int pos, bool clip = false) const\r
        { return grid->YToRow(pos, clip); }\r
    virtual int GetLineStartPos(const wxGrid *grid, int line) const\r
        { return grid->GetRowTop(line); }\r
    virtual int GetLineEndPos(const wxGrid *grid, int line) const\r
        { return grid->GetRowBottom(line); }\r
    virtual int GetLineSize(const wxGrid *grid, int line) const\r
        { return grid->GetRowHeight(line); }\r
    virtual const wxArrayInt& GetLineEnds(const wxGrid *grid) const\r
        { return grid->m_rowBottoms; }\r
    virtual int GetDefaultLineSize(const wxGrid *grid) const\r
        { return grid->GetDefaultRowSize(); }\r
    virtual int GetMinimalAcceptableLineSize(const wxGrid *grid) const\r
        { return grid->GetRowMinimalAcceptableHeight(); }\r
    virtual int GetMinimalLineSize(const wxGrid *grid, int line) const\r
        { return grid->GetRowMinimalHeight(line); }\r
    virtual void SetLineSize(wxGrid *grid, int line, int size) const\r
        { grid->SetRowSize(line, size); }\r
    virtual bool CanResizeLines(const wxGrid *grid) const\r
        { return grid->CanDragRowSize(); }\r
    virtual void SetDefaultLineSize(wxGrid *grid, int size, bool resizeExisting) const\r
        {  grid->SetDefaultRowSize(size, resizeExisting); } \r
\r
    virtual int GetLineAt(const wxGrid * WXUNUSED(grid), int line) const\r
        { return line; } // TODO: implement row reordering\r
\r
    virtual wxWindow *GetHeaderWindow(wxGrid *grid) const\r
        { return grid->GetGridRowLabelWindow(); }\r
    virtual int GetHeaderWindowSize(wxGrid *grid) const\r
        { return grid->GetRowLabelSize(); }\r
};\r
\r
class wxGridColumnOperations : public wxGridOperations\r
{\r
public:\r
    virtual wxGridOperations& Dual() const;\r
\r
    virtual int GetNumberOfLines(const wxGrid *grid) const\r
        { return grid->GetNumberCols(); }\r
\r
    virtual wxGrid::wxGridSelectionModes GetSelectionMode() const\r
        { return wxGrid::wxGridSelectColumns; }\r
\r
    virtual wxGridCellCoords MakeCoords(int thisDir, int otherDir) const\r
        { return wxGridCellCoords(otherDir, thisDir); }\r
\r
    virtual int CalcScrolledPosition(wxGrid *grid, int pos) const\r
        { return grid->CalcScrolledPosition(wxPoint(0, pos)).y; }\r
\r
    virtual int Select(const wxGridCellCoords& c) const { return c.GetCol(); }\r
    virtual int Select(const wxPoint& pt) const { return pt.y; }\r
    virtual int Select(const wxSize& sz) const { return sz.y; }\r
    virtual int Select(const wxRect& r) const { return r.y; }\r
    virtual int& Select(wxRect& r) const { return r.y; }\r
    virtual int& SelectSize(wxRect& r) const { return r.height; }\r
    virtual wxSize MakeSize(int first, int second) const\r
        { return wxSize(second, first); }\r
    virtual void Set(wxGridCellCoords& coords, int line) const\r
        { coords.SetCol(line); }\r
\r
    virtual void DrawParallelLine(wxDC& dc, int start, int end, int pos) const\r
        { dc.DrawLine(pos, start, pos, end); }\r
\r
    virtual int PosToLine(const wxGrid *grid, int pos, bool clip = false) const\r
        { return grid->XToCol(pos, clip); }\r
    virtual int GetLineStartPos(const wxGrid *grid, int line) const\r
        { return grid->GetColLeft(line); }\r
    virtual int GetLineEndPos(const wxGrid *grid, int line) const\r
        { return grid->GetColRight(line); }\r
    virtual int GetLineSize(const wxGrid *grid, int line) const\r
        { return grid->GetColWidth(line); }\r
    virtual const wxArrayInt& GetLineEnds(const wxGrid *grid) const\r
        { return grid->m_colRights; }\r
    virtual int GetDefaultLineSize(const wxGrid *grid) const\r
        { return grid->GetDefaultColSize(); }\r
    virtual int GetMinimalAcceptableLineSize(const wxGrid *grid) const\r
        { return grid->GetColMinimalAcceptableWidth(); }\r
    virtual int GetMinimalLineSize(const wxGrid *grid, int line) const\r
        { return grid->GetColMinimalWidth(line); }\r
    virtual void SetLineSize(wxGrid *grid, int line, int size) const\r
        { grid->SetColSize(line, size); }\r
    virtual bool CanResizeLines(const wxGrid *grid) const\r
        { return grid->CanDragColSize(); }\r
    virtual void SetDefaultLineSize(wxGrid *grid, int size, bool resizeExisting) const\r
        {  grid->SetDefaultColSize(size, resizeExisting); } \r
\r
    virtual int GetLineAt(const wxGrid *grid, int line) const\r
        { return grid->GetColAt(line); }\r
\r
    virtual wxWindow *GetHeaderWindow(wxGrid *grid) const\r
        { return grid->GetGridColLabelWindow(); }\r
    virtual int GetHeaderWindowSize(wxGrid *grid) const\r
        { return grid->GetColLabelSize(); }\r
};\r
\r
// This class abstracts the difference between operations going forward\r
// (down/right) and backward (up/left) and allows to use the same code for\r
// functions which differ only in the direction of grid traversal\r
//\r
// Like wxGridOperations it's an ABC with two concrete subclasses below. Unlike\r
// it, this is a normal object and not just a function dispatch table and has a\r
// non-default ctor.\r
//\r
// Note: the explanation of this discrepancy is the existence of (very useful)\r
// Dual() method in wxGridOperations which forces us to make wxGridOperations a\r
// function dispatcher only.\r
class wxGridDirectionOperations\r
{\r
public:\r
    // The oper parameter to ctor selects whether we work with rows or columns\r
    wxGridDirectionOperations(wxGrid *grid, const wxGridOperations& oper)\r
        : m_grid(grid),\r
          m_oper(oper)\r
    {\r
    }\r
\r
    // Check if the component of this point in our direction is at the\r
    // boundary, i.e. is the first/last row/column\r
    virtual bool IsAtBoundary(const wxGridCellCoords& coords) const = 0;\r
\r
    // Increment the component of this point in our direction\r
    virtual void Advance(wxGridCellCoords& coords) const = 0;\r
\r
    // Find the line at the given distance, in pixels, away from this one\r
    // (this uses clipping, i.e. anything after the last line is counted as the\r
    // last one and anything before the first one as 0)\r
    virtual int MoveByPixelDistance(int line, int distance) const = 0;\r
\r
    // This class is never used polymorphically but give it a virtual dtor\r
    // anyhow to suppress g++ complaints about it\r
    virtual ~wxGridDirectionOperations() { }\r
\r
protected:\r
    wxGrid * const m_grid;\r
    const wxGridOperations& m_oper;\r
};\r
\r
class wxGridBackwardOperations : public wxGridDirectionOperations\r
{\r
public:\r
    wxGridBackwardOperations(wxGrid *grid, const wxGridOperations& oper)\r
        : wxGridDirectionOperations(grid, oper)\r
    {\r
    }\r
\r
    virtual bool IsAtBoundary(const wxGridCellCoords& coords) const\r
    {\r
        wxASSERT_MSG( m_oper.Select(coords) >= 0, "invalid row/column" );\r
\r
        return m_oper.Select(coords) == 0;\r
    }\r
\r
    virtual void Advance(wxGridCellCoords& coords) const\r
    {\r
        wxASSERT( !IsAtBoundary(coords) );\r
\r
        m_oper.Set(coords, m_oper.Select(coords) - 1);\r
    }\r
\r
    virtual int MoveByPixelDistance(int line, int distance) const\r
    {\r
        int pos = m_oper.GetLineStartPos(m_grid, line);\r
        return m_oper.PosToLine(m_grid, pos - distance + 1, true);\r
    }\r
};\r
\r
class wxGridForwardOperations : public wxGridDirectionOperations\r
{\r
public:\r
    wxGridForwardOperations(wxGrid *grid, const wxGridOperations& oper)\r
        : wxGridDirectionOperations(grid, oper),\r
          m_numLines(oper.GetNumberOfLines(grid))\r
    {\r
    }\r
\r
    virtual bool IsAtBoundary(const wxGridCellCoords& coords) const\r
    {\r
        wxASSERT_MSG( m_oper.Select(coords) < m_numLines, "invalid row/column" );\r
\r
        return m_oper.Select(coords) == m_numLines - 1;\r
    }\r
\r
    virtual void Advance(wxGridCellCoords& coords) const\r
    {\r
        wxASSERT( !IsAtBoundary(coords) );\r
\r
        m_oper.Set(coords, m_oper.Select(coords) + 1);\r
    }\r
\r
    virtual int MoveByPixelDistance(int line, int distance) const\r
    {\r
        int pos = m_oper.GetLineStartPos(m_grid, line);\r
        return m_oper.PosToLine(m_grid, pos + distance, true);\r
    }\r
\r
private:\r
    const int m_numLines;\r
};\r
\r
// ----------------------------------------------------------------------------\r
// private helpers\r
// ----------------------------------------------------------------------------\r
\r
namespace\r
{\r
\r
// ensure that first is less or equal to second, swapping the values if\r
// necessary\r
void EnsureFirstLessThanSecond(int& first, int& second)\r
{\r
    if ( first > second )\r
        wxSwap(first, second);\r
}\r
\r
} // anonymous namespace\r
\r
// ----------------------------------------------------------------------------\r
// data structures used for the data type registry\r
// ----------------------------------------------------------------------------\r
\r
struct wxGridDataTypeInfo\r
{\r
    wxGridDataTypeInfo(const wxString& typeName,\r
                       wxGridCellRenderer* renderer,\r
                       wxGridCellEditor* editor)\r
        : m_typeName(typeName), m_renderer(renderer), m_editor(editor)\r
        {}\r
\r
    ~wxGridDataTypeInfo()\r
    {\r
        wxSafeDecRef(m_renderer);\r
        wxSafeDecRef(m_editor);\r
    }\r
\r
    wxString            m_typeName;\r
    wxGridCellRenderer* m_renderer;\r
    wxGridCellEditor*   m_editor;\r
\r
    wxDECLARE_NO_COPY_CLASS(wxGridDataTypeInfo);\r
};\r
\r
\r
WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridDataTypeInfo*, wxGridDataTypeInfoArray,\r
                                 class WXDLLIMPEXP_ADV);\r
\r
\r
class WXDLLIMPEXP_ADV wxGridTypeRegistry\r
{\r
public:\r
    wxGridTypeRegistry() {}\r
    ~wxGridTypeRegistry();\r
\r
    void RegisterDataType(const wxString& typeName,\r
                     wxGridCellRenderer* renderer,\r
                     wxGridCellEditor* editor);\r
\r
    // find one of already registered data types\r
    int FindRegisteredDataType(const wxString& typeName);\r
\r
    // try to FindRegisteredDataType(), if this fails and typeName is one of\r
    // standard typenames, register it and return its index\r
    int FindDataType(const wxString& typeName);\r
\r
    // try to FindDataType(), if it fails see if it is not one of already\r
    // registered data types with some params in which case clone the\r
    // registered data type and set params for it\r
    int FindOrCloneDataType(const wxString& typeName);\r
\r
    wxGridCellRenderer* GetRenderer(int index);\r
    wxGridCellEditor*   GetEditor(int index);\r
\r
private:\r
    wxGridDataTypeInfoArray m_typeinfo;\r
};\r
\r
#endif // wxUSE_GRID\r
#endif // _WX_GENERIC_GRID_PRIVATE_H_\r