wxSplitterWindow mouse capture improvements and cleanup.

[wxWidgets.git] / src / generic / grid.cpp

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index 418b9c901a74a5e900b18a2fab754c8262238d8e..2ce9f06c7040de5dd2c04d857240d81632d8b84a 100644 (file)
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -48,6 +48,7 @@
 #include "wx/tokenzr.h"
 #include "wx/renderer.h"
 #include "wx/headerctrl.h"
 #include "wx/tokenzr.h"
 #include "wx/renderer.h"
 #include "wx/headerctrl.h"

+#include "wx/hashset.h"

 
 #include "wx/generic/gridsel.h"
 #include "wx/generic/gridctrl.h"
 
 #include "wx/generic/gridsel.h"
 #include "wx/generic/gridctrl.h"


@@ -71,6 +72,9 @@ const char wxGridNameStr[] = "grid";
 // Required for wxIs... functions
 #include <ctype.h>
 
 // Required for wxIs... functions
 #include <ctype.h>
 

+WX_DECLARE_HASH_SET_WITH_DECL(int, wxIntegerHash, wxIntegerEqual,
+                              wxGridFixedIndicesSet, class WXDLLIMPEXP_ADV);
+

 
 // ----------------------------------------------------------------------------
 // globals
 
 // ----------------------------------------------------------------------------
 // globals


@@ -115,26 +119,26 @@ WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
 // events
 // ----------------------------------------------------------------------------
 
 // events
 // ----------------------------------------------------------------------------
 

-wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_CLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_CLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_DCLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_DCLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_CELL_BEGIN_DRAG, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_CLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_CLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_DCLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_DCLICK, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_ROW_SIZE, wxGridSizeEvent )
-wxDEFINE_EVENT( wxEVT_GRID_COL_SIZE, wxGridSizeEvent )
-wxDEFINE_EVENT( wxEVT_GRID_COL_MOVE, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_COL_SORT, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_RANGE_SELECT, wxGridRangeSelectEvent )
-wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGING, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGED, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_SELECT_CELL, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_EDITOR_SHOWN, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_EDITOR_HIDDEN, wxGridEvent )
-wxDEFINE_EVENT( wxEVT_GRID_EDITOR_CREATED, wxGridEditorCreatedEvent )
+wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_CLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_CLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_DCLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_DCLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_CELL_BEGIN_DRAG, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_CLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_CLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_DCLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_DCLICK, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_ROW_SIZE, wxGridSizeEvent );
+wxDEFINE_EVENT( wxEVT_GRID_COL_SIZE, wxGridSizeEvent );
+wxDEFINE_EVENT( wxEVT_GRID_COL_MOVE, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_COL_SORT, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_RANGE_SELECT, wxGridRangeSelectEvent );
+wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGING, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGED, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_SELECT_CELL, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_EDITOR_SHOWN, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_EDITOR_HIDDEN, wxGridEvent );
+wxDEFINE_EVENT( wxEVT_GRID_EDITOR_CREATED, wxGridEditorCreatedEvent );

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -193,8 +197,6 @@ wxGridCellWorker::~wxGridCellWorker()
 
 void wxGridCellAttr::Init(wxGridCellAttr *attrDefault)
 {
 
 void wxGridCellAttr::Init(wxGridCellAttr *attrDefault)
 {

-    m_nRef = 1;
-

     m_isReadOnly = Unset;
 
     m_renderer = NULL;
     m_isReadOnly = Unset;
 
     m_renderer = NULL;


@@ -641,30 +643,30 @@ void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
     {
         if ( attr )
         {
     {
         if ( attr )
         {

-            // add the attribute - no need to do anything to reference count
-            //                     since we take ownership of the attribute.
+            // store the new attribute, taking its ownership

             m_rowsOrCols.Add(rowOrCol);
             m_attrs.Add(attr);
         }
         // nothing to remove
     }
             m_rowsOrCols.Add(rowOrCol);
             m_attrs.Add(attr);
         }
         // nothing to remove
     }

-    else
+    else // we have an attribute for this row or column

     {
         size_t n = (size_t)i;
     {
         size_t n = (size_t)i;

-        if ( m_attrs[n] == attr )
-            // nothing to do
-            return;
+
+        // notice that this code works correctly even when the old attribute is
+        // the same as the new one: as we own of it, we must call DecRef() on
+        // it in any case and this won't result in destruction of the new
+        // attribute if it's the same as old one because it must have ref count
+        // of at least 2 to be passed to us while we keep a reference to it too
+        m_attrs[n]->DecRef();
+

         if ( attr )
         {
         if ( attr )
         {

-            // change the attribute, handling reference count manually,
-            //                       taking ownership of the new attribute.
-            m_attrs[n]->DecRef();
+            // replace the attribute with the new one

             m_attrs[n] = attr;
         }
             m_attrs[n] = attr;
         }

-        else
+        else // remove the attribute

         {
         {

-            // remove this attribute, handling reference count manually
-            m_attrs[n]->DecRef();

             m_rowsOrCols.RemoveAt(n);
             m_attrs.RemoveAt(n);
         }
             m_rowsOrCols.RemoveAt(n);
             m_attrs.RemoveAt(n);
         }


@@ -1013,7 +1015,7 @@ wxString wxGridTableBase::GetColLabelValue( int col )
     unsigned int i, n;
     for ( n = 1; ; n++ )
     {
     unsigned int i, n;
     for ( n = 1; ; n++ )
     {

-        s += (wxChar) (_T('A') + (wxChar)(col % 26));
+        s += (wxChar) (wxT('A') + (wxChar)(col % 26));

         col = col / 26 - 1;
         if ( col < 0 )
             break;
         col = col / 26 - 1;
         if ( col < 0 )
             break;


@@ -1123,11 +1125,14 @@ IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
 wxGridStringTable::wxGridStringTable()
         : wxGridTableBase()
 {
 wxGridStringTable::wxGridStringTable()
         : wxGridTableBase()
 {

+    m_numCols = 0;

 }
 
 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
         : wxGridTableBase()
 {
 }
 
 wxGridStringTable::wxGridStringTable( int numRows, int numCols )
         : wxGridTableBase()
 {

+    m_numCols = numCols;
+

     m_data.Alloc( numRows );
 
     wxArrayString sa;
     m_data.Alloc( numRows );
 
     wxArrayString sa;


@@ -1137,36 +1142,21 @@ wxGridStringTable::wxGridStringTable( int numRows, int numCols )
     m_data.Add( sa, numRows );
 }
 
     m_data.Add( sa, numRows );
 }
 

-wxGridStringTable::~wxGridStringTable()
-{
-}
-
-int wxGridStringTable::GetNumberRows()
-{
-    return m_data.GetCount();
-}
-
-int wxGridStringTable::GetNumberCols()
-{
-    if ( m_data.GetCount() > 0 )
-        return m_data[0].GetCount();
-    else
-        return 0;
-}
-

 wxString wxGridStringTable::GetValue( int row, int col )
 {
 wxString wxGridStringTable::GetValue( int row, int col )
 {

-    wxCHECK_MSG( (row < GetNumberRows()) && (col < GetNumberCols()),
+    wxCHECK_MSG( (row >= 0 && row < GetNumberRows()) &&
+                 (col >= 0 && col < GetNumberCols()),

                  wxEmptyString,
                  wxEmptyString,

-                 _T("invalid row or column index in wxGridStringTable") );
+                 wxT("invalid row or column index in wxGridStringTable") );

 
     return m_data[row][col];
 }
 
 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
 {
 
     return m_data[row][col];
 }
 
 void wxGridStringTable::SetValue( int row, int col, const wxString& value )
 {

-    wxCHECK_RET( (row < GetNumberRows()) && (col < GetNumberCols()),
-                 _T("invalid row or column index in wxGridStringTable") );
+    wxCHECK_RET( (row >= 0 && row < GetNumberRows()) &&
+                 (col >= 0 && col < GetNumberCols()),
+                 wxT("invalid row or column index in wxGridStringTable") );

 
     m_data[row][col] = value;
 }
 
     m_data[row][col] = value;
 }


@@ -1323,6 +1313,8 @@ bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
         }
     }
 
         }
     }
 

+    m_numCols += numCols;
+

     if ( GetView() )
     {
         wxGridTableMessage msg( this,
     if ( GetView() )
     {
         wxGridTableMessage msg( this,


@@ -1347,6 +1339,8 @@ bool wxGridStringTable::AppendCols( size_t numCols )
         m_data[row].Add( wxEmptyString, numCols );
     }
 
         m_data[row].Add( wxEmptyString, numCols );
     }
 

+    m_numCols += numCols;
+

     if ( GetView() )
     {
         wxGridTableMessage msg( this,
     if ( GetView() )
     {
         wxGridTableMessage msg( this,


@@ -1400,16 +1394,23 @@ bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
             m_colLabels.RemoveAt( colID, nToRm );
     }
 
             m_colLabels.RemoveAt( colID, nToRm );
     }
 

-    for ( row = 0; row < curNumRows; row++ )
+    if ( numCols >= curNumCols )

     {
     {

-        if ( numCols >= curNumCols )
+        for ( row = 0; row < curNumRows; row++ )

         {
             m_data[row].Clear();
         }
         {
             m_data[row].Clear();
         }

-        else
+
+        m_numCols = 0;
+    }
+    else // something will be left
+    {
+        for ( row = 0; row < curNumRows; row++ )

         {
             m_data[row].RemoveAt( colID, numCols );
         }
         {
             m_data[row].RemoveAt( colID, numCols );
         }

+
+        m_numCols -= numCols;

     }
 
     if ( GetView() )
     }
 
     if ( GetView() )


@@ -1807,7 +1808,7 @@ wxGrid::~wxGrid()
 
 #ifdef DEBUG_ATTR_CACHE
     size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
 
 #ifdef DEBUG_ATTR_CACHE
     size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;

-    wxPrintf(_T("wxGrid attribute cache statistics: "
+    wxPrintf(wxT("wxGrid attribute cache statistics: "

                 "total: %u, hits: %u (%u%%)\n"),
              total, gs_nAttrCacheHits,
              total ? (gs_nAttrCacheHits*100) / total : 0);
                 "total: %u, hits: %u (%u%%)\n"),
              total, gs_nAttrCacheHits,
              total ? (gs_nAttrCacheHits*100) / total : 0);


@@ -1822,6 +1823,9 @@ wxGrid::~wxGrid()
 
     delete m_typeRegistry;
     delete m_selection;
 
     delete m_typeRegistry;
     delete m_selection;

+
+    delete m_setFixedRows;
+    delete m_setFixedCols;

 }
 
 //
 }
 
 //


@@ -2047,6 +2051,9 @@ void wxGrid::Init()
     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
 
     m_rowLabelWidth  = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
     m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
 

+    m_setFixedRows =
+    m_setFixedCols = NULL;
+

     // init attr cache
     m_attrCache.row = -1;
     m_attrCache.col = -1;
     // init attr cache
     m_attrCache.row = -1;
     m_attrCache.col = -1;


@@ -2916,11 +2923,12 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     //
     else if ( event.LeftDown() )
     {
     //
     else if ( event.LeftDown() )
     {

-        // don't send a label click event for a hit on the
-        // edge of the row label - this is probably the user
-        // wanting to resize the row
-        //
-        if ( YToEdgeOfRow(y) < 0 )
+        row = YToEdgeOfRow(y);
+        if ( row != wxNOT_FOUND && CanDragRowSize(row) )
+        {
+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
+        }
+        else // not a request to start resizing

         {
             row = YToRow(y);
             if ( row >= 0 &&
         {
             row = YToRow(y);
             if ( row >= 0 &&


@@ -2948,12 +2956,6 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
             }
         }
                 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
             }
         }

-        else
-        {
-            // starting to drag-resize a row
-            if ( CanDragRowSize() )
-                ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
-        }

     }
 
     // ------------ Left double click
     }
 
     // ------------ Left double click


@@ -2961,7 +2963,19 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     else if (event.LeftDClick() )
     {
         row = YToEdgeOfRow(y);
     else if (event.LeftDClick() )
     {
         row = YToEdgeOfRow(y);

-        if ( row < 0 )
+        if ( row != wxNOT_FOUND && CanDragRowSize(row) )
+        {
+            // adjust row height depending on label text
+            //
+            // TODO: generate RESIZING event, see #10754
+            AutoSizeRowLabelSize( row );
+
+            SendGridSizeEvent(wxEVT_GRID_ROW_SIZE, row, -1, event);
+
+            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
+            m_dragLastPos = -1;
+        }
+        else // not on row separator or it's not resizeable

         {
             row = YToRow(y);
             if ( row >=0 &&
         {
             row = YToRow(y);
             if ( row >=0 &&


@@ -2970,14 +2984,6 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
                 // no default action at the moment
             }
         }
                 // no default action at the moment
             }
         }

-        else
-        {
-            // adjust row height depending on label text
-            AutoSizeRowLabelSize( row );
-
-            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
-            m_dragLastPos = -1;
-        }

     }
 
     // ------------ Left button released
     }
 
     // ------------ Left button released


@@ -2985,14 +2991,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     else if ( event.LeftUp() )
     {
         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
     else if ( event.LeftUp() )
     {
         if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )

-        {
-            DoEndDragResizeRow();
-
-            // Note: we are ending the event *after* doing
-            // default processing in this case
-            //
-            SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
-        }
+            DoEndDragResizeRow(event);

 
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
         m_dragLastPos = -1;
 
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
         m_dragLastPos = -1;


@@ -3027,12 +3026,11 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
     else if ( event.Moving() )
     {
         m_dragRowOrCol = YToEdgeOfRow( y );
     else if ( event.Moving() )
     {
         m_dragRowOrCol = YToEdgeOfRow( y );

-        if ( m_dragRowOrCol >= 0 )
+        if ( m_dragRowOrCol != wxNOT_FOUND )

         {
             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
             {
         {
             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
             {

-                // don't capture the mouse yet
-                if ( CanDragRowSize() )
+                if ( CanDragRowSize(m_dragRowOrCol) )

                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, false);
             }
         }
                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, false);
             }
         }


@@ -3248,12 +3246,14 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
     //
     else if ( event.LeftDown() )
     {
     //
     else if ( event.LeftDown() )
     {

-        // don't send a label click event for a hit on the
-        // edge of the col label - this is probably the user
-        // wanting to resize the col
-        //
-        if ( XToEdgeOfCol(x) < 0 )
+        int col = XToEdgeOfCol(x);
+        if ( col != wxNOT_FOUND && CanDragColSize(col) )

         {
         {

+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, GetColLabelWindow());
+        }
+        else // not a request to start resizing
+        {
+            col = XToCol(x);

             if ( col >= 0 &&
                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
             {
             if ( col >= 0 &&
                  !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
             {


@@ -3294,13 +3294,6 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
                 }
             }
         }
                 }
             }
         }

-        else
-        {
-            // starting to drag-resize a col
-            //
-            if ( CanDragColSize() )
-                ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, GetColLabelWindow());
-        }

     }
 
     // ------------ Left double click
     }
 
     // ------------ Left double click


@@ -3319,8 +3312,12 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
         else
         {
             // adjust column width depending on label text
         else
         {
             // adjust column width depending on label text

+            //
+            // TODO: generate RESIZING event, see #10754

             AutoSizeColLabelSize( colEdge );
 
             AutoSizeColLabelSize( colEdge );
 

+            SendGridSizeEvent(wxEVT_GRID_COL_SIZE, -1, colEdge, event);
+

             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
             m_dragLastPos = -1;
         }
             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
             m_dragLastPos = -1;
         }


@@ -3333,7 +3330,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
         switch ( m_cursorMode )
         {
             case WXGRID_CURSOR_RESIZE_COL:
         switch ( m_cursorMode )
         {
             case WXGRID_CURSOR_RESIZE_COL:

-                DoEndDragResizeCol();
+                DoEndDragResizeCol(event);

                 break;
 
             case WXGRID_CURSOR_MOVE_COL:
                 break;
 
             case WXGRID_CURSOR_MOVE_COL:


@@ -3394,8 +3391,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
         {
             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
             {
         {
             if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
             {

-                // don't capture the cursor yet
-                if ( CanDragColSize() )
+                if ( CanDragColSize(m_dragRowOrCol) )

                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, GetColLabelWindow(), false);
             }
         }
                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, GetColLabelWindow(), false);
             }
         }


@@ -3459,24 +3455,24 @@ void wxGrid::ChangeCursorMode(CursorMode mode,
                               wxWindow *win,
                               bool captureMouse)
 {
                               wxWindow *win,
                               bool captureMouse)
 {

-#ifdef __WXDEBUG__
+#if wxUSE_LOG_TRACE

     static const wxChar *cursorModes[] =
     {
     static const wxChar *cursorModes[] =
     {

-        _T("SELECT_CELL"),
-        _T("RESIZE_ROW"),
-        _T("RESIZE_COL"),
-        _T("SELECT_ROW"),
-        _T("SELECT_COL"),
-        _T("MOVE_COL"),
+        wxT("SELECT_CELL"),
+        wxT("RESIZE_ROW"),
+        wxT("RESIZE_COL"),
+        wxT("SELECT_ROW"),
+        wxT("SELECT_COL"),
+        wxT("MOVE_COL"),

     };
 
     };
 

-    wxLogTrace(_T("grid"),
-               _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
-               win == m_colWindow ? _T("colLabelWin")
-                                  : win ? _T("rowLabelWin")
-                                        : _T("gridWin"),
+    wxLogTrace(wxT("grid"),
+               wxT("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
+               win == m_colWindow ? wxT("colLabelWin")
+                                  : win ? wxT("rowLabelWin")
+                                        : wxT("gridWin"),

                cursorModes[m_cursorMode], cursorModes[mode]);
                cursorModes[m_cursorMode], cursorModes[mode]);

-#endif
+#endif // wxUSE_LOG_TRACE

 
     if ( mode == m_cursorMode &&
          win == m_winCapture &&
 
     if ( mode == m_cursorMode &&
          win == m_winCapture &&


@@ -3756,17 +3752,12 @@ wxGrid::DoGridCellLeftUp(wxMouseEvent& event, const wxGridCellCoords& coords)
     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
     {
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
     {
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);

-        DoEndDragResizeRow();
-
-        // Note: we are ending the event *after* doing
-        // default processing in this case
-        //
-        SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
+        DoEndDragResizeRow(event);

     }
     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
     {
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
     }
     else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
     {
         ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);

-        DoEndDragResizeCol();
+        DoEndDragResizeCol(event);

     }
 
     m_dragLastPos = -1;
     }
 
     m_dragLastPos = -1;


@@ -3796,27 +3787,24 @@ wxGrid::DoGridMouseMoveEvent(wxMouseEvent& WXUNUSED(event),
         return;
     }
 
         return;
     }
 

-    if ( dragRow >= 0 )
+    if ( dragRow >= 0 && CanDragGridSize() && CanDragRowSize(dragRow) )

     {
     {

-        m_dragRowOrCol = dragRow;
-

         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
         {
         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
         {

-            if ( CanDragRowSize() && CanDragGridSize() )
-                ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, NULL, false);
+            m_dragRowOrCol = dragRow;
+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, NULL, false);

         }
     }
     // When using the native header window we can only resize the columns by
     // dragging the dividers in it because we can't make it enter into the
     // column resizing mode programmatically
         }
     }
     // When using the native header window we can only resize the columns by
     // dragging the dividers in it because we can't make it enter into the
     // column resizing mode programmatically

-    else if ( dragCol >= 0 && !m_useNativeHeader )
+    else if ( dragCol >= 0 && !m_useNativeHeader &&
+                CanDragGridSize() && CanDragColSize(dragCol) )

     {
     {

-        m_dragRowOrCol = dragCol;
-

         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
         {
         if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
         {

-            if ( CanDragColSize() && CanDragGridSize() )
-                ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, NULL, false);
+            m_dragRowOrCol = dragCol;
+            ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, NULL, false);

         }
     }
     else // Neither on a row or col edge
         }
     }
     else // Neither on a row or col edge


@@ -3899,10 +3887,11 @@ void wxGrid::ProcessGridCellMouseEvent(wxMouseEvent& event)
     }
 }
 
     }
 }
 

-void wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)
+// this function returns true only if the size really changed
+bool wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)

 {
     if ( m_dragLastPos == -1 )
 {
     if ( m_dragLastPos == -1 )

-        return;
+        return false;

 
     const wxGridOperations& doper = oper.Dual();
 
 
     const wxGridOperations& doper = oper.Dual();
 


@@ -3926,9 +3915,12 @@ void wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)
 
     // do resize the line
     const int lineStart = oper.GetLineStartPos(this, m_dragRowOrCol);
 
     // do resize the line
     const int lineStart = oper.GetLineStartPos(this, m_dragRowOrCol);

+    const int lineSizeOld = oper.GetLineSize(this, m_dragRowOrCol);

     oper.SetLineSize(this, m_dragRowOrCol,
                      wxMax(m_dragLastPos - lineStart,
                            oper.GetMinimalLineSize(this, m_dragRowOrCol)));
     oper.SetLineSize(this, m_dragRowOrCol,
                      wxMax(m_dragLastPos - lineStart,
                            oper.GetMinimalLineSize(this, m_dragRowOrCol)));

+    const bool
+        sizeChanged = oper.GetLineSize(this, m_dragRowOrCol) != lineSizeOld;

 
     m_dragLastPos = -1;
 
 
     m_dragLastPos = -1;
 


@@ -3991,24 +3983,24 @@ void wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)
 
     // show the edit control back again
     ShowCellEditControl();
 
     // show the edit control back again
     ShowCellEditControl();

+
+    return sizeChanged;

 }
 
 }
 

-void wxGrid::DoEndDragResizeRow()
+void wxGrid::DoEndDragResizeRow(const wxMouseEvent& event)

 {
 {

-    DoEndDragResizeLine(wxGridRowOperations());
+    // TODO: generate RESIZING event, see #10754
+
+    if ( DoEndDragResizeLine(wxGridRowOperations()) )
+        SendGridSizeEvent(wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event);

 }
 
 }
 

-void wxGrid::DoEndDragResizeCol(wxMouseEvent *event)
+void wxGrid::DoEndDragResizeCol(const wxMouseEvent& event)

 {
 {

-    DoEndDragResizeLine(wxGridColumnOperations());
+    // TODO: generate RESIZING event, see #10754

 
 

-    // Note: we are ending the event *after* doing
-    // default processing in this case
-    //
-    if ( event )
-        SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, *event );
-    else
-        SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol );
+    if ( DoEndDragResizeLine(wxGridColumnOperations()) )
+        SendGridSizeEvent(wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event);

 }
 
 void wxGrid::DoStartMoveCol(int col)
 }
 
 void wxGrid::DoStartMoveCol(int col)


@@ -4182,9 +4174,27 @@ wxGrid::DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
     return (m_table->*funcAppend)(num);
 }
 
     return (m_table->*funcAppend)(num);
 }
 

-//
-// ----- event handlers
-//
+// ----------------------------------------------------------------------------
+// event generation helpers
+// ----------------------------------------------------------------------------
+
+void
+wxGrid::SendGridSizeEvent(wxEventType type,
+                      int row, int col,
+                      const wxMouseEvent& mouseEv)
+{
+   int rowOrCol = row == -1 ? col : row;
+
+   wxGridSizeEvent gridEvt( GetId(),
+           type,
+           this,
+           rowOrCol,
+           mouseEv.GetX() + GetRowLabelSize(),
+           mouseEv.GetY() + GetColLabelSize(),
+           mouseEv);
+
+   GetEventHandler()->ProcessEvent(gridEvt);
+}

 
 // Generate a grid event based on a mouse event and return:
 //  -1 if the event was vetoed
 
 // Generate a grid event based on a mouse event and return:
 //  -1 if the event was vetoed


@@ -4193,26 +4203,11 @@ wxGrid::DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
 int
 wxGrid::SendEvent(const wxEventType type,
                   int row, int col,
 int
 wxGrid::SendEvent(const wxEventType type,
                   int row, int col,

-                  wxMouseEvent& mouseEv)
+                  const wxMouseEvent& mouseEv)

 {
    bool claimed, vetoed;
 
 {
    bool claimed, vetoed;
 

-   if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
-   {
-       int rowOrCol = (row == -1 ? col : row);
-
-       wxGridSizeEvent gridEvt( GetId(),
-               type,
-               this,
-               rowOrCol,
-               mouseEv.GetX() + GetRowLabelSize(),
-               mouseEv.GetY() + GetColLabelSize(),
-               mouseEv);
-
-       claimed = GetEventHandler()->ProcessEvent(gridEvt);
-       vetoed = !gridEvt.IsAllowed();
-   }
-   else if ( type == wxEVT_GRID_RANGE_SELECT )
+   if ( type == wxEVT_GRID_RANGE_SELECT )

    {
        // Right now, it should _never_ end up here!
        wxGridRangeSelectEvent gridEvt( GetId(),
    {
        // Right now, it should _never_ end up here!
        wxGridRangeSelectEvent gridEvt( GetId(),


@@ -4275,28 +4270,13 @@ wxGrid::SendEvent(const wxEventType type,
 int
 wxGrid::SendEvent(const wxEventType type, int row, int col, const wxString& s)
 {
 int
 wxGrid::SendEvent(const wxEventType type, int row, int col, const wxString& s)
 {

-   bool claimed, vetoed;
+    wxGridEvent gridEvt( GetId(), type, this, row, col );
+    gridEvt.SetString(s);

 
 

-    if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
-    {
-        int rowOrCol = (row == -1 ? col : row);
-
-        wxGridSizeEvent gridEvt( GetId(), type, this, rowOrCol );
-
-        claimed = GetEventHandler()->ProcessEvent(gridEvt);
-        vetoed  = !gridEvt.IsAllowed();
-    }
-    else
-    {
-        wxGridEvent gridEvt( GetId(), type, this, row, col );
-        gridEvt.SetString(s);
-
-        claimed = GetEventHandler()->ProcessEvent(gridEvt);
-        vetoed  = !gridEvt.IsAllowed();
-     }
+    const bool claimed = GetEventHandler()->ProcessEvent(gridEvt);

 
     // A Veto'd event may not be `claimed' so test this first
 
     // A Veto'd event may not be `claimed' so test this first

-    if (vetoed)
+    if ( !gridEvt.IsAllowed() )

         return -1;
 
     return claimed ? 1 : 0;
         return -1;
 
     return claimed ? 1 : 0;


@@ -5733,7 +5713,7 @@ void wxGrid::EnableCellEditControl( bool enable )
                 return;
 
             // this should be checked by the caller!
                 return;
 
             // this should be checked by the caller!

-            wxASSERT_MSG( CanEnableCellControl(), _T("can't enable editing for this cell!") );
+            wxASSERT_MSG( CanEnableCellControl(), wxT("can't enable editing for this cell!") );

 
             // do it before ShowCellEditControl()
             m_cellEditCtrlEnabled = enable;
 
             // do it before ShowCellEditControl()
             m_cellEditCtrlEnabled = enable;


@@ -5976,7 +5956,7 @@ void wxGrid::SaveEditControlValue()
         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
 
         wxString newval;
         wxGridCellEditor* editor = attr->GetEditor(this, row, col);
 
         wxString newval;

-        bool changed = editor->EndEdit(oldval, &newval);
+        bool changed = editor->EndEdit(row, col, this, oldval, &newval);

 
         if ( changed && SendEvent(wxEVT_GRID_CELL_CHANGING, newval) != -1 )
         {
 
         if ( changed && SendEvent(wxEVT_GRID_CELL_CHANGING, newval) != -1 )
         {


@@ -6124,23 +6104,15 @@ int wxGrid::XToPos(int x) const
     return PosToLinePos(x, true /* clip */, wxGridColumnOperations());
 }
 
     return PosToLinePos(x, true /* clip */, wxGridColumnOperations());
 }
 

-// return the row number that that the y coord is near the edge of, or -1 if
+// return the row number such that the y coord is near the edge of, or -1 if

 // not near an edge.
 //
 // 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_ near 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.
-//
+// notice that position can only possibly be near an edge if the row/column is
+// large enough to still allow for an "inner" area that is _not_ near the edge
+// (i.e., if the height/width is smaller than WXGRID_LABEL_EDGE_ZONE, pos will
+// _never_ be considered to be near the edge).

 int wxGrid::PosToEdgeOfLine(int pos, const wxGridOperations& oper) const
 {
 int wxGrid::PosToEdgeOfLine(int pos, const wxGridOperations& oper) const
 {

-    if ( !oper.CanResizeLines(this) )
-        return -1;
-

     const int line = oper.PosToLine(this, pos, true);
 
     if ( oper.GetLineSize(this, line) > WXGRID_LABEL_EDGE_ZONE )
     const int line = oper.PosToLine(this, pos, true);
 
     if ( oper.GetLineSize(this, line) > WXGRID_LABEL_EDGE_ZONE )


@@ -6191,13 +6163,13 @@ wxRect wxGrid::CellToRect( int row, int col ) const
             rect.width += GetColWidth(i);
         for (i=row; i < row + cell_rows; i++)
             rect.height += GetRowHeight(i);
             rect.width += GetColWidth(i);
         for (i=row; i < row + cell_rows; i++)
             rect.height += GetRowHeight(i);

-    }

 
 

-    // if grid lines are enabled, then the area of the cell is a bit smaller
-    if (m_gridLinesEnabled)
-    {
-        rect.width -= 1;
-        rect.height -= 1;
+        // if grid lines are enabled, then the area of the cell is a bit smaller
+        if (m_gridLinesEnabled)
+        {
+            rect.width -= 1;
+            rect.height -= 1;
+        }

     }
 
     return rect;
     }
 
     return rect;


@@ -6898,7 +6870,7 @@ int wxGrid::GetDefaultRowSize() const
 
 int wxGrid::GetRowSize( int row ) const
 {
 
 int wxGrid::GetRowSize( int row ) const
 {

-    wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
+    wxCHECK_MSG( row >= 0 && row < m_numRows, 0, wxT("invalid row index") );

 
     return GetRowHeight(row);
 }
 
     return GetRowHeight(row);
 }


@@ -6910,7 +6882,7 @@ int wxGrid::GetDefaultColSize() const
 
 int wxGrid::GetColSize( int col ) const
 {
 
 int wxGrid::GetColSize( int col ) const
 {

-    wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
+    wxCHECK_MSG( col >= 0 && col < m_numCols, 0, wxT("invalid column index") );

 
     return GetColWidth(col);
 }
 
     return GetColWidth(col);
 }


@@ -7190,8 +7162,8 @@ wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
     wxGridCellAttr *attr = NULL;
     bool canHave = ((wxGrid*)this)->CanHaveAttributes();
 
     wxGridCellAttr *attr = NULL;
     bool canHave = ((wxGrid*)this)->CanHaveAttributes();
 

-    wxCHECK_MSG( canHave, attr, _T("Cell attributes not allowed"));
-    wxCHECK_MSG( m_table, attr, _T("must have a table") );
+    wxCHECK_MSG( canHave, attr, wxT("Cell attributes not allowed"));
+    wxCHECK_MSG( m_table, attr, wxT("must have a table") );

 
     attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
     if ( !attr )
 
     attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
     if ( !attr )


@@ -7225,7 +7197,7 @@ void wxGrid::SetColFormatFloat(int col, int width, int precision)
     wxString typeName = wxGRID_VALUE_FLOAT;
     if ( (width != -1) || (precision != -1) )
     {
     wxString typeName = wxGRID_VALUE_FLOAT;
     if ( (width != -1) || (precision != -1) )
     {

-        typeName << _T(':') << width << _T(',') << precision;
+        typeName << wxT(':') << width << wxT(',') << precision;

     }
 
     SetColFormatCustom(col, typeName);
     }
 
     SetColFormatCustom(col, typeName);


@@ -7481,6 +7453,22 @@ wxGridCellRenderer * wxGrid::GetDefaultRendererForType(const wxString& typeName)
 // row/col size
 // ----------------------------------------------------------------------------
 
 // row/col size
 // ----------------------------------------------------------------------------
 

+void wxGrid::DoDisableLineResize(int line, wxGridFixedIndicesSet *& setFixed)
+{
+    if ( !setFixed )
+    {
+        setFixed = new wxGridFixedIndicesSet;
+    }
+
+    setFixed->insert(line);
+}
+
+bool
+wxGrid::DoCanResizeLine(int line, const wxGridFixedIndicesSet *setFixed) const
+{
+    return !setFixed || !setFixed->count(line);
+}
+

 void wxGrid::EnableDragRowSize( bool enable )
 {
     m_canDragRowSize = enable;
 void wxGrid::EnableDragRowSize( bool enable )
 {
     m_canDragRowSize = enable;


@@ -7520,7 +7508,7 @@ void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
 
 void wxGrid::SetRowSize( int row, int height )
 {
 
 void wxGrid::SetRowSize( int row, int height )
 {

-    wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
+    wxCHECK_RET( row >= 0 && row < m_numRows, wxT("invalid row index") );

 
     // if < 0 then calculate new height from label
     if ( height < 0 )
 
     // if < 0 then calculate new height from label
     if ( height < 0 )


@@ -7578,7 +7566,7 @@ void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
 
 void wxGrid::SetColSize( int col, int width )
 {
 
 void wxGrid::SetColSize( int col, int width )
 {

-    wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
+    wxCHECK_RET( col >= 0 && col < m_numCols, wxT("invalid column index") );

 
     // if < 0 then calculate new width from label
     if ( width < 0 )
 
     // if < 0 then calculate new width from label
     if ( width < 0 )


@@ -8083,7 +8071,8 @@ void wxGrid::DeselectLine(int line, const wxGridOperations& oper)
         return;
 
     const wxGridSelectionModes mode = m_selection->GetSelectionMode();
         return;
 
     const wxGridSelectionModes mode = m_selection->GetSelectionMode();

-    if ( mode == oper.GetSelectionMode() )
+    if ( mode == oper.GetSelectionMode() ||
+            mode == wxGrid::wxGridSelectRowsOrColumns )

     {
         const wxGridCellCoords c(oper.MakeCoords(line, 0));
         if ( m_selection->IsInSelection(c) )
     {
         const wxGridCellCoords c(oper.MakeCoords(line, 0));
         if ( m_selection->IsInSelection(c) )


@@ -8201,8 +8190,10 @@ void wxGrid::ClearSelection()
     m_selectedBlockBottomRight =
     m_selectedBlockCorner = wxGridNoCellCoords;
 
     m_selectedBlockBottomRight =
     m_selectedBlockCorner = wxGridNoCellCoords;
 

-    Refresh( false, &r1 );
-    Refresh( false, &r2 );
+    if ( !r1.IsEmpty() )
+        RefreshRect(r1, false);
+    if ( !r2.IsEmpty() )
+        RefreshRect(r2, false);

 
     if ( m_selection )
         m_selection->ClearSelection();
 
     if ( m_selection )
         m_selection->ClearSelection();


@@ -8334,6 +8325,48 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords& topLeft,
     return resultRect;
 }
 
     return resultRect;
 }
 

+void wxGrid::DoSetSizes(const wxGridSizesInfo& sizeInfo,
+                        const wxGridOperations& oper)
+{
+    BeginBatch();
+    oper.SetDefaultLineSize(this, sizeInfo.m_sizeDefault, true);
+    const int numLines = oper.GetNumberOfLines(this);
+    for ( int i = 0; i < numLines; i++ )
+    {
+        int size = sizeInfo.GetSize(i);
+        if ( size != sizeInfo.m_sizeDefault)
+            oper.SetLineSize(this, i, size);
+    }
+    EndBatch();
+}
+
+void wxGrid::SetColSizes(const wxGridSizesInfo& sizeInfo)
+{
+    DoSetSizes(sizeInfo, wxGridColumnOperations());
+}
+
+void wxGrid::SetRowSizes(const wxGridSizesInfo& sizeInfo)
+{
+    DoSetSizes(sizeInfo, wxGridRowOperations());
+}
+
+wxGridSizesInfo::wxGridSizesInfo(int defSize, const wxArrayInt& allSizes)
+{
+    m_sizeDefault = defSize;
+    for ( size_t i = 0; i < allSizes.size(); i++ )
+    {
+        if ( allSizes[i] != defSize )
+            m_customSizes[i] = allSizes[i];
+    }
+}
+
+int wxGridSizesInfo::GetSize(unsigned pos) const
+{
+    wxUnsignedToIntHashMap::const_iterator it = m_customSizes.find(pos);
+
+    return it == m_customSizes.end() ? m_sizeDefault : it->second;
+}
+

 // ----------------------------------------------------------------------------
 // drop target
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // drop target
 // ----------------------------------------------------------------------------


@@ -8521,7 +8554,7 @@ int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
     {
         // the first part of the typename is the "real" type, anything after ':'
         // are the parameters for the renderer
     {
         // the first part of the typename is the "real" type, anything after ':'
         // are the parameters for the renderer

-        index = FindDataType(typeName.BeforeFirst(_T(':')));
+        index = FindDataType(typeName.BeforeFirst(wxT(':')));

         if ( index == wxNOT_FOUND )
         {
             return wxNOT_FOUND;
         if ( index == wxNOT_FOUND )
         {
             return wxNOT_FOUND;


@@ -8538,7 +8571,7 @@ int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
         editorOld->DecRef();
 
         // do it even if there are no parameters to reset them to defaults
         editorOld->DecRef();
 
         // do it even if there are no parameters to reset them to defaults

-        wxString params = typeName.AfterFirst(_T(':'));
+        wxString params = typeName.AfterFirst(wxT(':'));

         renderer->SetParameters(params);
         editor->SetParameters(params);
 
         renderer->SetParameters(params);
         editor->SetParameters(params);