X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/46cbb21ecbe0b016592a2166e4c9e3cec8f49d88..15f0ad701496612df8c145e8e46d4b38515c0bbf:/src/generic/grid.cpp

diff --git a/src/generic/grid.cpp b/src/generic/grid.cpp
index 99090322c0..b108ed7eb1 100644
--- a/src/generic/grid.cpp
+++ b/src/generic/grid.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////
-// Name:        generic/grid.cpp
+// Name:        src/generic/grid.cpp
 // Purpose:     wxGrid and related classes
 // Author:      Michael Bedward (based on code by Julian Smart, Robin Dunn)
 // Modified by: Robin Dunn, Vadim Zeitlin
@@ -1159,20 +1159,25 @@ void wxGridCellFloatEditor::SetParameters(const wxString& params)
 wxString wxGridCellFloatEditor::GetString() const
 {
     wxString fmt;
-    if ( m_width == -1 )
-    {
-        // default width/precision
-        fmt = _T("%f");
-    }
-    else if ( m_precision == -1 )
+    if ( m_precision == -1 && m_width != -1)
     {
         // default precision
         fmt.Printf(_T("%%%d.f"), m_width);
     }
-    else
+    else if ( m_precision != -1 && m_width == -1)
+    {
+        // default width
+        fmt.Printf(_T("%%.%df"), m_precision);
+    }
+    else if ( m_precision != -1 && m_width != -1 )
     {
         fmt.Printf(_T("%%%d.%df"), m_width, m_precision);
     }
+    else
+    {
+        // default width/precision
+        fmt = _T("%f");
+    }
 
     return wxString::Format(fmt, m_valueOld);
 }
@@ -1582,6 +1587,14 @@ void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent& event)
 
 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
 {
+    int row = m_grid->GetGridCursorRow();
+    int col = m_grid->GetGridCursorCol();
+    wxRect rect = m_grid->CellToRect( row, col );
+    int cw, ch;
+    m_grid->GetGridWindow()->GetClientSize( &cw, &ch );
+    // if cell width is smaller than grid client area, cell is wholly visible
+    bool wholeCellVisible = (rect.GetWidth() < cw);
+
     switch ( event.GetKeyCode() )
     {
         case WXK_ESCAPE:
@@ -1590,6 +1603,85 @@ void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent& event)
         case WXK_NUMPAD_ENTER:
             break;
 
+        case WXK_HOME:
+        {
+            if( wholeCellVisible )
+            {
+                // no special processing needed...
+                event.Skip();
+                break;
+            }
+
+            // do special processing for partly visible cell...
+
+            // get the widths of all cells previous to this one
+            int colXPos = 0;
+            for ( int i = 0; i < col; i++ )
+            {
+                colXPos += m_grid->GetColSize(i);
+            }
+
+            int xUnit = 1, yUnit = 1;
+            m_grid->GetScrollPixelsPerUnit(&xUnit, &yUnit);
+            if (col != 0)
+            {
+                m_grid->Scroll(colXPos/xUnit-1, m_grid->GetScrollPos(wxVERTICAL));
+            }
+            else
+            {
+                m_grid->Scroll(colXPos/xUnit, m_grid->GetScrollPos(wxVERTICAL));
+            }
+            event.Skip();
+            break;
+        }
+        case WXK_END:
+        {
+            if( wholeCellVisible )
+            {
+                // no special processing needed...
+                event.Skip();
+                break;
+            }
+
+            // do special processing for partly visible cell...
+
+            int textWidth = 0;
+            wxString value = m_grid->GetCellValue(row, col);
+            if ( wxEmptyString != value )
+            {
+                // get width of cell CONTENTS (text)
+                int y;
+                wxFont font = m_grid->GetCellFont(row, col);
+                m_grid->GetTextExtent(value, &textWidth, &y, NULL, NULL, &font);
+                // try to RIGHT align the text by scrolling
+                int client_right = m_grid->GetGridWindow()->GetClientSize().GetWidth();
+                // (m_grid->GetScrollLineX()*2) is a factor for not scrolling to far,
+                // otherwise the last part of the cell content might be hidden below the scroll bar
+                // FIXME: maybe there is a more suitable correction?
+                textWidth -= (client_right - (m_grid->GetScrollLineX()*2));
+                if ( textWidth < 0 )
+                {
+                    textWidth = 0;
+                }
+            }
+
+            // get the widths of all cells previous to this one
+            int colXPos = 0;
+            for ( int i = 0; i < col; i++ )
+            {
+                colXPos += m_grid->GetColSize(i);
+            }
+            // and add the (modified) text width of the cell contents
+            // as we'd like to see the last part of the cell contents
+            colXPos += textWidth;
+
+            int xUnit = 1, yUnit = 1;
+            m_grid->GetScrollPixelsPerUnit(&xUnit, &yUnit);
+            m_grid->Scroll(colXPos/xUnit-1, m_grid->GetScrollPos(wxVERTICAL));
+            event.Skip();
+            break;
+        }
+
         default:
             event.Skip();
     }
@@ -2640,16 +2732,16 @@ wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
     wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
     if ( m_data )
     {
-        switch(kind)
+        switch (kind)
         {
             case (wxGridCellAttr::Any):
-                //Get cached merge attributes.
-                // Currenlty not used as no cache implemented as not mutiable
+                // Get cached merge attributes.
+                // Currently not used as no cache implemented as not mutable
                 // attr = m_data->m_mergeAttr.GetAttr(row, col);
                 if (!attr)
                 {
-                    //Basically implement old version.
-                    //Also check merge cache, so we don't have to re-merge every time..
+                    // Basically implement old version.
+                    // Also check merge cache, so we don't have to re-merge every time..
                     wxGridCellAttr *attrcell = m_data->m_cellAttrs.GetAttr(row, col);
                     wxGridCellAttr *attrrow = m_data->m_rowAttrs.GetAttr(row);
                     wxGridCellAttr *attrcol = m_data->m_colAttrs.GetAttr(col);
@@ -2660,7 +2752,7 @@ wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
                         attr = new wxGridCellAttr;
                         attr->SetKind(wxGridCellAttr::Merged);
 
-                        //Order important..
+                        // Order is important..
                         if (attrcell)
                         {
                             attr->MergeWith(attrcell);
@@ -2676,7 +2768,8 @@ wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
                             attr->MergeWith(attrrow);
                             attrrow->DecRef();
                         }
-                        //store merge attr if cache implemented
+
+                        // store merge attr if cache implemented
                         //attr->IncRef();
                         //m_data->m_mergeAttr.SetAttr(attr, row, col);
                     }
@@ -2687,7 +2780,7 @@ wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
                             attr = attrrow;
                         if (attrcol)
                         {
-                            if(attr)
+                            if (attr)
                                 attr->DecRef();
                             attr = attrcol;
                         }
@@ -4182,8 +4275,7 @@ bool wxGrid::SetTable( wxGridTableBase *table, bool takeOwnership,
 
         m_table = table;
         m_table->SetView( this );
-        if (takeOwnership)
-            m_ownTable = true;
+        m_ownTable = takeOwnership;
         m_selection = new wxGridSelection( this, selmode );
 
         CalcDimensions();
@@ -4928,7 +5020,7 @@ void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
 
         if ( event.LeftIsDown() )
         {
-            switch( m_cursorMode )
+            switch ( m_cursorMode )
             {
                 case WXGRID_CURSOR_RESIZE_ROW:
                 {
@@ -5153,7 +5245,7 @@ void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
 
         if ( event.LeftIsDown() )
         {
-            switch( m_cursorMode )
+            switch ( m_cursorMode )
             {
                 case WXGRID_CURSOR_RESIZE_COL:
                 {
@@ -5484,7 +5576,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
     {
         //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
 
-        // Don't start doing anything until the mouse has been drug at
+        // Don't start doing anything until the mouse has been dragged at
         // least 3 pixels in any direction...
         if (! m_isDragging)
         {
@@ -5693,7 +5785,6 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 m_waitForSlowClick = true;
             }
         }
-
     }
 
 
@@ -5709,7 +5800,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 m_winCapture = NULL;
             }
 
-            if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl())
+            if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl() )
             {
                 ClearSelection();
                 EnableCellEditControl();
@@ -5816,7 +5907,7 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
         // Dragging on the corner of a cell to resize in both
         // directions is not implemented yet...
         //
-        if ( dragRow >= 0  &&  dragCol >= 0 )
+        if ( dragRow >= 0 && dragCol >= 0 )
         {
             ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
             return;
@@ -5831,16 +5922,8 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 if ( CanDragRowSize() && CanDragGridSize() )
                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
             }
-
-            if ( dragCol >= 0 )
-            {
-                m_dragRowOrCol = dragCol;
-            }
-
-            return;
         }
-
-        if ( dragCol >= 0 )
+        else if ( dragCol >= 0 )
         {
             m_dragRowOrCol = dragCol;
 
@@ -5849,15 +5932,13 @@ void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
                 if ( CanDragColSize() && CanDragGridSize() )
                     ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
             }
-
-            return;
         }
-
-        // Neither on a row or col edge
-        //
-        if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
+        else // Neither on a row or col edge
         {
-            ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+            if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
+            {
+                ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
+            }
         }
     }
 }
@@ -6527,11 +6608,11 @@ void wxGrid::OnKeyDown( wxKeyEvent& event )
                 }
                 break;
 
-            case WXK_PRIOR:
+            case WXK_PAGEUP:
                 MovePageUp();
                 break;
 
-            case WXK_NEXT:
+            case WXK_PAGEDOWN:
                 MovePageDown();
                 break;
 
@@ -6647,8 +6728,8 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
         return;
     }
 
-    wxClientDC dc(m_gridWin);
-    PrepareDC(dc);
+    wxClientDC dc( m_gridWin );
+    PrepareDC( dc );
 
     if ( m_currentCellCoords != wxGridNoCellCoords )
     {
@@ -6657,7 +6738,7 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
         if ( IsVisible( m_currentCellCoords, false ) )
         {
             wxRect r;
-            r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
+            r = BlockToDeviceRect( m_currentCellCoords, m_currentCellCoords );
             if ( !m_gridLinesEnabled )
             {
                 r.x--;
@@ -6671,15 +6752,15 @@ void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
             // Otherwise refresh redraws the highlight!
             m_currentCellCoords = coords;
 
-            DrawGridCellArea(dc,cells);
+            DrawGridCellArea( dc, cells );
             DrawAllGridLines( dc, r );
         }
     }
 
     m_currentCellCoords = coords;
 
-    wxGridCellAttr* attr = GetCellAttr(coords);
-    DrawCellHighlight(dc, attr);
+    wxGridCellAttr *attr = GetCellAttr( coords );
+    DrawCellHighlight( dc, attr );
     attr->DecRef();
 }
 
@@ -7053,9 +7134,15 @@ void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
     // Note: However, only if it is really _shown_, i.e. not hidden!
     if ( isCurrent && IsCellEditControlShown() )
     {
+        // OSAF NB: this "#if..." is temporary and fixes a problem where the
+        // 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
         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
         editor->PaintBackground(rect, attr);
         editor->DecRef();
+#endif
     }
     else
     {
@@ -7478,8 +7565,8 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
                                int vertAlign,
                                int textOrientation )
 {
-    long textWidth, textHeight;
-    long lineWidth, lineHeight;
+    long textWidth = 0, textHeight = 0;
+    long lineWidth = 0, lineHeight = 0;
     int nLines;
 
     dc.SetClippingRegion( rect );
@@ -7495,7 +7582,7 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
         else
             GetTextBoxSize( dc, lines, &textHeight, &textWidth );
 
-        switch( vertAlign )
+        switch ( vertAlign )
         {
         case wxALIGN_BOTTOM:
             if ( textOrientation == wxHORIZONTAL )
@@ -7525,7 +7612,7 @@ void wxGrid::DrawTextRectangle( wxDC& dc,
         {
             dc.GetTextExtent(lines[l], &lineWidth, &lineHeight);
 
-            switch( horizAlign )
+            switch ( horizAlign )
             {
             case wxALIGN_RIGHT:
                 if ( textOrientation == wxHORIZONTAL )
@@ -7577,7 +7664,7 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
     wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
     wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
 
-    while ( startPos < (int)tVal.Length() )
+    while ( startPos < (int)tVal.length() )
     {
         pos = tVal.Mid(startPos).Find( eol );
         if ( pos < 0 )
@@ -7595,7 +7682,7 @@ void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
         startPos += pos + 1;
     }
 
-    if ( startPos < (int)value.Length() )
+    if ( startPos < (int)value.length() )
     {
         lines.Add( value.Mid( startPos ) );
     }
@@ -7608,7 +7695,7 @@ void wxGrid::GetTextBoxSize( const wxDC& dc,
 {
     long w = 0;
     long h = 0;
-    long lineW, lineH;
+    long lineW = 0, lineH = 0;
 
     size_t i;
     for ( i = 0;  i < lines.GetCount();  i++ )
@@ -7684,9 +7771,6 @@ void wxGrid::EnableCellEditControl( bool enable )
     if (! m_editable)
         return;
 
-    if ( m_currentCellCoords == wxGridNoCellCoords )
-        SetCurrentCell( 0, 0 );
-
     if ( enable != m_cellEditCtrlEnabled )
     {
         if ( enable )
@@ -7771,7 +7855,7 @@ void wxGrid::ShowCellEditControl()
 {
     if ( IsCellEditControlEnabled() )
     {
-        if ( !IsVisible( m_currentCellCoords ) )
+        if ( !IsVisible( m_currentCellCoords, false ) )
         {
             m_cellEditCtrlEnabled = false;
             return;
@@ -7797,6 +7881,10 @@ void wxGrid::ShowCellEditControl()
             //
             CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
 
+            int nXMove = 0;
+            if (rect.x < 0)
+                nXMove = rect.x;
+
             // done in PaintBackground()
 #if 0
             // erase the highlight and the cell contents because the editor
@@ -7858,21 +7946,35 @@ void wxGrid::ShowCellEditControl()
                     int c_rows, c_cols;
                     GetCellSize( row, i, &c_rows, &c_cols );
                     // looks weird going over a multicell
-                    if (m_table->IsEmptyCell(row,i) &&
+                    if (m_table->IsEmptyCell( row, i ) &&
                             (rect.width < maxWidth) && (c_rows == 1))
-                        rect.width += GetColWidth(i);
+                        rect.width += GetColWidth( i );
                     else
                         break;
                 }
 
                 if (rect.GetRight() > client_right)
-                    rect.SetRight(client_right - 1);
+                    rect.SetRight( client_right - 1 );
             }
 
-            editor->SetCellAttr(attr);
+            editor->SetCellAttr( attr );
             editor->SetSize( rect );
+            editor->GetControl()->Move( editor->GetControl()->GetPosition().x + nXMove, editor->GetControl()->GetPosition().y );
             editor->Show( true, attr );
 
+            int colXPos = 0;
+            for (int i = 0; i < m_currentCellCoords.GetCol(); i++)
+            {
+                colXPos += GetColSize( i );
+            }
+
+            int xUnit = 1, yUnit = 1;
+            GetScrollPixelsPerUnit( &xUnit, &yUnit );
+            if (m_currentCellCoords.GetCol() != 0)
+                Scroll( colXPos / xUnit - 1, GetScrollPos( wxVERTICAL ) );
+            else
+                Scroll( colXPos / xUnit, GetScrollPos( wxVERTICAL ) );
+
             // recalc dimensions in case we need to
             // expand the scrolled window to account for editor
             CalcDimensions();
@@ -7893,7 +7995,7 @@ void wxGrid::HideCellEditControl()
         int row = m_currentCellCoords.GetRow();
         int col = m_currentCellCoords.GetCol();
 
-        wxGridCellAttr* attr = GetCellAttr(row, col);
+        wxGridCellAttr *attr = GetCellAttr(row, col);
         wxGridCellEditor *editor = attr->GetEditor(this, row, col);
         editor->Show( false );
         editor->DecRef();
@@ -8202,7 +8304,11 @@ void wxGrid::MakeCellVisible( int row, int col )
             ypos += m_scrollLineY;
         }
 
-        if ( left < 0 )
+        // special handling for wide cells - show always left part of the cell!
+        // Otherwise, e.g. when stepping from row to row, it would jump between
+        // left and right part of the cell on every step!
+//      if ( left < 0 )
+        if ( left < 0 || (right-left) >= cw )
         {
             xpos = r.GetLeft();
         }
@@ -8239,7 +8345,7 @@ bool wxGrid::MoveCursorUp( bool expandSelection )
     if ( m_currentCellCoords != wxGridNoCellCoords  &&
          m_currentCellCoords.GetRow() >= 0 )
     {
-        if ( expandSelection)
+        if ( expandSelection )
         {
             if ( m_selectingKeyboard == wxGridNoCellCoords )
                 m_selectingKeyboard = m_currentCellCoords;
@@ -8253,11 +8359,11 @@ bool wxGrid::MoveCursorUp( bool expandSelection )
         }
         else if ( m_currentCellCoords.GetRow() > 0 )
         {
+            int row = m_currentCellCoords.GetRow() - 1;
+            int col = m_currentCellCoords.GetCol();
             ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow() - 1,
-                             m_currentCellCoords.GetCol() );
-            SetCurrentCell( m_currentCellCoords.GetRow() - 1,
-                            m_currentCellCoords.GetCol() );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
         }
         else
             return false;
@@ -8288,11 +8394,11 @@ bool wxGrid::MoveCursorDown( bool expandSelection )
         }
         else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
         {
+            int row = m_currentCellCoords.GetRow() + 1;
+            int col = m_currentCellCoords.GetCol();
             ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow() + 1,
-                             m_currentCellCoords.GetCol() );
-            SetCurrentCell( m_currentCellCoords.GetRow() + 1,
-                            m_currentCellCoords.GetCol() );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
         }
         else
             return false;
@@ -8322,11 +8428,11 @@ bool wxGrid::MoveCursorLeft( bool expandSelection )
         }
         else if ( m_currentCellCoords.GetCol() > 0 )
         {
+            int row = m_currentCellCoords.GetRow();
+            int col = m_currentCellCoords.GetCol() - 1;
             ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow(),
-                             m_currentCellCoords.GetCol() - 1 );
-            SetCurrentCell( m_currentCellCoords.GetRow(),
-                            m_currentCellCoords.GetCol() - 1 );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
         }
         else
             return false;
@@ -8356,11 +8462,11 @@ bool wxGrid::MoveCursorRight( bool expandSelection )
         }
         else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
         {
+            int row = m_currentCellCoords.GetRow();
+            int col = m_currentCellCoords.GetCol() + 1;
             ClearSelection();
-            MakeCellVisible( m_currentCellCoords.GetRow(),
-                             m_currentCellCoords.GetCol() + 1 );
-            SetCurrentCell( m_currentCellCoords.GetRow(),
-                            m_currentCellCoords.GetCol() + 1 );
+            MakeCellVisible( row, col );
+            SetCurrentCell( row, col );
         }
         else
             return false;
@@ -9596,7 +9702,7 @@ wxGrid::GetDefaultEditorForType(const wxString& typeName) const
     int index = m_typeRegistry->FindOrCloneDataType(typeName);
     if ( index == wxNOT_FOUND )
     {
-    wxString	errStr;
+        wxString errStr;
 
         errStr.Printf(wxT("Unknown data type name [%s]"), typeName.c_str());
         wxFAIL_MSG(errStr.c_str());
@@ -9613,7 +9719,7 @@ wxGrid::GetDefaultRendererForType(const wxString& typeName) const
     int index = m_typeRegistry->FindOrCloneDataType(typeName);
     if ( index == wxNOT_FOUND )
     {
-    wxString	errStr;
+    wxString errStr;
 
         errStr.Printf(wxT("Unknown data type name [%s]"), typeName.c_str());
         wxFAIL_MSG(errStr.c_str());
@@ -9624,7 +9730,6 @@ wxGrid::GetDefaultRendererForType(const wxString& typeName) const
     return m_typeRegistry->GetRenderer(index);
 }
 
-
 // ----------------------------------------------------------------------------
 // row/col size
 // ----------------------------------------------------------------------------
@@ -9722,7 +9827,7 @@ void wxGrid::SetColSize( int col, int width )
     //
     // This test then fixes sf.net bug #645734
 
-    if ( width < GetColMinimalAcceptableWidth())
+    if ( width < GetColMinimalAcceptableWidth() )
         return;
 
     if ( m_colWidths.IsEmpty() )
@@ -9742,6 +9847,7 @@ void wxGrid::SetColSize( int col, int width )
       GetTextBoxSize(dc, lines, &w, &h);
       width = w + 6;
     }
+
     int w = wxMax( 0, width );
     int diff = w - m_colWidths[col];
     m_colWidths[col] = w;
@@ -9751,6 +9857,7 @@ void wxGrid::SetColSize( int col, int width )
     {
         m_colRights[i] += diff;
     }
+
     if ( !GetBatchCount() )
         CalcDimensions();
 }
@@ -9777,6 +9884,7 @@ int wxGrid::GetColMinimalWidth(int col) const
 {
     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
     wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
+
     return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
 }
 
@@ -9784,25 +9892,24 @@ int wxGrid::GetRowMinimalHeight(int row) const
 {
     wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
     wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
+
     return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
 }
 
 void wxGrid::SetColMinimalAcceptableWidth( int width )
 {
     // We do allow a width of 0 since this gives us
-    // an easy way to temporarily hidding columns.
-    if ( width < 0 )
-        return;
-    m_minAcceptableColWidth = width;
+    // an easy way to temporarily hiding columns.
+    if ( width >= 0 )
+        m_minAcceptableColWidth = width;
 }
 
 void wxGrid::SetRowMinimalAcceptableHeight( int height )
 {
     // We do allow a height of 0 since this gives us
-    // an easy way to temporarily hidding rows.
-    if ( height < 0 )
-        return;
-    m_minAcceptableRowHeight = height;
+    // an easy way to temporarily hiding rows.
+    if ( height >= 0 )
+        m_minAcceptableRowHeight = height;
 }
 
 int  wxGrid::GetColMinimalAcceptableWidth() const
@@ -9823,11 +9930,11 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
 {
     wxClientDC dc(m_gridWin);
 
-    //Cancel editting of cell
+    // cancel editing of cell
     HideCellEditControl();
     SaveEditControlValue();
 
-    // init both of them to avoid compiler warnings, even if weo nly need one
+    // init both of them to avoid compiler warnings, even if we only need one
     int row = -1,
         col = -1;
     if ( column )
@@ -9889,19 +9996,15 @@ void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
     else
     {
         if ( column )
-        {
             // leave some space around text
             extentMax += 10;
-        }
         else
-        {
             extentMax += 6;
-        }
     }
 
     if ( column )
     {
-        SetColSize(col, extentMax);
+        SetColSize( col, extentMax );
         if ( !GetBatchCount() )
         {
             int cw, ch, dummy;
@@ -9971,9 +10074,7 @@ int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
     for ( int row = 0; row < m_numRows; row++ )
     {
         if ( !calcOnly )
-        {
             AutoSizeRow(row, setAsMin);
-        }
 
         height += GetRowHeight(row);
     }
@@ -10139,10 +10240,12 @@ wxSize wxGrid::DoGetBestSize() const
         height = maxheight;
 
     wxSize best(width, height);
+
     // 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;
 }
 
@@ -10189,9 +10292,9 @@ void wxGrid::SetCellValue( int row, int col, const wxString& s )
 }
 
 
-//
-// ------ Block, row and col selection
-//
+// ----------------------------------------------------------------------------
+// block, row and col selection
+// ----------------------------------------------------------------------------
 
 void wxGrid::SelectRow( int row, bool addToSelected )
 {
@@ -10231,9 +10334,9 @@ void wxGrid::SelectAll()
     }
 }
 
-//
-// ------ Cell, row and col deselection
-//
+// ----------------------------------------------------------------------------
+// cell, row and col deselection
+// ----------------------------------------------------------------------------
 
 void wxGrid::DeselectRow( int row )
 {
@@ -10379,7 +10482,7 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
     }
     else
     {
-        rect = wxRect(0,0,0,0);
+        rect = wxRect(0, 0, 0, 0);
     }
 
     cellRect = CellToRect( bottomRight );
@@ -10423,7 +10526,6 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
         bottomRow = i;
     }
 
-
     for ( j = topRow; j <= bottomRow; j++ )
     {
         for ( i = leftCol; i <= rightCol; i++ )
@@ -10467,9 +10569,9 @@ wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
     return rect;
 }
 
-//
-// ------ Grid event classes
-//
+// ----------------------------------------------------------------------------
+// grid event classes
+// ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
 
@@ -10546,4 +10648,3 @@ wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
 }
 
 #endif // wxUSE_GRID
-