X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/2b73a34e1b6e06097163555b743a118ebf7afd6b..59678f3fae7d537003fe1dbd0d0049694ec946c1:/src/generic/grid.cpp

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index 284143a62e..3601bf69d6 100644
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -18,6 +18,8 @@
 
 #if wxUSE_GRID
 
+#include "wx/grid.h"
+
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/dcclient.h"
@@ -37,9 +39,10 @@
 #include "wx/tokenzr.h"
 #include "wx/renderer.h"
 
-#include "wx/grid.h"
 #include "wx/generic/gridsel.h"
 
+const wxChar wxGridNameStr[] = wxT("grid");
+
 #if defined(__WXMOTIF__)
     #define WXUNUSED_MOTIF(identifier)  WXUNUSED(identifier)
 #else
@@ -117,16 +120,43 @@ DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED)
 // private classes
 // ----------------------------------------------------------------------------
 
-class WXDLLIMPEXP_ADV wxGridRowLabelWindow : public wxWindow
+// common base class for various grid subwindows
+class WXDLLIMPEXP_ADV wxGridSubwindow : public wxWindow
 {
 public:
-    wxGridRowLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridSubwindow() { m_owner = NULL; }
+    wxGridSubwindow(wxGrid *owner,
+                    wxWindowID id,
+                    const wxPoint& pos,
+                    const wxSize& size,
+                    int additionalStyle = 0,
+                    const wxString& name = wxPanelNameStr)
+        : wxWindow(owner, id, pos, size,
+                   wxWANTS_CHARS | wxBORDER_NONE | additionalStyle,
+                   name)
+    {
+        m_owner = owner;
+    }
+
+    wxGrid *GetOwner() { return m_owner; }
+
+protected:
+    void OnMouseCaptureLost(wxMouseCaptureLostEvent& event);
+
+    wxGrid *m_owner;
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_NO_COPY_CLASS(wxGridSubwindow)
+};
+
+class WXDLLIMPEXP_ADV wxGridRowLabelWindow : public wxGridSubwindow
+{
+public:
+    wxGridRowLabelWindow() { }
     wxGridRowLabelWindow( wxGrid *parent, wxWindowID id,
                           const wxPoint &pos, const wxSize &size );
 
 private:
-    wxGrid   *m_owner;
-
     void OnPaint( wxPaintEvent& event );
     void OnMouseEvent( wxMouseEvent& event );
     void OnMouseWheel( wxMouseEvent& event );
@@ -140,16 +170,14 @@ private:
 };
 
 
-class WXDLLIMPEXP_ADV wxGridColLabelWindow : public wxWindow
+class WXDLLIMPEXP_ADV wxGridColLabelWindow : public wxGridSubwindow
 {
 public:
-    wxGridColLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridColLabelWindow() { }
     wxGridColLabelWindow( wxGrid *parent, wxWindowID id,
                           const wxPoint &pos, const wxSize &size );
 
 private:
-    wxGrid   *m_owner;
-
     void OnPaint( wxPaintEvent& event );
     void OnMouseEvent( wxMouseEvent& event );
     void OnMouseWheel( wxMouseEvent& event );
@@ -163,16 +191,14 @@ private:
 };
 
 
-class WXDLLIMPEXP_ADV wxGridCornerLabelWindow : public wxWindow
+class WXDLLIMPEXP_ADV wxGridCornerLabelWindow : public wxGridSubwindow
 {
 public:
-    wxGridCornerLabelWindow() { m_owner = (wxGrid *)NULL; }
+    wxGridCornerLabelWindow() { }
     wxGridCornerLabelWindow( wxGrid *parent, wxWindowID id,
                              const wxPoint &pos, const wxSize &size );
 
 private:
-    wxGrid *m_owner;
-
     void OnMouseEvent( wxMouseEvent& event );
     void OnMouseWheel( wxMouseEvent& event );
     void OnKeyDown( wxKeyEvent& event );
@@ -185,12 +211,11 @@ private:
     DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow)
 };
 
-class WXDLLIMPEXP_ADV wxGridWindow : public wxWindow
+class WXDLLIMPEXP_ADV wxGridWindow : public wxGridSubwindow
 {
 public:
     wxGridWindow()
     {
-        m_owner = NULL;
         m_rowLabelWin = NULL;
         m_colLabelWin = NULL;
     }
@@ -199,14 +224,10 @@ public:
                   wxGridRowLabelWindow *rowLblWin,
                   wxGridColLabelWindow *colLblWin,
                   wxWindowID id, const wxPoint &pos, const wxSize &size );
-    ~wxGridWindow() {}
 
     void ScrollWindow( int dx, int dy, const wxRect *rect );
 
-    wxGrid* GetOwner() { return m_owner; }
-
 private:
-    wxGrid                   *m_owner;
     wxGridRowLabelWindow     *m_rowLabelWin;
     wxGridColLabelWindow     *m_colLabelWin;
 
@@ -624,7 +645,11 @@ void wxGridCellTextEditor::Create(wxWindow* parent,
     m_control = new wxTextCtrl(parent, id, wxEmptyString,
                                wxDefaultPosition, wxDefaultSize
 #if defined(__WXMSW__)
-                               , wxTE_PROCESS_TAB | wxTE_AUTO_SCROLL | wxNO_BORDER
+                               ,
+                               wxTE_PROCESS_ENTER |
+                               wxTE_PROCESS_TAB |
+                               wxTE_AUTO_SCROLL |
+                               wxNO_BORDER
 #endif
                               );
 
@@ -1192,27 +1217,30 @@ bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
 {
     if ( wxGridCellEditor::IsAcceptedKey(event) )
     {
-        int keycode = event.GetKeyCode();
-        printf("%d\n", keycode);
-        // accept digits, 'e' as in '1e+6', also '-', '+', and '.'
-        char tmpbuf[2];
-        tmpbuf[0] = (char) keycode;
-        tmpbuf[1] = '\0';
-        wxString strbuf(tmpbuf, *wxConvCurrent);
+        const int keycode = event.GetKeyCode();
+        if ( isascii(keycode) )
+        {
+            char tmpbuf[2];
+            tmpbuf[0] = (char) keycode;
+            tmpbuf[1] = '\0';
+            wxString strbuf(tmpbuf, *wxConvCurrent);
 
 #if wxUSE_INTL
-        bool is_decimal_point =
-            ( strbuf == wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT,
-                                          wxLOCALE_CAT_NUMBER) );
+            const wxString decimalPoint =
+                wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER);
 #else
-        bool is_decimal_point = ( strbuf == _T(".") );
+            const wxString decimalPoint(_T('.'));
 #endif
 
-        if ( (keycode < 128) &&
-             (wxIsdigit(keycode) || tolower(keycode) == 'e' ||
-              is_decimal_point || keycode == '+' || keycode == '-') )
-        {
-            return true;
+            // accept digits, 'e' as in '1e+6', also '-', '+', and '.'
+            if ( wxIsdigit(keycode) ||
+                    tolower(keycode) == 'e' ||
+                        keycode == decimalPoint ||
+                            keycode == '+' ||
+                                keycode == '-' )
+            {
+                return true;
+            }
         }
     }
 
@@ -1227,6 +1255,9 @@ bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
 // wxGridCellBoolEditor
 // ----------------------------------------------------------------------------
 
+// the default values for GetValue()
+wxString wxGridCellBoolEditor::ms_stringValues[2] = { _T(""), _T("1") };
+
 void wxGridCellBoolEditor::Create(wxWindow* parent,
                                   wxWindowID id,
                                   wxEvtHandler* evtHandler)
@@ -1332,7 +1363,19 @@ void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
     else
     {
         wxString cellval( grid->GetTable()->GetValue(row, col) );
-        m_startValue = !( !cellval || (cellval == wxT("0")) );
+
+        if ( cellval == ms_stringValues[false] )
+            m_startValue = false;
+        else if ( cellval == ms_stringValues[true] )
+            m_startValue = true;
+        else
+        {
+            // do not try to be smart here and convert it to true or false
+            // because we'll still overwrite it with something different and
+            // this risks to be very surprising for the user code, let them
+            // know about it
+            wxFAIL_MSG( _T("invalid value for a cell with bool editor!") );
+        }
     }
 
     CBox()->SetValue(m_startValue);
@@ -1352,10 +1395,11 @@ bool wxGridCellBoolEditor::EndEdit(int row, int col,
 
     if ( changed )
     {
-        if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
-            grid->GetTable()->SetValueAsBool(row, col, value);
+        wxGridTableBase * const table = grid->GetTable();
+        if ( table->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
+            table->SetValueAsBool(row, col, value);
         else
-            grid->GetTable()->SetValue(row, col, value ? _T("1") : wxEmptyString);
+            table->SetValue(row, col, GetValue());
     }
 
     return changed;
@@ -1410,12 +1454,23 @@ void wxGridCellBoolEditor::StartingKey(wxKeyEvent& event)
     }
 }
 
-
-// return the value as "1" for true and the empty string for false
 wxString wxGridCellBoolEditor::GetValue() const
 {
-  bool bSet = CBox()->GetValue();
-  return bSet ? _T("1") : wxEmptyString;
+  return ms_stringValues[CBox()->GetValue()];
+}
+
+/* static */ void
+wxGridCellBoolEditor::UseStringValues(const wxString& valueTrue,
+                                      const wxString& valueFalse)
+{
+    ms_stringValues[false] = valueFalse;
+    ms_stringValues[true] = valueTrue;
+}
+
+/* static */ bool
+wxGridCellBoolEditor::IsTrueValue(const wxString& value)
+{
+    return value == ms_stringValues[true];
 }
 
 #endif // wxUSE_CHECKBOX
@@ -2211,7 +2266,7 @@ void wxGridCellBoolRenderer::Draw(wxGrid& grid,
     else
     {
         wxString cellval( grid.GetTable()->GetValue(row, col) );
-        value = !( !cellval || (cellval == wxT("0")) );
+        value = wxGridCellBoolEditor::IsTrueValue(cellval);
     }
 
     if ( value )
@@ -2286,6 +2341,7 @@ wxGridCellAttr *wxGridCellAttr::Clone() const
     if ( IsReadOnly() )
         attr->SetReadOnly();
 
+    attr->SetOverflow( m_overflow == Overflow );
     attr->SetKind( m_attrkind );
 
     return attr;
@@ -2437,7 +2493,7 @@ void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
 // NULL (because the table has a type that the grid does not have in its
 // registry), then the grid's default editor or renderer is used.
 
-wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col) const
+wxGridCellRenderer* wxGridCellAttr::GetRenderer(const wxGrid* grid, int row, int col) const
 {
     wxGridCellRenderer *renderer = NULL;
 
@@ -2481,7 +2537,7 @@ wxGridCellRenderer* wxGridCellAttr::GetRenderer(wxGrid* grid, int row, int col)
 }
 
 // same as above, except for s/renderer/editor/g
-wxGridCellEditor* wxGridCellAttr::GetEditor(wxGrid* grid, int row, int col) const
+wxGridCellEditor* wxGridCellAttr::GetEditor(const wxGrid* grid, int row, int col) const
 {
     wxGridCellEditor *editor = NULL;
 
@@ -2661,7 +2717,7 @@ int wxGridCellAttrData::FindIndex(int row, int col) const
 
 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
 {
-    size_t count = m_attrs.Count();
+    size_t count = m_attrs.GetCount();
     for ( size_t n = 0; n < count; n++ )
     {
         m_attrs[n]->DecRef();
@@ -2902,7 +2958,7 @@ void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
 
 wxGridTypeRegistry::~wxGridTypeRegistry()
 {
-    size_t count = m_typeinfo.Count();
+    size_t count = m_typeinfo.GetCount();
     for ( size_t i = 0; i < count; i++ )
         delete m_typeinfo[i];
 }
@@ -3610,7 +3666,12 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
 
     if ( !m_colLabels.IsEmpty() )
     {
-        m_colLabels.RemoveAt( colID, numCols );
+        // m_colLabels stores just as many elements as it needs, e.g. if only
+        // the label of the first column had been set it would have only one
+        // element and not numCols, so account for it
+        int nToRm = m_colLabels.size() - colID;
+        if ( nToRm > 0 )
+            m_colLabels.RemoveAt( colID, nToRm );
     }
 
     for ( row = 0; row < curNumRows; row++ )
@@ -3702,9 +3763,18 @@ void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
+BEGIN_EVENT_TABLE(wxGridSubwindow, wxWindow)
+    EVT_MOUSE_CAPTURE_LOST(wxGridSubwindow::OnMouseCaptureLost)
+END_EVENT_TABLE()
+
+void wxGridSubwindow::OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
+{
+    m_owner->CancelMouseCapture();
+}
+
 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow, wxWindow )
 
-BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxWindow )
+BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxGridSubwindow )
     EVT_PAINT( wxGridRowLabelWindow::OnPaint )
     EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel )
     EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
@@ -3716,7 +3786,7 @@ END_EVENT_TABLE()
 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid *parent,
                                             wxWindowID id,
                                             const wxPoint &pos, const wxSize &size )
-  : wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxFULL_REPAINT_ON_RESIZE )
+  : wxGridSubwindow(parent, id, pos, size)
 {
     m_owner = parent;
 }
@@ -3733,7 +3803,8 @@ void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
 
     int x, y;
     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
-    dc.SetDeviceOrigin( 0, -y );
+    wxPoint pt = dc.GetDeviceOrigin();
+    dc.SetDeviceOrigin( pt.x, pt.y-y );
 
     wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
     m_owner->DrawRowLabels( dc, rows );
@@ -3774,7 +3845,7 @@ void wxGridRowLabelWindow::OnChar( wxKeyEvent& event )
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow, wxWindow )
 
-BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxWindow )
+BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxGridSubwindow )
     EVT_PAINT( wxGridColLabelWindow::OnPaint )
     EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel )
     EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
@@ -3786,7 +3857,7 @@ END_EVENT_TABLE()
 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid *parent,
                                             wxWindowID id,
                                             const wxPoint &pos, const wxSize &size )
-  : wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxFULL_REPAINT_ON_RESIZE )
+  : wxGridSubwindow(parent, id, pos, size)
 {
     m_owner = parent;
 }
@@ -3803,7 +3874,11 @@ void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
 
     int x, y;
     m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
-    dc.SetDeviceOrigin( -x, 0 );
+    wxPoint pt = dc.GetDeviceOrigin();
+    if (GetLayoutDirection() == wxLayout_RightToLeft)
+        dc.SetDeviceOrigin( pt.x+x, pt.y );
+    else
+        dc.SetDeviceOrigin( pt.x-x, pt.y );
 
     wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
     m_owner->DrawColLabels( dc, cols );
@@ -3844,7 +3919,7 @@ void wxGridColLabelWindow::OnChar( wxKeyEvent& event )
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow, wxWindow )
 
-BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxWindow )
+BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxGridSubwindow )
     EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel )
     EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
     EVT_PAINT( wxGridCornerLabelWindow::OnPaint )
@@ -3856,7 +3931,7 @@ END_EVENT_TABLE()
 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid *parent,
                                                   wxWindowID id,
                                                   const wxPoint &pos, const wxSize &size )
-  : wxWindow( parent, id, pos, size, wxWANTS_CHARS | wxBORDER_NONE | wxFULL_REPAINT_ON_RESIZE )
+  : wxGridSubwindow(parent, id, pos, size)
 {
     m_owner = parent;
 }
@@ -3870,7 +3945,8 @@ void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
     GetClientSize( &client_width, &client_height );
 
     // VZ: any reason for this ifdef? (FIXME)
-#ifdef __WXGTK__
+#if 0
+def __WXGTK__
     wxRect rect;
     rect.SetX( 1 );
     rect.SetY( 1 );
@@ -3926,7 +4002,7 @@ void wxGridCornerLabelWindow::OnChar( wxKeyEvent& event )
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow, wxWindow )
 
-BEGIN_EVENT_TABLE( wxGridWindow, wxWindow )
+BEGIN_EVENT_TABLE( wxGridWindow, wxGridSubwindow )
     EVT_PAINT( wxGridWindow::OnPaint )
     EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel )
     EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
@@ -3944,10 +4020,8 @@ wxGridWindow::wxGridWindow( wxGrid *parent,
                             wxWindowID id,
                             const wxPoint &pos,
                             const wxSize &size )
-            : wxWindow(
-                parent, id, pos, size,
-                wxWANTS_CHARS | wxBORDER_NONE | wxCLIP_CHILDREN | wxFULL_REPAINT_ON_RESIZE,
-                wxT("grid window") )
+            : wxGridSubwindow(parent, id, pos, size,
+                              wxCLIP_CHILDREN, wxT("grid window") )
 {
     m_owner = parent;
     m_rowLabelWin = rowLblWin;
@@ -4123,7 +4197,7 @@ wxGrid::wxGrid( wxWindow *parent,
     m_rowMinHeights(GRID_HASH_SIZE)
 {
     Create();
-    SetBestFittingSize(size);
+    SetInitialSize(size);
 }
 
 bool wxGrid::Create(wxWindow *parent, wxWindowID id,
@@ -4138,7 +4212,7 @@ bool wxGrid::Create(wxWindow *parent, wxWindowID id,
     m_rowMinHeights = wxLongToLongHashMap(GRID_HASH_SIZE);
 
     Create();
-    SetBestFittingSize(size);
+    SetInitialSize(size);
 
     return true;
 }
@@ -4158,8 +4232,12 @@ wxGrid::~wxGrid()
              total ? (gs_nAttrCacheHits*100) / total : 0);
 #endif
 
-    if (m_ownTable)
+    // if we own the table, just delete it, otherwise at least don't leave it
+    // with dangling view pointer
+    if ( m_ownTable )
         delete m_table;
+    else if ( m_table && m_table->GetView() == this )
+        m_table->SetView(NULL);
 
     delete m_typeRegistry;
     delete m_selection;
@@ -4309,24 +4387,33 @@ wxGrid::wxGridSelectionModes wxGrid::GetSelectionMode() const
 bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
                        wxGrid::wxGridSelectionModes selmode )
 {
+    bool checkSelection = false;
     if ( m_created )
     {
         // stop all processing
         m_created = false;
 
-        if (m_ownTable)
+        if (m_table)
         {
-            wxGridTableBase *t = m_table;
+            m_table->SetView(0);
+            if( m_ownTable )
+                delete m_table;
             m_table = NULL;
-            delete t;
         }
 
         delete m_selection;
-
-        m_table = NULL;
         m_selection = NULL;
+
+        m_ownTable = false;
         m_numRows = 0;
         m_numCols = 0;
+        checkSelection = true;
+
+        // kill row and column size arrays
+        m_colWidths.Empty();
+        m_colRights.Empty();
+        m_rowHeights.Empty();
+        m_rowBottoms.Empty();
     }
 
     if (table)
@@ -4338,7 +4425,28 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
         m_table->SetView( this );
         m_ownTable = takeOwnership;
         m_selection = new wxGridSelection( this, selmode );
-
+        if (checkSelection)
+        {
+            // If the newly set table is smaller than the
+            // original one current cell and selection regions
+            // might be invalid,
+            m_selectingKeyboard = wxGridNoCellCoords;
+            m_currentCellCoords =
+              wxGridCellCoords(wxMin(m_numRows, m_currentCellCoords.GetRow()),
+                               wxMin(m_numCols, m_currentCellCoords.GetCol()));
+            if (m_selectingTopLeft.GetRow() >= m_numRows ||
+                m_selectingTopLeft.GetCol() >= m_numCols)
+            {
+                m_selectingTopLeft = wxGridNoCellCoords;
+                m_selectingBottomRight = wxGridNoCellCoords;
+            }
+            else
+                m_selectingBottomRight =
+                  wxGridCellCoords(wxMin(m_numRows,
+                                         m_selectingBottomRight.GetRow()),
+                                   wxMin(m_numCols,
+                                         m_selectingBottomRight.GetCol()));
+        }
         CalcDimensions();
 
         m_created = true;
@@ -4441,8 +4549,9 @@ void wxGrid::Init()
 // default widths/heights are used for all rows/columns, we may not use these
 // arrays at all
 //
-// with some extra code, it should be possible to only store the
-// widths/heights different from default ones but this will be done later...
+// with some extra code, it should be possible to only store the widths/heights
+// different from default ones (resulting in space savings for huge grids) but
+// this is not done currently
 // ----------------------------------------------------------------------------
 
 void wxGrid::InitRowHeights()
@@ -4453,10 +4562,9 @@ void wxGrid::InitRowHeights()
     m_rowHeights.Alloc( m_numRows );
     m_rowBottoms.Alloc( m_numRows );
 
-    int rowBottom = 0;
-
     m_rowHeights.Add( m_defaultRowHeight, m_numRows );
 
+    int rowBottom = 0;
     for ( int i = 0; i < m_numRows; i++ )
     {
         rowBottom += m_defaultRowHeight;
@@ -4471,10 +4579,10 @@ void wxGrid::InitColWidths()
 
     m_colWidths.Alloc( m_numCols );
     m_colRights.Alloc( m_numCols );
-    int colRight = 0;
 
     m_colWidths.Add( m_defaultColWidth, m_numCols );
 
+    int colRight = 0;
     for ( int i = 0; i < m_numCols; i++ )
     {
         colRight = ( GetColPos( i ) + 1 ) * m_defaultColWidth;
@@ -4518,17 +4626,12 @@ int wxGrid::GetRowBottom(int row) const
 
 void wxGrid::CalcDimensions()
 {
-    int cw, ch;
-    GetClientSize( &cw, &ch );
+    // compute the size of the scrollable area
+    int w = m_numCols > 0 ? GetColRight(GetColAt(m_numCols - 1)) : 0;
+    int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
 
-    if ( m_rowLabelWin->IsShown() )
-        cw -= m_rowLabelWidth;
-    if ( m_colLabelWin->IsShown() )
-        ch -= m_colLabelHeight;
-
-    // grid total size
-    int w = m_numCols > 0 ? GetColRight(GetColAt( m_numCols - 1 )) + m_extraWidth + 1 : 0;
-    int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
+    w += m_extraWidth;
+    h += m_extraHeight;
 
     // take into account editor if shown
     if ( IsCellEditControlShown() )
@@ -4565,7 +4668,8 @@ void wxGrid::CalcDimensions()
 
     // do set scrollbar parameters
     SetScrollbars( m_scrollLineX, m_scrollLineY,
-                   GetScrollX(w), GetScrollY(h), x, y,
+                   GetScrollX(w), GetScrollY(h),
+                   x, y,
                    GetBatchCount() != 0);
 
     // if our OnSize() hadn't been called (it would if we have scrollbars), we
@@ -4583,6 +4687,33 @@ void wxGrid::CalcWindowSizes()
     int cw, ch;
     GetClientSize( &cw, &ch );
 
+    // this block of code tries to work around the following problem: the grid
+    // could have been just resized to have enough space to show the full grid
+    // window contents without the scrollbars, but its client size could be
+    // not big enough because the grid has the scrollbars right now and so the
+    // scrollbars would remain even though we don't need them any more
+    //
+    // to prevent this from happening, check if we have enough space for
+    // everything without the scrollbars and explicitly disable them then
+    wxSize size = GetSize() - GetWindowBorderSize();
+    if ( size != wxSize(cw, ch) )
+    {
+        // check if we have enough space for grid window after accounting for
+        // the fixed size elements
+        size.x -= m_rowLabelWidth;
+        size.y -= m_colLabelHeight;
+
+        const wxSize vsize = m_gridWin->GetVirtualSize();
+
+        if ( size.x >= vsize.x && size.y >= vsize.y )
+        {
+            // yes, we do, so remove the scrollbars and use the new client size
+            // (which should be the same as full window size - borders now)
+            SetScrollbars(0, 0, 0, 0);
+            GetClientSize(&cw, &ch);
+        }
+    }
+
     if ( m_cornerLabelWin && m_cornerLabelWin->IsShown() )
         m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
 
@@ -4974,7 +5105,7 @@ bool wxGrid::Redimension( wxGridTableMessage& msg )
     return result;
 }
 
-wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg ) const
 {
     wxRegionIterator iter( reg );
     wxRect r;
@@ -5025,7 +5156,7 @@ wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
     return rowlabels;
 }
 
-wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
+wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg ) const
 {
     wxRegionIterator iter( reg );
     wxRect r;
@@ -5079,7 +5210,7 @@ wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
     return colLabels;
 }
 
-wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
+wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg ) const
 {
     wxRegionIterator iter( reg );
     wxRect r;
@@ -5701,6 +5832,21 @@ void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
     }
 }
 
+void wxGrid::CancelMouseCapture()
+{
+    // cancel operation currently in progress, whatever it is
+    if ( m_winCapture )
+    {
+        m_isDragging = false;
+        m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
+        m_winCapture->SetCursor( *wxSTANDARD_CURSOR );
+        m_winCapture = NULL;
+
+        // remove traces of whatever we drew on screen
+        Refresh();
+    }
+}
+
 void wxGrid::ChangeCursorMode(CursorMode mode,
                               wxWindow *win,
                               bool captureMouse)
@@ -5820,13 +5966,6 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 SaveEditControlValue();
             }
 
-            // Have we captured the mouse yet?
-            if (! m_winCapture)
-            {
-                m_winCapture = m_gridWin;
-                m_winCapture->CaptureMouse();
-            }
-
             if ( coords != wxGridNoCellCoords )
             {
                 if ( event.CmdDown() )
@@ -5846,6 +5985,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                                    coords.GetRow(),
                                    coords.GetCol(),
                                    event );
+                        return;
                     }
                 }
                 else
@@ -5867,6 +6007,14 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                     // scrolling is way to fast, at least on MSW - also on GTK.
                 }
             }
+            // Have we captured the mouse yet?
+            if (! m_winCapture)
+            {
+                m_winCapture = m_gridWin;
+                m_winCapture->CaptureMouse();
+            }
+
+
         }
         else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
         {
@@ -6629,7 +6777,7 @@ int wxGrid::SendEvent( const wxEventType type,
            pos.y += GetColLabelSize();
        if ( mouseEv.GetEventObject() == GetGridColLabelWindow() )
            pos.x += GetRowLabelSize();
-       
+
        wxGridEvent gridEvt( GetId(),
                type,
                this,
@@ -6795,14 +6943,10 @@ void wxGrid::Refresh(bool eraseb, const wxRect* rect)
     }
 }
 
-void wxGrid::OnSize( wxSizeEvent& event )
+void wxGrid::OnSize(wxSizeEvent& WXUNUSED(event))
 {
-    // position the child windows
-    CalcWindowSizes();
-
-    // don't call CalcDimensions() from here, the base class handles the size
-    // changes itself
-    event.Skip();
+    // update our children window positions and scrollbars
+    CalcDimensions();
 }
 
 void wxGrid::OnKeyDown( wxKeyEvent& event )
@@ -6823,6 +6967,14 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
 
     if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
     {
+        if (GetLayoutDirection() == wxLayout_RightToLeft)
+        {
+            if (event.GetKeyCode() == WXK_RIGHT)
+                event.m_keyCode = WXK_LEFT;
+            else if (event.GetKeyCode() == WXK_LEFT)
+                event.m_keyCode = WXK_RIGHT;
+        }
+
         // try local handlers
         switch ( event.GetKeyCode() )
         {
@@ -7050,8 +7202,10 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
         return;
     }
 
+#if !(defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS)
     wxClientDC dc( m_gridWin );
     PrepareDC( dc );
+#endif
 
     if ( m_currentCellCoords != wxGridNoCellCoords )
     {
@@ -7074,15 +7228,21 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
             // Otherwise refresh redraws the highlight!
             m_currentCellCoords = coords;
 
+#if defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS
+            m_gridWin->Refresh(true /*, & r */);
+#else
             DrawGridCellArea( dc, cells );
             DrawAllGridLines( dc, r );
+#endif
         }
     }
 
     m_currentCellCoords = coords;
 
     wxGridCellAttr *attr = GetCellAttr( coords );
+#if !(defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS)
     DrawCellHighlight( dc, attr );
+#endif
     attr->DecRef();
 }
 
@@ -7458,7 +7618,7 @@ void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
         // edit control is erased by this code after being rendered.
         // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
         // implicitly, causing this out-of order render.
-#if !defined(__WXMAC__) || wxMAC_USE_CORE_GRAPHICS
+#if !defined(__WXMAC__)
         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
         editor->PaintBackground(rect, attr);
         editor->DecRef();
@@ -7533,6 +7693,21 @@ void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
 #endif
 }
 
+wxPen wxGrid::GetDefaultGridLinePen()
+{
+    return wxPen(GetGridLineColour(), 1, wxSOLID);
+}
+
+wxPen wxGrid::GetRowGridLinePen(int WXUNUSED(row))
+{
+    return GetDefaultGridLinePen();
+}
+
+wxPen wxGrid::GetColGridLinePen(int WXUNUSED(col))
+{
+    return GetDefaultGridLinePen();
+}
+
 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
 {
     int row = coords.GetRow();
@@ -7540,15 +7715,16 @@ void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
     if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
         return;
 
-    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
 
     wxRect rect = CellToRect( row, col );
 
     // right hand border
+    dc.SetPen( GetColGridLinePen(col) );
     dc.DrawLine( rect.x + rect.width, rect.y,
                  rect.x + rect.width, rect.y + rect.height + 1 );
 
     // bottom border
+    dc.SetPen( GetRowGridLinePen(row) );
     dc.DrawLine( rect.x, rect.y + rect.height,
                  rect.x + rect.width, rect.y + rect.height);
 }
@@ -7637,17 +7813,16 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
     int rightCol = GetColPos( internalXToCol(right) );
     int bottomRow = internalYToRow(bottom);
 
-#ifndef __WXMAC__
-    // CS: I don't know why suddenly unscrolled coordinates are used for clipping
+#if !defined(__WXMAC__) || wxMAC_USE_CORE_GRAPHICS
     wxRegion clippedcells(0, 0, cw, ch);
 
     int i, j, cell_rows, cell_cols;
     wxRect rect;
 
-    for (j=topRow; j<bottomRow; j++)
+    for (j=topRow; j<=bottomRow; j++)
     {
         int colPos;
-        for (colPos=leftCol; colPos<rightCol; colPos++)
+        for (colPos=leftCol; colPos<=rightCol; colPos++)
         {
             i = GetColAt( colPos );
 
@@ -7672,9 +7847,9 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
     int i, j, cell_rows, cell_cols;
     wxRect rect;
 
-    for (j=topRow; j<bottomRow; j++)
+    for (j=topRow; j<=bottomRow; j++)
     {
-        for (i=leftCol; i<rightCol; i++)
+        for (i=leftCol; i<=rightCol; i++)
         {
             GetCellSize( j, i, &cell_rows, &cell_cols );
             if ((cell_rows > 1) || (cell_cols > 1))
@@ -7693,7 +7868,6 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
 
     dc.SetClippingRegion( clippedcells );
 
-    dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
 
     // horizontal grid lines
     //
@@ -7709,6 +7883,7 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
 
         if ( bot >= top )
         {
+            dc.SetPen( GetRowGridLinePen(i) );
             dc.DrawLine( left, bot, right, bot );
         }
     }
@@ -7720,7 +7895,12 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
     {
         i = GetColAt( colPos );
 
-        int colRight = GetColRight(i) - 1;
+        int colRight = GetColRight(i);
+#ifdef __WXGTK__
+        if (GetLayoutDirection() != wxLayout_RightToLeft)
+#endif
+            colRight--;
+
         if ( colRight > right )
         {
             break;
@@ -7728,6 +7908,7 @@ void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
 
         if ( colRight >= left )
         {
+            dc.SetPen( GetColGridLinePen(i) );
             dc.DrawLine( colRight, top, colRight, bottom );
         }
     }
@@ -7756,7 +7937,8 @@ void wxGrid::DrawRowLabel( wxDC& dc, int row )
 
     wxRect rect;
 
-#ifdef __WXGTK20__
+#if 0
+def __WXGTK20__
     rect.SetX( 1 );
     rect.SetY( GetRowTop(row) + 1 );
     rect.SetWidth( m_rowLabelWidth - 2 );
@@ -7818,7 +8000,8 @@ void wxGrid::DrawColLabel( wxDC& dc, int col )
 
     wxRect rect;
 
-#ifdef __WXGTK20__
+#if 0
+def __WXGTK20__
     rect.SetX( colLeft + 1 );
     rect.SetY( 1 );
     rect.SetWidth( GetColWidth(col) - 2 );
@@ -7937,8 +8120,8 @@ void wxGrid::DrawTextRectangle(wxDC& dc,
             continue;
         }
 
-        long lineWidth,
-             lineHeight;
+        wxCoord lineWidth = 0,
+             lineHeight = 0;
         dc.GetTextExtent(line, &lineWidth, &lineHeight);
 
         switch ( horizAlign )
@@ -7982,7 +8165,7 @@ void wxGrid::DrawTextRectangle(wxDC& dc,
 // Split multi-line text up into an array of strings.
 // Any existing contents of the string array are preserved.
 //
-void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
+void wxGrid::StringToLines( const wxString& value, wxArrayString& lines ) const
 {
     int startPos = 0;
     int pos;
@@ -8016,11 +8199,11 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
 
 void wxGrid::GetTextBoxSize( const wxDC& dc,
                              const wxArrayString& lines,
-                             long *width, long *height )
+                             long *width, long *height ) const
 {
-    long w = 0;
-    long h = 0;
-    long lineW = 0, lineH = 0;
+    wxCoord w = 0;
+    wxCoord h = 0;
+    wxCoord lineW = 0, lineH = 0;
 
     size_t i;
     for ( i = 0; i < lines.GetCount(); i++ )
@@ -8203,7 +8386,8 @@ void wxGrid::ShowCellEditControl()
             // might not cover the entire cell
             wxClientDC dc( m_gridWin );
             PrepareDC( dc );
-            dc.SetBrush(wxBrush(GetCellAttr(row, col)->GetBackgroundColour(), wxSOLID));
+            wxGridCellAttr* attr = GetCellAttr(row, col);
+            dc.SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
             dc.SetPen(*wxTRANSPARENT_PEN);
             dc.DrawRectangle(rect);
 
@@ -8223,7 +8407,6 @@ void wxGrid::ShowCellEditControl()
             if (rect.y > 0)
                 rect.y--;
 
-            wxGridCellAttr* attr = GetCellAttr(row, col);
             wxGridCellEditor* editor = attr->GetEditor(this, row, col);
             if ( !editor->IsCreated() )
             {
@@ -8363,7 +8546,7 @@ void wxGrid::SaveEditControlValue()
 //  coordinates for mouse events etc.
 //
 
-void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
+void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords ) const
 {
     int row = YToRow(y);
     int col = XToCol(x);
@@ -8445,19 +8628,18 @@ static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
     return i_max;
 }
 
-int wxGrid::YToRow( int y )
+int wxGrid::YToRow( int y ) const
 {
     return CoordToRowOrCol(y, m_defaultRowHeight,
                            m_minAcceptableRowHeight, m_rowBottoms, m_numRows, false);
 }
 
-int wxGrid::XToCol( int x, bool clipToMinMax )
+int wxGrid::XToCol( int x, bool clipToMinMax ) const
 {
     if (x < 0)
         return clipToMinMax && (m_numCols > 0) ? GetColAt( 0 ) : -1;
 
-    if (!m_defaultColWidth)
-        m_defaultColWidth = 1;
+    wxASSERT_MSG(m_defaultColWidth > 0, wxT("Default column width can not be zero"));
 
     int maxPos = x / m_defaultColWidth;
     int minPos = 0;
@@ -8512,15 +8694,23 @@ int wxGrid::XToCol( int x, bool clipToMinMax )
     return GetColAt( maxPos );
 }
 
-// return the row number that that the y coord is near the edge of, or
-// -1 if not near an edge
+// return the row number that that the y coord is near
+//  the edge of, or -1 if not near an edge.
+// coords can only possibly be near an edge if
+//    (a) the row/column is large enough to still allow for an "inner" area
+//        that is _not_ nead the edge (i.e., if the height/width is smaller
+//        than WXGRID_LABEL_EDGE_ZONE, coords are _never_ considered to be
+//        near the edge).
+//   and
+//    (b) resizing rows/columns (the thing for which edge detection is
+//        relevant at all) is enabled.
 //
-int wxGrid::YToEdgeOfRow( int y )
+int wxGrid::YToEdgeOfRow( int y ) const
 {
     int i;
     i = internalYToRow(y);
 
-    if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
+    if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE && CanDragRowSize() )
     {
         // We know that we are in row i, test whether we are
         // close enough to lower or upper border, respectively.
@@ -8535,13 +8725,14 @@ int wxGrid::YToEdgeOfRow( int y )
 
 // return the col number that that the x coord is near the edge of, or
 // -1 if not near an edge
+// See comment at YToEdgeOfRow for conditions on edge detection.
 //
-int wxGrid::XToEdgeOfCol( int x )
+int wxGrid::XToEdgeOfCol( int x ) const
 {
     int i;
     i = internalXToCol(x);
 
-    if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
+    if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE && CanDragColSize() )
     {
         // We know that we are in column i; test whether we are
         // close enough to right or left border, respectively.
@@ -8554,7 +8745,7 @@ int wxGrid::XToEdgeOfCol( int x )
     return -1;
 }
 
-wxRect wxGrid::CellToRect( int row, int col )
+wxRect wxGrid::CellToRect( int row, int col ) const
 {
     wxRect rect( -1, -1, -1, -1 );
 
@@ -8589,7 +8780,7 @@ wxRect wxGrid::CellToRect( int row, int col )
     return rect;
 }
 
-bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
+bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible ) const
 {
     // get the cell rectangle in logical coords
     //
@@ -9167,7 +9358,7 @@ bool wxGrid::MoveCursorRightBlock( bool expandSelection )
 // ------ Label values and formatting
 //
 
-void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
+void wxGrid::GetRowLabelAlignment( int *horiz, int *vert ) const
 {
     if ( horiz )
         *horiz = m_rowLabelHorizAlign;
@@ -9175,7 +9366,7 @@ void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
         *vert  = m_rowLabelVertAlign;
 }
 
-void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
+void wxGrid::GetColLabelAlignment( int *horiz, int *vert ) const
 {
     if ( horiz )
         *horiz = m_colLabelHorizAlign;
@@ -9183,12 +9374,12 @@ void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
         *vert  = m_colLabelVertAlign;
 }
 
-int wxGrid::GetColLabelTextOrientation()
+int wxGrid::GetColLabelTextOrientation() const
 {
     return m_colLabelTextOrientation;
 }
 
-wxString wxGrid::GetRowLabelValue( int row )
+wxString wxGrid::GetRowLabelValue( int row ) const
 {
     if ( m_table )
     {
@@ -9202,7 +9393,7 @@ wxString wxGrid::GetRowLabelValue( int row )
     }
 }
 
-wxString wxGrid::GetColLabelValue( int col )
+wxString wxGrid::GetColLabelValue( int col ) const
 {
     if ( m_table )
     {
@@ -9218,7 +9409,13 @@ wxString wxGrid::GetColLabelValue( int col )
 
 void wxGrid::SetRowLabelSize( int width )
 {
-    width = wxMax( width, 0 );
+    wxASSERT( width >= 0 || width == wxGRID_AUTOSIZE );
+
+    if ( width == wxGRID_AUTOSIZE )
+    {
+        width = CalcColOrRowLabelAreaMinSize(wxGRID_ROW);
+    }
+
     if ( width != m_rowLabelWidth )
     {
         if ( width == 0 )
@@ -9241,7 +9438,13 @@ void wxGrid::SetRowLabelSize( int width )
 
 void wxGrid::SetColLabelSize( int height )
 {
-    height = wxMax( height, 0 );
+    wxASSERT( height >=0 || height == wxGRID_AUTOSIZE );
+
+    if ( height == wxGRID_AUTOSIZE )
+    {
+        height = CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN);
+    }
+
     if ( height != m_colLabelHeight )
     {
         if ( height == 0 )
@@ -9459,7 +9662,7 @@ void wxGrid::SetCellHighlightPenWidth(int width)
         // make any visible change if the the thickness is getting smaller.
         int row = m_currentCellCoords.GetRow();
         int col = m_currentCellCoords.GetCol();
-        if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
+        if ( row == -1 || col == -1 || GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
             return;
 
         wxRect rect = CellToRect(row, col);
@@ -9507,24 +9710,24 @@ void wxGrid::EnableGridLines( bool enable )
     }
 }
 
-int wxGrid::GetDefaultRowSize()
+int wxGrid::GetDefaultRowSize() const
 {
     return m_defaultRowHeight;
 }
 
-int wxGrid::GetRowSize( int row )
+int wxGrid::GetRowSize( int row ) const
 {
     wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
 
     return GetRowHeight(row);
 }
 
-int wxGrid::GetDefaultColSize()
+int wxGrid::GetDefaultColSize() const
 {
     return m_defaultColWidth;
 }
 
-int wxGrid::GetColSize( int col )
+int wxGrid::GetColSize( int col ) const
 {
     wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
 
@@ -9588,30 +9791,30 @@ void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
 }
 
 // ----------------------------------------------------------------------------
-// access to the default attrbiutes
+// access to the default attributes
 // ----------------------------------------------------------------------------
 
-wxColour wxGrid::GetDefaultCellBackgroundColour()
+wxColour wxGrid::GetDefaultCellBackgroundColour() const
 {
     return m_defaultCellAttr->GetBackgroundColour();
 }
 
-wxColour wxGrid::GetDefaultCellTextColour()
+wxColour wxGrid::GetDefaultCellTextColour() const
 {
     return m_defaultCellAttr->GetTextColour();
 }
 
-wxFont wxGrid::GetDefaultCellFont()
+wxFont wxGrid::GetDefaultCellFont() const
 {
     return m_defaultCellAttr->GetFont();
 }
 
-void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
+void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert ) const
 {
     m_defaultCellAttr->GetAlignment(horiz, vert);
 }
 
-bool wxGrid::GetDefaultCellOverflow()
+bool wxGrid::GetDefaultCellOverflow() const
 {
     return m_defaultCellAttr->GetOverflow();
 }
@@ -9630,7 +9833,7 @@ wxGridCellEditor *wxGrid::GetDefaultEditor() const
 // access to cell attributes
 // ----------------------------------------------------------------------------
 
-wxColour wxGrid::GetCellBackgroundColour(int row, int col)
+wxColour wxGrid::GetCellBackgroundColour(int row, int col) const
 {
     wxGridCellAttr *attr = GetCellAttr(row, col);
     wxColour colour = attr->GetBackgroundColour();
@@ -9639,7 +9842,7 @@ wxColour wxGrid::GetCellBackgroundColour(int row, int col)
     return colour;
 }
 
-wxColour wxGrid::GetCellTextColour( int row, int col )
+wxColour wxGrid::GetCellTextColour( int row, int col ) const
 {
     wxGridCellAttr *attr = GetCellAttr(row, col);
     wxColour colour = attr->GetTextColour();
@@ -9648,7 +9851,7 @@ wxColour wxGrid::GetCellTextColour( int row, int col )
     return colour;
 }
 
-wxFont wxGrid::GetCellFont( int row, int col )
+wxFont wxGrid::GetCellFont( int row, int col ) const
 {
     wxGridCellAttr *attr = GetCellAttr(row, col);
     wxFont font = attr->GetFont();
@@ -9657,14 +9860,14 @@ wxFont wxGrid::GetCellFont( int row, int col )
     return font;
 }
 
-void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
+void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert ) const
 {
     wxGridCellAttr *attr = GetCellAttr(row, col);
     attr->GetAlignment(horiz, vert);
     attr->DecRef();
 }
 
-bool wxGrid::GetCellOverflow( int row, int col )
+bool wxGrid::GetCellOverflow( int row, int col ) const
 {
     wxGridCellAttr *attr = GetCellAttr(row, col);
     bool allow = attr->GetOverflow();
@@ -9673,14 +9876,14 @@ bool wxGrid::GetCellOverflow( int row, int col )
     return allow;
 }
 
-void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols )
+void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
 {
     wxGridCellAttr *attr = GetCellAttr(row, col);
     attr->GetSize( num_rows, num_cols );
     attr->DecRef();
 }
 
-wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
+wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const
 {
     wxGridCellAttr* attr = GetCellAttr(row, col);
     wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
@@ -9689,7 +9892,7 @@ wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
     return renderer;
 }
 
-wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
+wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const
 {
     wxGridCellAttr* attr = GetCellAttr(row, col);
     wxGridCellEditor* editor = attr->GetEditor(this, row, col);
@@ -9711,7 +9914,7 @@ bool wxGrid::IsReadOnly(int row, int col) const
 // attribute support: cache, automatic provider creation, ...
 // ----------------------------------------------------------------------------
 
-bool wxGrid::CanHaveAttributes()
+bool wxGrid::CanHaveAttributes() const
 {
     if ( !m_table )
     {
@@ -10151,8 +10354,7 @@ void wxGrid::SetRowSize( int row, int height )
     int diff = h - m_rowHeights[row];
 
     m_rowHeights[row] = h;
-    int i;
-    for ( i = row; i < m_numRows; i++ )
+    for ( int i = row; i < m_numRows; i++ )
     {
         m_rowBottoms[i] += diff;
     }
@@ -10163,7 +10365,8 @@ void wxGrid::SetRowSize( int row, int height )
 
 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 {
-    m_defaultColWidth = wxMax( width, m_minAcceptableColWidth );
+    // we dont allow zero default column width
+    m_defaultColWidth = wxMax( wxMax( width, m_minAcceptableColWidth ), 1 );
 
     if ( resizeExistingCols )
     {
@@ -10215,12 +10418,9 @@ void wxGrid::SetColSize( int col, int width )
     int diff = w - m_colWidths[col];
     m_colWidths[col] = w;
 
-    int i;
-    int colPos;
-    for ( colPos = GetColPos( col ); colPos < m_numCols; colPos++ )
+    for ( int colPos = GetColPos(col); colPos < m_numCols; colPos++ )
     {
-        i = GetColAt( colPos );
-        m_colRights[i] += diff;
+        m_colRights[GetColAt(colPos)] += diff;
     }
 
     if ( !GetBatchCount() )
@@ -10291,8 +10491,11 @@ int  wxGrid::GetRowMinimalAcceptableHeight() const
 // auto sizing
 // ----------------------------------------------------------------------------
 
-void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
+void
+wxGrid::AutoSizeColOrRow(int colOrRow, bool setAsMin, wxGridDirection direction)
 {
+    const bool column = direction == wxGRID_COLUMN;
+
     wxClientDC dc(m_gridWin);
 
     // cancel editing of cell
@@ -10337,12 +10540,12 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
 
     if ( column )
     {
-        dc.GetTextExtent( GetColLabelValue(col), &w, &h );
+        dc.GetMultiLineTextExtent( GetColLabelValue(col), &w, &h );
         if ( GetColLabelTextOrientation() == wxVERTICAL )
             w = h;
     }
     else
-        dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
+        dc.GetMultiLineTextExtent( GetRowLabelValue(row), &w, &h );
 
     extent = column ? w : h;
     if ( extent > extentMax )
@@ -10403,12 +10606,66 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
     }
 }
 
+wxCoord wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction)
+{
+    // calculate size for the rows or columns?
+    const bool calcRows = direction == wxGRID_ROW;
+
+    wxClientDC dc(calcRows ? GetGridRowLabelWindow()
+                           : GetGridColLabelWindow());
+    dc.SetFont(GetLabelFont());
+
+    // which dimension should we take into account for calculations?
+    //
+    // for columns, the text can be only horizontal so it's easy but for rows
+    // we also have to take into account the text orientation
+    const bool
+        useWidth = calcRows || (GetColLabelTextOrientation() == wxVERTICAL);
+
+    wxArrayString lines;
+    wxCoord extentMax = 0;
+
+    const int numRowsOrCols = calcRows ? m_numRows : m_numCols;
+    for ( int rowOrCol = 0; rowOrCol < numRowsOrCols; rowOrCol++ )
+    {
+        lines.Clear();
+
+        wxString label = calcRows ? GetRowLabelValue(rowOrCol)
+                                  : GetColLabelValue(rowOrCol);
+        StringToLines(label, lines);
+
+        long w, h;
+        GetTextBoxSize(dc, lines, &w, &h);
+
+        const wxCoord extent = useWidth ? w : h;
+        if ( extent > extentMax )
+            extentMax = extent;
+    }
+
+    if ( !extentMax )
+    {
+        // empty column - give default extent (notice that if extentMax is less
+        // than default extent but != 0, it's OK)
+        extentMax = calcRows ? GetDefaultRowLabelSize()
+                             : GetDefaultColLabelSize();
+    }
+
+    // leave some space around text (taken from AutoSizeColOrRow)
+    if ( calcRows )
+        extentMax += 10;
+    else
+        extentMax += 6;
+
+    return extentMax;
+}
+
 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
 {
     int width = m_rowLabelWidth;
 
-    if ( !calcOnly )
-        BeginBatch();
+    wxGridUpdateLocker locker;
+    if(!calcOnly)
+        locker.Create(this);
 
     for ( int col = 0; col < m_numCols; col++ )
     {
@@ -10418,9 +10675,6 @@ int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
         width += GetColWidth(col);
     }
 
-    if ( !calcOnly )
-        EndBatch();
-
     return width;
 }
 
@@ -10428,8 +10682,9 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
 {
     int height = m_colLabelHeight;
 
-    if ( !calcOnly )
-        BeginBatch();
+    wxGridUpdateLocker locker;
+    if(!calcOnly)
+        locker.Create(this);
 
     for ( int row = 0; row < m_numRows; row++ )
     {
@@ -10439,31 +10694,24 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
         height += GetRowHeight(row);
     }
 
-    if ( !calcOnly )
-        EndBatch();
-
     return height;
 }
 
 void wxGrid::AutoSize()
 {
-    BeginBatch();
-
-    wxSize size(SetOrCalcColumnSizes(false), SetOrCalcRowSizes(false));
+    wxGridUpdateLocker locker(this);
 
-    // round up the size to a multiple of scroll step - this ensures that we
-    // won't get the scrollbars if we're sized exactly to this width
-    // CalcDimension adds m_extraWidth + 1 etc. to calculate the necessary
-    // scrollbar steps
-    wxSize sizeFit(
-        GetScrollX(size.x + m_extraWidth + 1) * m_scrollLineX,
-        GetScrollY(size.y + m_extraHeight + 1) * m_scrollLineY );
+    // we need to round up the size of the scrollable area to a multiple of
+    // scroll step to ensure that we don't get the scrollbars when we're sized
+    // exactly to fit our contents
+    wxSize size(SetOrCalcColumnSizes(false) - m_rowLabelWidth + m_extraWidth,
+                SetOrCalcRowSizes(false) - m_colLabelHeight + m_extraHeight);
+    wxSize sizeFit(GetScrollX(size.x) * GetScrollLineX(),
+                   GetScrollY(size.y) * GetScrollLineY());
 
     // distribute the extra space between the columns/rows to avoid having
     // extra white space
-
-    // Remove the extra m_extraWidth + 1 added above
-    wxCoord diff = sizeFit.x - size.x + (m_extraWidth + 1);
+    wxCoord diff = sizeFit.x - size.x;
     if ( diff && m_numCols )
     {
         // try to resize the columns uniformly
@@ -10488,7 +10736,7 @@ void wxGrid::AutoSize()
     }
 
     // same for rows
-    diff = sizeFit.y - size.y - (m_extraHeight + 1);
+    diff = sizeFit.y - size.y;
     if ( diff && m_numRows )
     {
         // try to resize the columns uniformly
@@ -10512,9 +10760,11 @@ void wxGrid::AutoSize()
         }
     }
 
-    EndBatch();
-
-    SetClientSize(sizeFit);
+    // we know that we're not going to have scrollbars so disable them now to
+    // avoid trouble in SetClientSize() which can otherwise set the correct
+    // client size but also leave space for (not needed any more) scrollbars
+    SetScrollbars(0, 0, 0, 0, 0, 0, true);
+    SetClientSize(sizeFit.x + m_rowLabelWidth, sizeFit.y + m_colLabelHeight);
 }
 
 void wxGrid::AutoSizeRowLabelSize( int row )
@@ -10568,46 +10818,22 @@ void wxGrid::AutoSizeColLabelSize( int col )
 
 wxSize wxGrid::DoGetBestSize() const
 {
-    // don't set sizes, only calculate them
     wxGrid *self = (wxGrid *)this;  // const_cast
 
-    int width, height;
-    width = self->SetOrCalcColumnSizes(true);
-    height = self->SetOrCalcRowSizes(true);
-
-    if (!width)
-        width = 100;
-    if (!height)
-        height = 80;
-
-    // Round up to a multiple the scroll rate
-    // NOTE: this still doesn't get rid of the scrollbars;
-    // is there any magic incantation for that?
-    int xpu, ypu;
-    GetScrollPixelsPerUnit(&xpu, &ypu);
-    if (xpu)
-        width  += 1 + xpu - (width  % xpu);
-    if (ypu)
-        height += 1 + ypu - (height % ypu);
-
-    // limit to 1/4 of the screen size
-    int maxwidth, maxheight;
-    wxDisplaySize( &maxwidth, &maxheight );
-    maxwidth /= 2;
-    maxheight /= 2;
-    if ( width > maxwidth )
-        width = maxwidth;
-    if ( height > maxheight )
-        height = maxheight;
-
-    wxSize best(width, height);
+    // we do the same as in AutoSize() here with the exception that we don't
+    // change the column/row sizes, only calculate them
+    wxSize size(self->SetOrCalcColumnSizes(true) - m_rowLabelWidth + m_extraWidth,
+                self->SetOrCalcRowSizes(true) - m_colLabelHeight + m_extraHeight);
+    wxSize sizeFit(GetScrollX(size.x) * GetScrollLineX(),
+                   GetScrollY(size.y) * GetScrollLineY());
 
     // NOTE: This size should be cached, but first we need to add calls to
     // InvalidateBestSize everywhere that could change the results of this
     // calculation.
     // CacheBestSize(size);
 
-    return best;
+    return wxSize(sizeFit.x + m_rowLabelWidth, sizeFit.y + m_colLabelHeight)
+            + GetWindowBorderSize();
 }
 
 void wxGrid::Fit()
@@ -10746,7 +10972,7 @@ void wxGrid::DeselectCell( int row, int col )
         m_selection->ToggleCellSelection(row, col);
 }
 
-bool wxGrid::IsSelection()
+bool wxGrid::IsSelection() const
 {
     return ( m_selection && (m_selection->IsSelection() ||
              ( m_selectingTopLeft != wxGridNoCellCoords &&
@@ -10830,7 +11056,7 @@ void wxGrid::ClearSelection()
 // in device coords clipped to the client size of the grid window.
 //
 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
-                                  const wxGridCellCoords &bottomRight )
+                                  const wxGridCellCoords &bottomRight ) const
 {
     wxRect rect( wxGridNoCellRect );
     wxRect cellRect;