src/generic/gridg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gridg.cpp
   3 // Purpose:     wxGenericGrid
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "gridg.h"
  14 #pragma interface
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx/wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #ifndef WX_PRECOMP
  25 #include "wx/wx.h"
  26 #endif
  27
  28 #include <string.h>
  29
  30 #include "wx/string.h"
  31 #include "wx/generic/gridg.h"
  32 #include "wx/settings.h"
  33
  34 // Set to zero to use no double-buffering
  35 #ifdef __WXMSW__
  36 #define USE_DOUBLE_BUFFERING 1
  37 #else
  38 #define USE_DOUBLE_BUFFERING 0
  39 #endif
  40
  41 #define wxGRID_DRAG_NONE       0
  42 #define wxGRID_DRAG_LEFT_RIGHT 1
  43 #define wxGRID_DRAG_UP_DOWN    2
  44
  45 IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid, wxPanel)
  46
  47 BEGIN_EVENT_TABLE(wxGenericGrid, wxPanel)
  48         EVT_SIZE(wxGenericGrid::OnSize)
  49         EVT_PAINT(wxGenericGrid::OnPaint)
  50         EVT_ERASE_BACKGROUND(wxGenericGrid::OnEraseBackground)
  51         EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent)
  52     EVT_TEXT(wxGRID_TEXT_CTRL, wxGenericGrid::OnText)
  53     EVT_COMMAND_SCROLL(wxGRID_HSCROLL, wxGenericGrid::OnGridScroll)
  54     EVT_COMMAND_SCROLL(wxGRID_VSCROLL, wxGenericGrid::OnGridScroll)
  55 END_EVENT_TABLE()
  56
  57 wxGenericGrid::wxGenericGrid(void)
  58 {
  59   m_batchCount = 0;
  60   m_hScrollBar = (wxScrollBar *) NULL;
  61   m_vScrollBar = (wxScrollBar *) NULL;
  62   m_cellTextColour = *wxBLACK;
  63   m_cellBackgroundColour = *wxWHITE;
  64   m_labelTextColour = *wxBLACK;
  65 //  m_labelBackgroundColour = *wxLIGHT_GREY;
  66   m_labelBackgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
  67   m_labelBackgroundBrush = (wxBrush *) NULL;
  68   m_labelTextFont = (wxFont *) NULL;
  69   m_cellTextFont = (wxFont *) NULL;
  70   m_textItem = (wxTextCtrl *) NULL;
  71   m_currentRectVisible = FALSE;
  72   m_editable = TRUE;
  73 #if defined(__WIN95__)
  74   m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
  75 #else
  76   m_scrollWidth = 16;
  77 #endif
  78   m_dragStatus = wxGRID_DRAG_NONE;
  79   m_dragRowOrCol = 0;
  80   m_dragStartPosition = 0;
  81   m_dragLastPosition = 0;
  82   m_divisionPen = (wxPen *) NULL;
  83   m_leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
  84   m_topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
  85   m_cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
  86   m_totalGridWidth = 0;
  87   m_totalGridHeight = 0;
  88   m_colWidths = (short *) NULL;
  89   m_rowHeights = (short *) NULL;
  90   m_verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
  91   m_horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
  92   m_verticalLabelAlignment = wxCENTRE;
  93   m_horizontalLabelAlignment = wxCENTRE;
  94   m_editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
  95   m_editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
  96   m_editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
  97   m_editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
  98   m_wCursorRow = 0;
  99   m_wCursorColumn = 0;
 100   m_scrollPosX = 0;
 101   m_scrollPosY = 0;
 102   m_editCreated = FALSE;
 103   m_totalRows = 0;
 104   m_totalCols = 0;
 105   m_gridCells = (wxGridCell ***) NULL;
 106   m_rowLabelCells = (wxGridCell **) NULL;
 107   m_colLabelCells = (wxGridCell **) NULL;
 108   m_textItem = (wxTextCtrl *) NULL;
 109   m_horizontalSashCursor = (wxCursor *) NULL;
 110   m_verticalSashCursor = (wxCursor *) NULL;
 111 }
 112
 113 bool wxGenericGrid::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
 114  long style, const wxString& name)
 115 {
 116   m_batchCount = 0;
 117   m_editingPanel = (wxPanel *) NULL;
 118   m_hScrollBar = (wxScrollBar *) NULL;
 119   m_vScrollBar = (wxScrollBar *) NULL;
 120   m_horizontalSashCursor = (wxCursor *) NULL;
 121   m_verticalSashCursor = (wxCursor *) NULL;
 122   m_cellTextColour = *wxBLACK;
 123   m_cellBackgroundColour = *wxWHITE;
 124   m_labelTextColour = *wxBLACK;
 125 //  m_labelBackgroundColour = *wxLIGHT_GREY;
 126   m_labelBackgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
 127   m_labelBackgroundBrush = (wxBrush *) NULL;
 128   m_labelTextFont = wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxBOLD);
 129   m_cellTextFont = wxTheFontList->FindOrCreateFont(10, wxSWISS, wxNORMAL, wxNORMAL);
 130   m_textItem = (wxTextCtrl *) NULL;
 131   m_currentRectVisible = FALSE;
 132   m_editable = TRUE;
 133 #if defined(__WIN95__)
 134   m_scrollWidth = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X);
 135 #else
 136   m_scrollWidth = 16;
 137 #endif
 138   m_dragStatus = wxGRID_DRAG_NONE;
 139   m_dragRowOrCol = 0;
 140   m_dragStartPosition = 0;
 141   m_dragLastPosition = 0;
 142   m_divisionPen = wxThePenList->FindOrCreatePen("LIGHT GREY", 1, wxSOLID);
 143   m_doubleBufferingBitmap = (wxBitmap *) NULL;
 144
 145   if (!m_horizontalSashCursor)
 146   {
 147     m_horizontalSashCursor = new wxCursor(wxCURSOR_SIZEWE);
 148     m_verticalSashCursor = new wxCursor(wxCURSOR_SIZENS);
 149   }
 150
 151   SetLabelBackgroundColour(m_labelBackgroundColour);
 152
 153   m_leftOfSheet = wxGRID_DEFAULT_SHEET_LEFT;
 154   m_topOfSheet = wxGRID_DEFAULT_SHEET_TOP;
 155   m_cellHeight = wxGRID_DEFAULT_CELL_HEIGHT;
 156   m_totalGridWidth = 0;
 157   m_totalGridHeight = 0;
 158   m_colWidths = (short *) NULL;
 159   m_rowHeights = (short *) NULL;
 160
 161   m_verticalLabelWidth = wxGRID_DEFAULT_VERTICAL_LABEL_WIDTH;
 162   m_horizontalLabelHeight = wxGRID_DEFAULT_HORIZONAL_LABEL_HEIGHT;
 163   m_verticalLabelAlignment = wxCENTRE;
 164   m_horizontalLabelAlignment = wxCENTRE;
 165   m_editControlPosition.x = wxGRID_DEFAULT_EDIT_X;
 166   m_editControlPosition.y = wxGRID_DEFAULT_EDIT_Y;
 167   m_editControlPosition.width = wxGRID_DEFAULT_EDIT_WIDTH;
 168   m_editControlPosition.height = wxGRID_DEFAULT_EDIT_HEIGHT;
 169
 170   m_wCursorRow = 0;
 171   m_wCursorColumn = 0;
 172
 173   m_scrollPosX = 0;
 174   m_scrollPosY = 0;
 175
 176   /* Store the rect. coordinates for the current cell */
 177   SetCurrentRect(m_wCursorRow, m_wCursorColumn);
 178
 179   m_editCreated = FALSE;
 180
 181   m_totalRows = 0;
 182   m_totalCols = 0;
 183   m_gridCells = (wxGridCell ***) NULL;
 184   m_rowLabelCells = (wxGridCell **) NULL;
 185   m_colLabelCells = (wxGridCell **) NULL;
 186   m_textItem = (wxTextCtrl *) NULL;
 187
 188   wxPanel::Create(parent, id, pos, size, style, name);
 189
 190   m_editingPanel = new wxPanel(this);
 191
 192   m_textItem = new wxTextCtrl(m_editingPanel, wxGRID_TEXT_CTRL, "",
 193      wxPoint(m_editControlPosition.x, m_editControlPosition.y), wxSize(m_editControlPosition.width, -1),
 194      0);
 195   m_textItem->Show(TRUE);
 196   m_textItem->SetFocus();
 197   int controlW, controlH;
 198
 199   m_textItem->GetSize(&controlW, &controlH);
 200   m_editControlPosition.height = controlH;
 201
 202   m_topOfSheet = m_editControlPosition.y + controlH + 2;
 203
 204   m_editCreated = TRUE;
 205
 206   m_hScrollBar = new wxScrollBar(this, wxGRID_HSCROLL, wxPoint(0, 0), wxSize(20, 100), wxHORIZONTAL);
 207   m_vScrollBar = new wxScrollBar(this, wxGRID_VSCROLL, wxPoint(0, 0), wxSize(100, 20), wxVERTICAL);
 208
 209   return TRUE;
 210 }
 211
 212 wxGenericGrid::~wxGenericGrid(void)
 213 {
 214   ClearGrid();
 215 }
 216
 217 void wxGenericGrid::ClearGrid(void)
 218 {
 219   int i,j;
 220   if (m_gridCells)
 221   {
 222     for (i = 0; i < m_totalRows; i++)
 223     {
 224       for (j = 0; j < m_totalCols; j++)
 225         if (m_gridCells[i][j])
 226           delete m_gridCells[i][j];
 227       delete[] m_gridCells[i];
 228     }
 229     delete[] m_gridCells;
 230     m_gridCells = (wxGridCell ***) NULL;
 231   }
 232   if (m_colWidths)
 233     delete[] m_colWidths;
 234   m_colWidths = (short *) NULL;
 235   if (m_rowHeights)
 236     delete[] m_rowHeights;
 237   m_rowHeights = (short *) NULL;
 238
 239   if (m_rowLabelCells)
 240   {
 241     for (i = 0; i < m_totalRows; i++)
 242       delete m_rowLabelCells[i];
 243     delete[] m_rowLabelCells;
 244     m_rowLabelCells = (wxGridCell **) NULL;
 245   }
 246   if (m_colLabelCells)
 247   {
 248     for (i = 0; i < m_totalCols; i++)
 249       delete m_colLabelCells[i];
 250     delete[] m_colLabelCells;
 251     m_colLabelCells = (wxGridCell **) NULL;
 252   }
 253   if (m_doubleBufferingBitmap)
 254   {
 255     delete m_doubleBufferingBitmap;
 256     m_doubleBufferingBitmap = (wxBitmap *) NULL;
 257   }
 258 }
 259
 260 bool wxGenericGrid::CreateGrid(int nRows, int nCols, wxString **cellValues, short *widths,
 261      short defaultWidth, short defaultHeight)
 262 {
 263   m_totalRows = nRows;
 264   m_totalCols = nCols;
 265
 266   int i,j;
 267   m_colWidths = new short[nCols];
 268   m_rowHeights = new short[nRows];
 269   for (i = 0; i < nCols; i++)
 270     if (widths)
 271       m_colWidths[i] = widths[i];
 272     else
 273       m_colWidths[i] = defaultWidth;
 274   for (i = 0; i < nRows; i++)
 275     m_rowHeights[i] = defaultHeight;
 276
 277   m_gridCells = new wxGridCell **[nRows];
 278
 279   for (i = 0; i < nRows; i++)
 280     m_gridCells[i] = new wxGridCell *[nCols];
 281
 282   for (i = 0; i < nRows; i++)
 283     for (j = 0; j < nCols; j++)
 284       if (cellValues)
 285       {
 286         m_gridCells[i][j] = OnCreateCell();
 287         m_gridCells[i][j]->SetTextValue(cellValues[i][j]);
 288       }
 289       else
 290         m_gridCells[i][j] = (wxGridCell *) NULL;
 291
 292   m_rowLabelCells = new wxGridCell *[nRows];
 293   for (i = 0; i < nRows; i++)
 294     m_rowLabelCells[i] = new wxGridCell(this);
 295   m_colLabelCells = new wxGridCell *[nCols];
 296   for (i = 0; i < nCols; i++)
 297     m_colLabelCells[i] = new wxGridCell(this);
 298
 299   m_wCursorRow = m_wCursorColumn = 0;
 300   SetCurrentRect(0, 0);
 301
 302   // Need to determine various dimensions
 303   UpdateDimensions();
 304
 305   // Number of 'lines'
 306   int objectSizeX = m_totalCols;
 307   int pageSizeX = 1;
 308   int viewLengthX = m_totalCols;
 309
 310 /*
 311   m_hScrollBar->SetViewLength(viewLengthX);
 312   m_hScrollBar->SetObjectLength(objectSizeX);
 313   m_hScrollBar->SetPageSize(pageSizeX);
 314 */
 315   m_hScrollBar->SetScrollbar(m_hScrollBar->GetPosition(), pageSizeX, objectSizeX, viewLengthX);
 316
 317   int objectSizeY = m_totalRows;
 318   int pageSizeY = 1;
 319   int viewLengthY = m_totalRows;
 320
 321 /*
 322   m_vScrollBar->SetViewLength(viewLengthY);
 323   m_vScrollBar->SetObjectLength(objectSizeY);
 324   m_vScrollBar->SetPageSize(pageSizeY);
 325 */
 326
 327   m_vScrollBar->SetScrollbar(m_vScrollBar->GetPosition(), pageSizeY, objectSizeY, viewLengthY);
 328
 329   AdjustScrollbars();
 330
 331   OnChangeLabels();
 332   OnChangeSelectionLabel();
 333
 334   return TRUE;
 335 }
 336
 337 // Need to determine various dimensions
 338 void wxGenericGrid::UpdateDimensions(void)
 339 {
 340   int canvasWidth, canvasHeight;
 341   GetSize(&canvasWidth, &canvasHeight);
 342
 343   if (m_editCreated && m_editable)
 344   {
 345     int controlW, controlH;
 346     GetTextItem()->GetSize(&controlW, &controlH);
 347     m_topOfSheet = m_editControlPosition.y + controlH + 2;
 348   }
 349   else
 350     m_topOfSheet = 0;
 351   m_rightOfSheet = m_leftOfSheet + m_verticalLabelWidth;
 352   int i;
 353   for (i = m_scrollPosX; i < m_totalCols; i++)
 354   {
 355     if (m_rightOfSheet > canvasWidth)
 356       break;
 357     else
 358       m_rightOfSheet += m_colWidths[i];
 359   }
 360   m_bottomOfSheet = m_topOfSheet + m_horizontalLabelHeight;
 361   for (i = m_scrollPosY; i < m_totalRows; i++)
 362   {
 363     if (m_bottomOfSheet > canvasHeight)
 364       break;
 365     else
 366       m_bottomOfSheet += m_rowHeights[i];
 367   }
 368
 369   m_totalGridWidth = m_leftOfSheet + m_verticalLabelWidth;
 370   for (i = 0; i < m_totalCols; i++)
 371   {
 372     m_totalGridWidth += m_colWidths[i];
 373   }
 374   m_totalGridHeight = m_topOfSheet + m_horizontalLabelHeight;
 375   for (i = 0; i < m_totalRows; i++)
 376   {
 377     m_totalGridHeight += m_rowHeights[i];
 378   }
 379 }
 380
 381 wxGridCell *wxGenericGrid::GetCell(int row, int col)
 382 {
 383   if (!m_gridCells)
 384     return (wxGridCell *) NULL;
 385
 386   if ((row >= m_totalRows) || (col >= m_totalCols))
 387     return (wxGridCell *) NULL;
 388
 389   wxGridCell *cell = m_gridCells[row][col];
 390   if (!cell)
 391   {
 392     m_gridCells[row][col] = OnCreateCell();
 393     return m_gridCells[row][col];
 394   }
 395   else
 396     return cell;
 397 }
 398
 399 void wxGenericGrid::SetGridClippingRegion(wxDC *dc)
 400 {
 401   int m_scrollWidthHoriz = 0;
 402   int m_scrollWidthVert = 0;
 403   int cw, ch;
 404   GetClientSize(&cw, &ch);
 405
 406   if (m_hScrollBar && m_hScrollBar->IsShown())
 407     m_scrollWidthHoriz = m_scrollWidth;
 408   if (m_vScrollBar && m_vScrollBar->IsShown())
 409     m_scrollWidthVert = m_scrollWidth;
 410
 411   // Don't paint over the scrollbars
 412   dc->SetClippingRegion(m_leftOfSheet, m_topOfSheet,
 413      cw - m_scrollWidthVert - m_leftOfSheet, ch - m_scrollWidthHoriz - m_topOfSheet);
 414 }
 415
 416 void wxGenericGrid::OnPaint(wxPaintEvent& WXUNUSED(event))
 417 {
 418   int w, h;
 419   GetClientSize(&w, &h);
 420
 421   bool useDoubleBuffering = (bool) USE_DOUBLE_BUFFERING;
 422   if (useDoubleBuffering)
 423   {
 424     // Reuse the old bitmap if possible
 425
 426     if (!m_doubleBufferingBitmap ||
 427        (m_doubleBufferingBitmap->GetWidth() < w || m_doubleBufferingBitmap->GetHeight() < h))
 428     {
 429         if (m_doubleBufferingBitmap)
 430             delete m_doubleBufferingBitmap;
 431         m_doubleBufferingBitmap = new wxBitmap(w, h);
 432     }
 433     if (!m_doubleBufferingBitmap || !m_doubleBufferingBitmap->Ok())
 434     {
 435         // If we couldn't create a new bitmap, perhaps because resources were low,
 436         // then don't complain, just don't double-buffer
 437         if (m_doubleBufferingBitmap)
 438             delete m_doubleBufferingBitmap;
 439         m_doubleBufferingBitmap = (wxBitmap *) NULL;
 440         useDoubleBuffering = FALSE;
 441     }
 442   }
 443
 444   if (useDoubleBuffering)
 445   {
 446     wxPaintDC paintDC(this);
 447     wxMemoryDC dc(& paintDC);
 448     dc.SelectObject(* m_doubleBufferingBitmap);
 449
 450     PaintGrid(dc);
 451
 452     int vertScrollBarWidth = m_scrollWidth;
 453     int horizScrollBarHeight = m_scrollWidth;
 454     if (m_vScrollBar && !m_vScrollBar->IsShown())
 455       vertScrollBarWidth = 0;
 456     if (m_hScrollBar && !m_hScrollBar->IsShown())
 457       horizScrollBarHeight = 0;
 458
 459     paintDC.Blit(m_leftOfSheet, m_topOfSheet, w - vertScrollBarWidth - m_leftOfSheet, h - horizScrollBarHeight - m_topOfSheet,
 460       &dc, m_leftOfSheet, m_topOfSheet, wxCOPY);
 461
 462     dc.SelectObject(wxNullBitmap);
 463   }
 464   else
 465   {
 466     wxPaintDC dc(this);
 467     PaintGrid(dc);
 468   }
 469 }
 470
 471 void wxGenericGrid::PaintGrid(wxDC& dc)
 472 {
 473     dc.BeginDrawing();
 474     dc.SetOptimization(FALSE);
 475
 476     SetGridClippingRegion(& dc);
 477
 478     DrawLabelAreas(& dc);
 479
 480     DrawEditableArea(& dc);
 481     DrawColumnLabels(& dc);
 482     DrawRowLabels(& dc);
 483     DrawCells(& dc);
 484     DrawGridLines(& dc);
 485
 486     /* Hilight present cell */
 487     SetCurrentRect(m_wCursorRow, m_wCursorColumn);
 488     if (m_currentRectVisible)
 489       HighlightCell(& dc);
 490
 491     dc.DestroyClippingRegion();
 492     dc.SetOptimization(TRUE);
 493     dc.EndDrawing();
 494 }
 495
 496 // Erase (some of) the background.
 497 // Currently, a Windows-only optimisation.
 498 void wxGenericGrid::OnEraseBackground(wxEraseEvent& WXUNUSED(event) )
 499 {
 500     wxClientDC dc(this);
 501     dc.BeginDrawing();
 502     dc.SetOptimization(FALSE);
 503
 504     int w, h;
 505     GetClientSize(& w, & h);
 506     dc.SetBrush(*wxLIGHT_GREY_BRUSH);
 507     dc.SetPen(*wxLIGHT_GREY_PEN);
 508
 509     if (m_hScrollBar && m_hScrollBar->IsShown() && m_vScrollBar && m_vScrollBar->IsShown())
 510     {
 511         dc.DrawRectangle(w - m_scrollWidth, h - m_scrollWidth, m_scrollWidth, m_scrollWidth);
 512     }
 513
 514     dc.SetOptimization(TRUE);
 515     dc.EndDrawing();
 516 }
 517
 518
 519 void wxGenericGrid::DrawLabelAreas(wxDC *dc)
 520 {
 521   int cw, ch;
 522   GetClientSize(&cw, &ch);
 523
 524   dc->SetPen(*wxTRANSPARENT_PEN);
 525 //  dc->SetBrush(*dc->GetBackground());
 526
 527   // Should blank out any area which isn't going to be painted over.
 528 //  dc->DrawRectangle(m_leftOfSheet, m_bottomOfSheet, cw - m_leftOfSheet, ch - m_bottomOfSheet);
 529 //  dc->DrawRectangle(m_rightOfSheet, m_topOfSheet, cw - m_rightOfSheet, ch - m_topOfSheet);
 530
 531   // Paint the label areas
 532   dc->SetBrush(*m_labelBackgroundBrush);
 533 //  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_rightOfSheet - m_leftOfSheet + 1, m_horizontalLabelHeight + 1);
 534   dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, cw-m_leftOfSheet, m_horizontalLabelHeight + 1);
 535 //  dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_verticalLabelWidth + 1, m_bottomOfSheet - m_topOfSheet + 1);
 536   dc->DrawRectangle(m_leftOfSheet, m_topOfSheet, m_verticalLabelWidth + 1, ch-m_topOfSheet);
 537 }
 538
 539 void wxGenericGrid::DrawEditableArea(wxDC *dc)
 540 {
 541   int cw, ch;
 542   GetClientSize(&cw, &ch);
 543
 544   dc->SetPen(*wxTRANSPARENT_PEN);
 545   dc->SetBrush(*wxTheBrushList->FindOrCreateBrush(m_cellBackgroundColour, wxSOLID));
 546 //  dc->DrawRectangle(m_leftOfSheet+m_verticalLabelWidth, m_topOfSheet+m_horizontalLabelHeight,
 547 //      m_rightOfSheet-(m_leftOfSheet+m_verticalLabelWidth) + 1, m_bottomOfSheet - (m_topOfSheet+m_horizontalLabelHeight) + 1);
 548   dc->DrawRectangle(m_leftOfSheet+m_verticalLabelWidth, m_topOfSheet+m_horizontalLabelHeight,
 549       cw-(m_leftOfSheet+m_verticalLabelWidth), ch - (m_topOfSheet+m_horizontalLabelHeight));
 550 }
 551
 552 void wxGenericGrid::DrawGridLines(wxDC *dc)
 553 {
 554   int cw, ch;
 555   GetClientSize(&cw, &ch);
 556
 557   int i;
 558
 559   if (m_divisionPen)
 560   {
 561     dc->SetPen(*m_divisionPen);
 562
 563     int heightCount = m_topOfSheet + m_horizontalLabelHeight;
 564
 565     // Draw horizontal grey lines for cells
 566     for (i = m_scrollPosY; i < (m_totalRows+1); i++)
 567     {
 568       if (heightCount > ch)
 569         break;
 570       else
 571       {
 572         dc->DrawLine(m_leftOfSheet, heightCount,
 573                    cw, heightCount);
 574         if (i < m_totalRows)
 575           heightCount += m_rowHeights[i];
 576       }
 577     }
 578   }
 579
 580   if (m_verticalLabelWidth > 0)
 581   {
 582     dc->SetPen(*wxBLACK_PEN);
 583
 584     // Draw horizontal black lines for row labels
 585     int heightCount = m_topOfSheet + m_horizontalLabelHeight;
 586     for (i = m_scrollPosY; i < (m_totalRows+1); i++)
 587     {
 588       if (heightCount > ch)
 589         break;
 590       else
 591       {
 592         dc->DrawLine(m_leftOfSheet, heightCount,
 593                      m_verticalLabelWidth, heightCount);
 594         if (i < m_totalRows)
 595           heightCount += m_rowHeights[i];
 596       }
 597     }
 598     // Draw a black vertical line for row number cells
 599     dc->DrawLine(m_leftOfSheet + m_verticalLabelWidth, m_topOfSheet,
 600       m_leftOfSheet + m_verticalLabelWidth, ch);
 601     // First vertical line
 602     dc->DrawLine(m_leftOfSheet, m_topOfSheet, m_leftOfSheet, ch);
 603
 604     dc->SetPen(*wxWHITE_PEN);
 605
 606     // Draw highlights on row labels
 607     heightCount = m_topOfSheet + m_horizontalLabelHeight;
 608     for (i = m_scrollPosY; i < m_totalRows; i++)
 609     {
 610       if (heightCount > ch)
 611         break;
 612       else
 613       {
 614         dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 615                      m_verticalLabelWidth, heightCount+1);
 616         dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 617                      m_leftOfSheet+1, heightCount + m_rowHeights[i] - 1);
 618         heightCount += m_rowHeights[i];
 619       }
 620     }
 621     // Last one - down to the floor.
 622     dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 623                  m_verticalLabelWidth, heightCount+1);
 624     dc->DrawLine(m_leftOfSheet+1, heightCount+1,
 625                    m_leftOfSheet+1, ch);
 626
 627   }
 628
 629   if (m_divisionPen)
 630   {
 631     dc->SetPen(*m_divisionPen);
 632
 633     // Draw vertical grey lines for cells
 634     int widthCount = m_leftOfSheet + m_verticalLabelWidth;
 635     for (i = m_scrollPosX; i < m_totalCols; i++)
 636     {
 637       if (widthCount > cw)
 638         break;
 639       else
 640       {
 641         // Skip the first one
 642         if (i != m_scrollPosX)
 643         {
 644          dc->DrawLine(widthCount, m_topOfSheet + m_horizontalLabelHeight,
 645                        widthCount, m_bottomOfSheet);
 646         }
 647         widthCount += m_colWidths[i];
 648       }
 649     }
 650     // Last one
 651     dc->DrawLine(widthCount, m_topOfSheet + m_horizontalLabelHeight,
 652                     widthCount, m_bottomOfSheet);
 653   }
 654
 655   dc->SetPen(*wxBLACK_PEN);
 656
 657   // Draw two black horizontal lines for column number cells
 658   dc->DrawLine(
 659           m_leftOfSheet, m_topOfSheet,
 660           cw, m_topOfSheet);
 661   dc->DrawLine(m_leftOfSheet,  m_topOfSheet + m_horizontalLabelHeight,
 662                cw, m_topOfSheet + m_horizontalLabelHeight);
 663
 664   if (m_horizontalLabelHeight > 0)
 665   {
 666     int widthCount = m_leftOfSheet + m_verticalLabelWidth;
 667
 668     // Draw black vertical lines for column number cells
 669     for (i = m_scrollPosX; i < m_totalCols; i++)
 670     {
 671       if (widthCount > cw)
 672         break;
 673       else
 674       {
 675         dc->DrawLine(widthCount, m_topOfSheet,
 676                       widthCount, m_topOfSheet + m_horizontalLabelHeight);
 677         widthCount += m_colWidths[i];
 678       }
 679     }
 680
 681     // Last one
 682     dc->DrawLine(widthCount, m_topOfSheet,
 683                     widthCount, m_topOfSheet + m_horizontalLabelHeight);
 684
 685     // Draw highlights
 686     dc->SetPen(*wxWHITE_PEN);
 687     widthCount = m_leftOfSheet + m_verticalLabelWidth;
 688
 689     for (i = m_scrollPosX; i < m_totalCols; i++)
 690     {
 691       if (widthCount > cw)
 692         break;
 693       else
 694       {
 695         dc->DrawLine(widthCount+1, m_topOfSheet+1,
 696                      widthCount+m_colWidths[i], m_topOfSheet+1);
 697         dc->DrawLine(widthCount+1, m_topOfSheet+1,
 698                      widthCount+1, m_topOfSheet+m_horizontalLabelHeight);
 699         widthCount += m_colWidths[i];
 700       }
 701     }
 702     // Last one - to the right side of the canvas.
 703     dc->DrawLine(widthCount+1, m_topOfSheet+1,
 704                    cw, m_topOfSheet+1);
 705     dc->DrawLine(widthCount+1, m_topOfSheet+1,
 706                    widthCount+1, m_topOfSheet+m_horizontalLabelHeight);
 707
 708   }
 709 }
 710
 711 void wxGenericGrid::DrawColumnLabels(wxDC *dc)
 712 {
 713   int cw, ch;
 714   GetClientSize(&cw, &ch);
 715
 716   if (m_horizontalLabelHeight == 0)
 717     return;
 718
 719   int i;
 720   wxRectangle rect;
 721
 722   // Draw letters for columns
 723   rect.y = m_topOfSheet + 1;
 724   rect.height = m_horizontalLabelHeight - 1;
 725
 726   dc->SetTextBackground(m_labelBackgroundColour);
 727   dc->SetBackgroundMode(wxTRANSPARENT);
 728 //  dc->SetTextForeground(m_labelTextColour);
 729
 730   int widthCount = m_leftOfSheet + m_verticalLabelWidth;
 731   for (i = m_scrollPosX; i < m_totalCols; i++)
 732   {
 733      if (widthCount > cw)
 734        break;
 735      else
 736      {
 737        rect.x = 1 + widthCount;
 738        rect.width = m_colWidths[i];
 739        DrawColumnLabel(dc, &rect, i);
 740
 741        widthCount += m_colWidths[i];
 742      }
 743   }
 744 }
 745
 746 void wxGenericGrid::DrawColumnLabel(wxDC *dc, wxRectangle *rect, int col)
 747 {
 748   wxGridCell *cell = GetLabelCell(wxHORIZONTAL, col);
 749   if (cell)
 750   {
 751     wxRectangle rect2;
 752     rect2 = *rect;
 753     rect2.x += 3;
 754     rect2.y += 2;
 755     rect2.width -= 5;
 756     rect2.height -= 4;
 757     dc->SetTextForeground(GetLabelTextColour());
 758     dc->SetFont(*GetLabelTextFont());
 759         if ( !cell->GetTextValue().IsNull() )
 760         DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxHORIZONTAL));
 761   }
 762 }
 763
 764 void wxGenericGrid::DrawRowLabels(wxDC *dc)
 765 {
 766   int cw, ch;
 767   GetClientSize(&cw, &ch);
 768
 769   if (m_verticalLabelWidth == 0)
 770     return;
 771
 772   int i;
 773   wxRectangle rect;
 774
 775   // Draw numbers for rows
 776   rect.x = m_leftOfSheet;
 777   rect.width = m_verticalLabelWidth;
 778
 779   int heightCount = m_topOfSheet + m_horizontalLabelHeight;
 780
 781   dc->SetTextBackground(m_labelBackgroundColour);
 782   dc->SetBackgroundMode(wxTRANSPARENT);
 783
 784   for (i = m_scrollPosY; i < m_totalRows; i++)
 785   {
 786      if (heightCount > ch)
 787        break;
 788      else
 789      {
 790        rect.y = 1 + heightCount;
 791        rect.height = m_rowHeights[i];
 792        DrawRowLabel(dc, &rect, i);
 793
 794        heightCount += m_rowHeights[i];
 795      }
 796   }
 797 }
 798
 799 void wxGenericGrid::DrawRowLabel(wxDC *dc, wxRectangle *rect, int row)
 800 {
 801   wxGridCell *cell = GetLabelCell(wxVERTICAL, row);
 802   if (cell)
 803   {
 804     wxRectangle rect2;
 805     rect2 = *rect;
 806     rect2.x += 3;
 807     rect2.y += 2;
 808     rect2.width -= 5;
 809     rect2.height -= 4;
 810     dc->SetTextForeground(GetLabelTextColour());
 811     dc->SetFont(*GetLabelTextFont());
 812         if ( !cell->GetTextValue().IsNull() )
 813         DrawTextRect(dc, cell->GetTextValue(), &rect2, GetLabelAlignment(wxVERTICAL));
 814   }
 815 }
 816
 817 void wxGenericGrid::DrawCells(wxDC *dc)
 818 {
 819   int cw, ch;
 820   GetClientSize(&cw, &ch);
 821
 822   int i,j;
 823
 824   // Draw value corresponding to each cell
 825   for (i = m_scrollPosY; i < m_totalRows; i++)
 826   {
 827     for (j = m_scrollPosX; j < m_totalCols; j++)
 828     {
 829       SetCurrentRect(i, j, cw, ch);
 830       if (m_currentRectVisible)
 831       {
 832         DrawCellBackground(dc, &m_currentRect, i, j);
 833         DrawCellValue(dc, &m_currentRect, i, j);
 834       }
 835       if (m_currentRect.x > cw)
 836         break;
 837     }
 838     if (m_currentRect.y > ch)
 839       break;
 840   }
 841   dc->SetBackgroundMode(wxSOLID);
 842   dc->SetPen(*wxBLACK_PEN);
 843 }
 844
 845 void wxGenericGrid::DrawCellBackground(wxDC *dc, wxRectangle *rect, int row, int col)
 846 {
 847   wxGridCell *cell = GetCell(row, col);
 848   if (cell)
 849   {
 850     dc->SetBrush(*cell->GetBackgroundBrush());
 851     dc->SetPen(*wxTRANSPARENT_PEN);
 852
 853 #if 0    // In wxWin 2.0 the dc code is exact. RR.
 854 #ifdef __WXMOTIF__
 855     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width-1, rect->height-1);
 856 #else
 857     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width, rect->height);
 858 #endif
 859 #endif
 860
 861     dc->DrawRectangle(rect->x+1, rect->y+1, rect->width-1, rect->height-1);
 862
 863     dc->SetPen(*wxBLACK_PEN);
 864   }
 865 }
 866
 867 void wxGenericGrid::DrawCellValue(wxDC *dc, wxRectangle *rect, int row, int col)
 868 {
 869   wxGridCell *cell = GetCell(row, col);
 870   if (cell)
 871   {
 872     wxBitmap *bitmap = cell->GetCellBitmap();
 873     wxRectangle rect2;
 874     rect2 = *rect;
 875     rect2.x += 3;
 876     rect2.y += 2;
 877     rect2.width -= 5;
 878     rect2.height -= 4;
 879
 880     if (bitmap)
 881     {
 882       DrawBitmapRect(dc, bitmap, &rect2, cell->GetAlignment());
 883     }
 884     else
 885     {
 886       dc->SetBackgroundMode(wxTRANSPARENT);
 887       dc->SetTextForeground(cell->GetTextColour());
 888       dc->SetFont(*cell->GetFont());
 889
 890           if ( !cell->GetTextValue().IsNull() )
 891         DrawTextRect(dc, cell->GetTextValue(), &rect2, cell->GetAlignment());
 892     }
 893   }
 894 }
 895
 896 void wxGenericGrid::AdjustScrollbars(void)
 897 {
 898   int cw, ch;
 899   GetClientSize(&cw, &ch);
 900
 901   // To calculate the number of steps for each scrollbar,
 902   // we need to see how much will fit onto the canvas
 903   // at the present size. So:
 904   // 1) Find the *last* row r1 such that when it's at the top of the
 905   //    window, all the remaining rows are visible.
 906   // 2) There should therefore be r1 - 1 steps in the scrollbar.
 907   // Similarly with columns.
 908
 909   // IGNORE THE ABOVE, it's crap.
 910   // We find the view size by seeing how many rows/cols fit on
 911   // the current view.
 912   // BUT... this means that the scrollbar should be adjusted every time
 913   // it's scrolled, as well as when sized, because with variable size rows/cols,
 914   // the number of rows/col visible on the view differs according to what bit
 915   // you're looking at. The object length is always the same, but the
 916   // view length differs.
 917
 918   // Since this may not be known until the end of this function, we should probably call AdjustScrollbars
 919   // twice.
 920   int vertScrollBarWidth = m_scrollWidth;
 921   int horizScrollBarHeight = m_scrollWidth;
 922   if (m_vScrollBar && !m_vScrollBar->IsShown())
 923     vertScrollBarWidth = 0;
 924   if (m_hScrollBar && !m_hScrollBar->IsShown())
 925     horizScrollBarHeight = 0;
 926
 927   int noHorizSteps = 0;
 928   int noVertSteps = 0;
 929
 930   if (m_totalGridWidth <= cw)
 931     noHorizSteps = 0;
 932   else
 933   {
 934     noHorizSteps = 0;
 935     int widthCount = 0;
 936 /*
 937     if (GetLabelSize(wxVERTICAL) > 0)
 938       noHorizSteps ++;
 939 */
 940
 941     int i;
 942         int nx = 0;
 943     for (i = m_scrollPosX ; i < m_totalCols; i++)
 944     {
 945       widthCount += m_colWidths[i];
 946           // A partial bit doesn't count, we still have to scroll to see the
 947           // rest of it
 948       if (widthCount + m_leftOfSheet + m_verticalLabelWidth > (cw-vertScrollBarWidth))
 949         break;
 950           else
 951             nx ++;
 952
 953     }
 954
 955     noHorizSteps += nx;
 956   }
 957   if (m_totalGridHeight <= ch)
 958     noVertSteps = 0;
 959   else
 960   {
 961     noVertSteps = 0;
 962     int heightCount = 0;
 963 /*
 964     if (GetLabelSize(wxHORIZONTAL) > 0)
 965       noVertSteps ++;
 966 */
 967
 968     int i;
 969         int ny = 0;
 970     for (i = m_scrollPosY ; i < m_totalRows; i++)
 971     {
 972       heightCount += m_rowHeights[i];
 973           // A partial bit doesn't count, we still have to scroll to see the
 974           // rest of it
 975       if (heightCount + m_topOfSheet + m_horizontalLabelHeight > (ch-horizScrollBarHeight))
 976         break;
 977           else
 978             ny ++;
 979     }
 980
 981     noVertSteps += ny;
 982   }
 983
 984   if (m_totalGridWidth <= cw)
 985   {
 986         if ( m_hScrollBar )
 987         m_hScrollBar->Show(FALSE);
 988     SetScrollPosX(0);
 989   }
 990   else
 991   {
 992         if ( m_hScrollBar )
 993         m_hScrollBar->Show(TRUE);
 994   }
 995
 996   if (m_totalGridHeight <= ch)
 997   {
 998         if ( m_vScrollBar )
 999         m_vScrollBar->Show(FALSE);
1000     SetScrollPosY(0);
1001   }
1002   else
1003   {
1004         if ( m_vScrollBar )
1005         m_vScrollBar->Show(TRUE);
1006   }
1007
1008   UpdateDimensions(); // Necessary in case m_scrollPosX/Y changed
1009
1010   vertScrollBarWidth = m_scrollWidth;
1011   horizScrollBarHeight = m_scrollWidth;
1012   if (m_vScrollBar && !m_vScrollBar->IsShown())
1013     vertScrollBarWidth = 0;
1014   if (m_hScrollBar && !m_hScrollBar->IsShown())
1015     horizScrollBarHeight = 0;
1016
1017   if (m_hScrollBar)
1018   {
1019     int nCols = GetCols();
1020 /*
1021     m_hScrollBar->SetPageSize(wxMax(noHorizSteps, 1));
1022     m_hScrollBar->SetViewLength(wxMax(noHorizSteps, 1));
1023     m_hScrollBar->SetObjectLength(nCols);
1024 */
1025     m_hScrollBar->SetScrollbar(m_hScrollBar->GetPosition(), wxMax(noHorizSteps, 1), nCols, wxMax(noHorizSteps, 1));
1026
1027     m_hScrollBar->SetSize(m_leftOfSheet, ch - m_scrollWidth -2,
1028       cw - vertScrollBarWidth - m_leftOfSheet, m_scrollWidth);
1029   }
1030
1031   if (m_vScrollBar)
1032   {
1033     int nRows = GetRows();
1034 /*
1035     m_vScrollBar->SetPageSize(wxMax(noVertSteps, 1));
1036     m_vScrollBar->SetViewLength(wxMax(noVertSteps, 1));
1037     m_vScrollBar->SetObjectLength(nRows);
1038 */
1039
1040     m_vScrollBar->SetScrollbar(m_vScrollBar->GetPosition(), wxMax(noVertSteps, 1), nRows, wxMax(noVertSteps, 1));
1041     m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
1042        m_scrollWidth, ch - m_topOfSheet - horizScrollBarHeight);
1043   }
1044 }
1045
1046 void wxGenericGrid::OnSize(wxSizeEvent& WXUNUSED(event) )
1047 {
1048   if (!m_vScrollBar || !m_hScrollBar)
1049           return;
1050
1051   AdjustScrollbars();
1052
1053   int cw, ch;
1054   GetClientSize(&cw, &ch);
1055
1056   if (m_editCreated && m_editingPanel && GetTextItem() && GetTextItem()->IsShown())
1057   {
1058     m_editingPanel->SetSize(0, 0, cw, m_editControlPosition.height + m_editControlPosition.y + 2);
1059     GetTextItem()->SetSize(m_editControlPosition.x, m_editControlPosition.y,
1060       cw - m_editControlPosition.x, m_editControlPosition.height);
1061   }
1062 }
1063
1064 bool wxGenericGrid::CellHitTest(int x, int y, int *row, int *col)
1065 {
1066       // Find the selected cell and call OnSelectCell
1067       if (x >= (m_leftOfSheet + m_verticalLabelWidth) && y >= (m_topOfSheet + m_horizontalLabelHeight) &&
1068           x <= m_rightOfSheet && y <= m_bottomOfSheet)
1069       {
1070          // Calculate the cell number from x and y
1071          x -= (m_verticalLabelWidth + m_leftOfSheet);
1072          y -= (m_topOfSheet + m_horizontalLabelHeight);
1073
1074          int i;
1075
1076          // Now we need to do a hit test for which row we're on
1077          int currentHeight = 0;
1078          for (i = m_scrollPosY; i < m_totalRows; i++)
1079          {
1080             if (y >= currentHeight && y <= (currentHeight + m_rowHeights[i]))
1081             {
1082               *row = i;
1083               break;
1084             }
1085             currentHeight += m_rowHeights[i];
1086          }
1087
1088          // Now we need to do a hit test for which column we're on
1089          int currentWidth = 0;
1090          for (i = m_scrollPosX; i < m_totalCols; i++)
1091          {
1092             if (x >= currentWidth && x <= (currentWidth + m_colWidths[i]))
1093             {
1094               *col = i;
1095               break;
1096             }
1097             currentWidth += m_colWidths[i];
1098          }
1099          return TRUE;
1100        }
1101   return FALSE;
1102 }
1103
1104 bool wxGenericGrid::LabelSashHitTest(int x, int y, int *orientation, int *rowOrCol, int *startPos)
1105 {
1106   int i;
1107   int tolerance = 3;
1108
1109   if (x >= (m_leftOfSheet + m_verticalLabelWidth) && y >= m_topOfSheet &&
1110       x <= m_rightOfSheet && y <= (m_topOfSheet + m_horizontalLabelHeight))
1111   {
1112     // We may be on a column label sash.
1113     int currentWidth = m_leftOfSheet + m_verticalLabelWidth;
1114     for (i = m_scrollPosX; i < m_totalCols; i++)
1115     {
1116       if (x >= (currentWidth + m_colWidths[i] - tolerance) && x <= (currentWidth + m_colWidths[i] + tolerance))
1117       {
1118         *orientation = wxHORIZONTAL;
1119         *rowOrCol = i;
1120         *startPos = currentWidth;
1121         return TRUE;
1122       }
1123       currentWidth += m_colWidths[i];
1124     }
1125     return FALSE;
1126   }
1127   else if (x >= m_leftOfSheet && y >= (m_topOfSheet + m_horizontalLabelHeight) &&
1128       x <= (m_leftOfSheet + m_verticalLabelWidth) && y <= m_bottomOfSheet)
1129   {
1130     // We may be on a row label sash.
1131     int currentHeight = m_topOfSheet + m_horizontalLabelHeight;
1132     for (i = m_scrollPosY; i < m_totalRows; i++)
1133     {
1134       if (y >= (currentHeight + m_rowHeights[i] - tolerance) && y <= (currentHeight + m_rowHeights[i] + tolerance))
1135       {
1136         *orientation = wxVERTICAL;
1137         *rowOrCol = i;
1138         *startPos = currentHeight;
1139         return TRUE;
1140       }
1141       currentHeight += m_rowHeights[i];
1142     }
1143     return FALSE;
1144   }
1145   return FALSE;
1146 }
1147
1148 bool wxGenericGrid::LabelHitTest(int x, int y, int *row, int *col)
1149 {
1150       // Find the selected label
1151       if (x >= m_leftOfSheet && y >= m_topOfSheet &&
1152           x <= m_rightOfSheet && y <= m_bottomOfSheet)
1153       {
1154          // Calculate the cell number from x and y
1155          x -= m_leftOfSheet;
1156          y -= m_topOfSheet;
1157
1158          int i;
1159
1160          // Now we need to do a hit test for which row we're on
1161          int currentHeight = m_horizontalLabelHeight;
1162          for (i = m_scrollPosY; i < m_totalRows; i++)
1163          {
1164             if (y >= currentHeight && y <= (currentHeight + m_rowHeights[i]))
1165             {
1166               *row = i;
1167               break;
1168             }
1169             currentHeight += m_rowHeights[i];
1170          }
1171          if (y >= 0 && y <= m_horizontalLabelHeight)
1172          {
1173              *row = -1;
1174          }
1175
1176          // Now we need to do a hit test for which column we're on
1177          int currentWidth = m_verticalLabelWidth;
1178          for (i = m_scrollPosX; i < m_totalCols; i++)
1179          {
1180             if (x >= currentWidth && x <= (currentWidth + m_colWidths[i]))
1181             {
1182               *col = i;
1183               break;
1184             }
1185             currentWidth += m_colWidths[i];
1186          }
1187          if (x >= 0 && x <= m_verticalLabelWidth)
1188          {
1189              *col = -1;
1190          }
1191
1192          if ((*col == -1) || (*row == -1))
1193          {
1194              return TRUE;
1195          }
1196        }
1197   return FALSE;
1198 }
1199
1200 void wxGenericGrid::OnMouseEvent(wxMouseEvent& ev)
1201 {
1202   if (ev.LeftDown())
1203   {
1204     wxClientDC dc(this);
1205     dc.BeginDrawing();
1206
1207     int row, col;
1208     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1209     {
1210       OnSelectCellImplementation(& dc, row, col);
1211       OnCellLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1212     }
1213     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1214     {
1215       OnLabelLeftClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1216     }
1217     dc.EndDrawing();
1218   }
1219   else if (ev.Dragging() && ev.LeftIsDown())
1220   {
1221     switch (m_dragStatus)
1222     {
1223       case wxGRID_DRAG_NONE:
1224       {
1225         int orientation;
1226         if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &m_dragRowOrCol, &m_dragStartPosition))
1227         {
1228           if (orientation == wxHORIZONTAL)
1229           {
1230             m_dragStatus = wxGRID_DRAG_LEFT_RIGHT;
1231             SetCursor(*m_horizontalSashCursor);
1232             m_dragLastPosition = (int)ev.GetX();
1233           }
1234           else
1235           {
1236             m_dragStatus = wxGRID_DRAG_UP_DOWN;
1237             SetCursor(*m_verticalSashCursor);
1238             m_dragLastPosition = (int)ev.GetY();
1239           }
1240           wxClientDC dc(this);
1241           dc.BeginDrawing();
1242           dc.SetLogicalFunction(wxINVERT);
1243           if (orientation == wxHORIZONTAL)
1244             dc.DrawLine((int)ev.GetX(), m_topOfSheet, (int)ev.GetX(), m_bottomOfSheet);
1245           else
1246             dc.DrawLine(m_leftOfSheet, (int)ev.GetY(), m_rightOfSheet, (int)ev.GetY());
1247           dc.EndDrawing();
1248
1249           CaptureMouse();
1250         }
1251         break;
1252       }
1253       case wxGRID_DRAG_LEFT_RIGHT:
1254       {
1255         wxClientDC dc(this);
1256         dc.BeginDrawing();
1257         dc.SetLogicalFunction(wxINVERT);
1258         dc.DrawLine(m_dragLastPosition, m_topOfSheet, m_dragLastPosition, m_bottomOfSheet);
1259
1260         dc.DrawLine((int)ev.GetX(), m_topOfSheet, (int)ev.GetX(), m_bottomOfSheet);
1261         dc.EndDrawing();
1262
1263         m_dragLastPosition = (int)ev.GetX();
1264         SetCursor(*m_horizontalSashCursor);
1265         break;
1266       }
1267       case wxGRID_DRAG_UP_DOWN:
1268       {
1269         wxClientDC dc(this);
1270         dc.BeginDrawing();
1271         dc.SetLogicalFunction(wxINVERT);
1272         dc.DrawLine(m_leftOfSheet, m_dragLastPosition, m_rightOfSheet, m_dragLastPosition);
1273
1274         dc.DrawLine(m_leftOfSheet, (int)ev.GetY(), m_rightOfSheet, (int)ev.GetY());
1275         dc.EndDrawing();
1276
1277         m_dragLastPosition = (int)ev.GetY();
1278         SetCursor(*m_verticalSashCursor);
1279         break;
1280       }
1281     }
1282   }
1283   else if (ev.Moving())
1284   {
1285     int rowOrCol, orientation, startPos;
1286     if (LabelSashHitTest((int)ev.GetX(), (int)ev.GetY(), &orientation, &rowOrCol, &startPos))
1287     {
1288       if (orientation == wxHORIZONTAL)
1289         SetCursor(*m_horizontalSashCursor);
1290        else
1291         SetCursor(*m_verticalSashCursor);
1292     }
1293     else
1294       SetCursor(*wxSTANDARD_CURSOR);
1295   }
1296   else if (ev.LeftUp())
1297   {
1298     switch (m_dragStatus)
1299     {
1300       case wxGRID_DRAG_LEFT_RIGHT:
1301       {
1302         wxClientDC dc(this);
1303         dc.BeginDrawing();
1304         dc.SetLogicalFunction(wxINVERT);
1305         dc.DrawLine(m_dragLastPosition, m_topOfSheet, m_dragLastPosition, m_bottomOfSheet);
1306         dc.SetLogicalFunction(wxCOPY);
1307         dc.EndDrawing();
1308
1309         ReleaseMouse();
1310         if (ev.GetX() > m_dragStartPosition)
1311         {
1312           m_colWidths[m_dragRowOrCol] = (short)(ev.GetX() - m_dragStartPosition);
1313           UpdateDimensions();
1314           AdjustScrollbars();
1315           Refresh();
1316         }
1317         SetCursor(*wxSTANDARD_CURSOR);
1318         int cw, ch;
1319         GetClientSize(&cw, &ch);
1320                 wxSizeEvent evt;
1321         OnSize(evt);
1322         break;
1323       }
1324       case wxGRID_DRAG_UP_DOWN:
1325       {
1326         wxClientDC dc(this);
1327         dc.BeginDrawing();
1328         dc.SetLogicalFunction(wxINVERT);
1329         dc.DrawLine(m_leftOfSheet, m_dragLastPosition, m_rightOfSheet, m_dragLastPosition);
1330         dc.SetLogicalFunction(wxCOPY);
1331         dc.EndDrawing();
1332
1333         ReleaseMouse();
1334         if (ev.GetY() > m_dragStartPosition)
1335         {
1336           m_rowHeights[m_dragRowOrCol] = (short)(ev.GetY() - m_dragStartPosition);
1337           UpdateDimensions();
1338           AdjustScrollbars();
1339           Refresh();
1340         }
1341         SetCursor(*wxSTANDARD_CURSOR);
1342         break;
1343       }
1344     }
1345     m_dragStatus = wxGRID_DRAG_NONE;
1346   }
1347   else if (ev.RightDown())
1348   {
1349     int row, col;
1350     if (CellHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1351     {
1352       OnCellRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1353     }
1354     if (LabelHitTest((int)ev.GetX(), (int)ev.GetY(), &row, &col))
1355     {
1356       OnLabelRightClick(row, col, (int)ev.GetX(), (int)ev.GetY(), ev.ControlDown(), ev.ShiftDown());
1357     }
1358   }
1359 }
1360
1361 void wxGenericGrid::OnSelectCellImplementation(wxDC *dc, int row, int col)
1362 {
1363   m_wCursorColumn = col;
1364   m_wCursorRow = row;
1365
1366   OnChangeSelectionLabel();
1367
1368   SetGridClippingRegion(dc);
1369
1370   // Remove the highlight from the old cell
1371   if (m_currentRectVisible)
1372      HighlightCell(dc);
1373
1374   // Highlight the new cell and copy its content to the edit control
1375   SetCurrentRect(m_wCursorRow, m_wCursorColumn);
1376   wxGridCell *cell = GetCell(m_wCursorRow, m_wCursorColumn);
1377   if (cell)
1378   {
1379         if ( cell->GetTextValue().IsNull() )
1380                 m_textItem->SetValue("");
1381         else
1382         m_textItem->SetValue(cell->GetTextValue());
1383   }
1384
1385   SetGridClippingRegion(dc);
1386
1387   // Why isn't this needed for Windows??
1388   // Probably because of the SetValue??
1389   // Arrrrrgh. This isn't needed anywhere, of course. RR.
1390 #ifndef __WXMSW__
1391 //  HighlightCell(dc);
1392 #endif
1393   dc->DestroyClippingRegion();
1394
1395   OnSelectCell(row, col);
1396 }
1397
1398 wxGridCell *wxGenericGrid::OnCreateCell(void)
1399 {
1400   return new wxGridCell(this);
1401 }
1402
1403 void wxGenericGrid::OnChangeLabels(void)
1404 {
1405   char buf[100];
1406   int i;
1407   for (i = 0; i < m_totalRows; i++)
1408   {
1409     sprintf(buf, "%d", i+1);
1410     SetLabelValue(wxVERTICAL, buf, i);
1411   }
1412   // A...Z,AA...ZZ,AAA...ZZZ, etc.
1413   for (i = 0; i < m_totalCols; i++)
1414   {
1415     int j;
1416     int noTimes = (i/26 + 1);
1417     int ch = (i % 26) + 65;
1418     buf[0] = 0;
1419     for (j = 0; j < noTimes; j++)
1420     {
1421       char buf2[20];
1422       sprintf(buf2, "%c", (char)ch);
1423       strcat(buf, buf2);
1424     }
1425     SetLabelValue(wxHORIZONTAL, buf, i);
1426   }
1427 }
1428
1429 void wxGenericGrid::OnChangeSelectionLabel(void)
1430 {
1431   if (!GetEditable())
1432     return;
1433
1434   wxString rowLabel(GetLabelValue(wxVERTICAL, GetCursorRow()));
1435   wxString colLabel(GetLabelValue(wxHORIZONTAL, GetCursorColumn()));
1436
1437   wxString newLabel = colLabel + rowLabel;
1438   if ((newLabel.Length() > 0) && (newLabel.Length() <= 8) && GetTextItem())
1439   {
1440 //    GetTextItem()->SetLabel(newLabel);
1441   }
1442 }
1443
1444 void wxGenericGrid::HighlightCell(wxDC *dc)
1445 {
1446   dc->SetLogicalFunction(wxINVERT);
1447
1448   // Top
1449   dc->DrawLine( m_currentRect.x + 1,
1450                 m_currentRect.y + 1,
1451                 m_currentRect.x + m_currentRect.width - 1,
1452                 m_currentRect.y + 1);
1453   // Right
1454   dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
1455                 m_currentRect.y + 1,
1456                 m_currentRect.x + m_currentRect.width - 1,
1457                 m_currentRect.y +m_currentRect.height - 1 );
1458   // Bottom
1459   dc->DrawLine( m_currentRect.x + m_currentRect.width - 1,
1460                 m_currentRect.y + m_currentRect.height - 1,
1461                 m_currentRect.x + 1,
1462                 m_currentRect.y + m_currentRect.height - 1);
1463   // Left
1464   dc->DrawLine( m_currentRect.x + 1,
1465                 m_currentRect.y + m_currentRect.height - 1,
1466                 m_currentRect.x + 1,
1467                 m_currentRect.y + 1);
1468
1469   dc->SetLogicalFunction(wxCOPY);
1470 }
1471
1472 void wxGenericGrid::DrawCellText(void)
1473 {
1474   if (!m_currentRectVisible)
1475     return;
1476
1477   wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
1478   if (!cell)
1479     return;
1480
1481   static char szEdit[300];
1482
1483   wxClientDC dc(this);
1484   dc.BeginDrawing();
1485
1486   SetGridClippingRegion(& dc);
1487
1488   dc.SetBackgroundMode(wxTRANSPARENT);
1489   dc.SetBrush(*cell->GetBackgroundBrush());
1490
1491   strcpy(szEdit, m_textItem->GetValue());
1492
1493   wxRectangle rect;
1494   rect = m_currentRect;
1495   rect.x += 3;
1496   rect.y += 2;
1497   rect.width -= 5;
1498   rect.height -= 4;
1499
1500   DrawTextRect(& dc, "                                    ", &rect, wxLEFT);
1501   DrawTextRect(& dc, szEdit, &rect, cell->GetAlignment());
1502
1503   dc.DestroyClippingRegion();
1504
1505   dc.SetBackgroundMode(wxSOLID);
1506
1507   dc.EndDrawing();
1508 }
1509
1510 void wxGenericGrid::SetCurrentRect(int Row, int Column, int canvasW, int canvasH)
1511 {
1512   int currentWidth = m_leftOfSheet + m_verticalLabelWidth;
1513   int i;
1514   for (i = m_scrollPosX; i < Column; i++)
1515     currentWidth += m_colWidths[i];
1516
1517   int currentHeight = m_topOfSheet + m_horizontalLabelHeight;
1518   for (i = m_scrollPosY; i < Row; i++)
1519     currentHeight += m_rowHeights[i];
1520
1521   m_currentRect.x = currentWidth;
1522   m_currentRect.y = currentHeight;
1523   m_currentRect.width = m_colWidths ? (m_colWidths[Column]) : 0;
1524   m_currentRect.height = m_rowHeights ? (m_rowHeights[Row]) : 0;
1525
1526   if (Row < m_scrollPosY || Column < m_scrollPosX)
1527     m_currentRectVisible = FALSE;
1528   else if ((canvasW != -1 && canvasH != -1) && (m_currentRect.x > canvasW || m_currentRect.y > canvasH))
1529     m_currentRectVisible = FALSE;
1530   else m_currentRectVisible = TRUE;
1531 }
1532
1533 static bool wxRectIntersection(wxRectangle *rect1, wxRectangle *rect2, wxRectangle *rect3)
1534 {
1535   int x2_1 = rect1->x + rect1->width;
1536   int y2_1 = rect1->y + rect1->height;
1537
1538   int x2_2 = rect2->x + rect2->width;
1539   int y2_2 = rect2->y + rect2->height;
1540
1541   int x2_3, y2_3;
1542
1543   // Check for intersection
1544   if ((rect1->x > x2_2) || (rect2->x > x2_1) ||
1545       (rect1->y > y2_2) || (rect2->y > y2_1))
1546   {
1547     // No intersection
1548     rect3->x = rect3->y = rect3->width = rect3->height = 0;
1549     return FALSE;
1550   }
1551
1552   if (rect1->x > rect2->x)
1553     rect3->x = rect1->x;
1554   else
1555     rect3->x = rect2->x;
1556   if (rect1->y > rect2->y)
1557     rect3->y = rect1->y;
1558   else
1559     rect3->y = rect2->y;
1560
1561   if (x2_1 > x2_2)
1562     x2_3 = x2_2;
1563   else
1564     x2_3 = x2_1;
1565   if (y2_1 > y2_2)
1566     y2_3 = y2_2;
1567   else
1568     y2_3 = y2_1;
1569
1570   rect3->width = (int)(x2_3 - rect3->x);
1571   rect3->height = (int)(y2_3 - rect3->y);
1572   return TRUE;
1573 }
1574
1575 void wxGenericGrid::DrawTextRect(wxDC *dc, const wxString& text, wxRectangle *rect, int flag)
1576 {
1577   dc->BeginDrawing();
1578
1579   // Ultimately, this functionality should be built into wxWindows,
1580   // and optimized for each platform. E.g. on Windows, use DrawText
1581   // passing a clipping rectangle, so that the wxWindows clipping region
1582   // does not have to be used to implement this.
1583
1584   // If we're already clipping, we need to find the intersection
1585   // between current clipping area and text clipping area.
1586
1587   wxRectangle clipRect;
1588   wxRectangle clipRect2;
1589   long clipX, clipY, clipW, clipH;
1590   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
1591   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
1592   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
1593
1594   bool alreadyClipping = TRUE;
1595
1596   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
1597   {
1598     alreadyClipping = FALSE;
1599     clipRect2.x = rect->x; clipRect2.y = rect->y;
1600     clipRect2.width = rect->width; clipRect2.height = rect->height;
1601   }
1602   else
1603   {
1604     // Find intersection.
1605     if (!wxRectIntersection(rect, &clipRect, &clipRect2))
1606       return;
1607   }
1608
1609   if (alreadyClipping)
1610     dc->DestroyClippingRegion();
1611
1612   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
1613   long textWidth, textHeight;
1614
1615   dc->GetTextExtent(text, &textWidth, &textHeight);
1616
1617   // Do alignment
1618   float x,y;
1619   switch (flag)
1620   {
1621     case wxRIGHT:
1622     {
1623       x = (rect->x + rect->width - textWidth - 1.0);
1624       y = (rect->y + (rect->height - textHeight)/2.0);
1625       break;
1626     }
1627     case wxCENTRE:
1628     {
1629       x = (rect->x + (rect->width - textWidth)/2.0);
1630       y = (rect->y + (rect->height - textHeight)/2.0);
1631       break;
1632     }
1633     case wxLEFT:
1634     default:
1635     {
1636       x = (rect->x + 1.0);
1637       y = (rect->y + (rect->height - textHeight)/2.0);
1638       break;
1639     }
1640   }
1641   dc->DrawText(text, (long)x, (long)y );
1642
1643   dc->DestroyClippingRegion();
1644
1645   // Restore old clipping
1646   if (alreadyClipping)
1647     dc->SetClippingRegion(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
1648
1649   dc->EndDrawing();
1650 }
1651
1652 void wxGenericGrid::DrawBitmapRect(wxDC *dc, wxBitmap *bitmap, wxRectangle *rect, int flag)
1653 {
1654   dc->BeginDrawing();
1655
1656   // Ultimately, this functionality should be built into wxWindows,
1657   // and optimized for each platform. E.g. on Windows, use DrawText
1658   // passing a clipping rectangle, so that the wxWindows clipping region
1659   // does not have to be used to implement this.
1660
1661   // If we're already clipping, we need to find the intersection
1662   // between current clipping area and text clipping area.
1663
1664   wxRectangle clipRect;
1665   wxRectangle clipRect2;
1666   long clipX, clipY, clipW, clipH;
1667   dc->GetClippingBox(&clipX, &clipY, &clipW, &clipH);
1668   clipRect.x = (int)clipX; clipRect.y = (int)clipY;
1669   clipRect.width = (int)clipW; clipRect.height = (int)clipH;
1670
1671   bool alreadyClipping = TRUE;
1672
1673   if (clipRect.x == 0 && clipRect.y == 0 && clipRect.width == 0 && clipRect.height == 0)
1674   {
1675     alreadyClipping = FALSE;
1676     clipRect2.x = rect->x; clipRect2.y = rect->y;
1677     clipRect2.width = rect->width; clipRect2.height = rect->height;
1678   }
1679   else
1680   {
1681     // Find intersection.
1682     if (!wxRectIntersection(rect, &clipRect, &clipRect2))
1683       return;
1684   }
1685
1686   if (alreadyClipping)
1687     dc->DestroyClippingRegion();
1688
1689   dc->SetClippingRegion(clipRect2.x, clipRect2.y, clipRect2.width, clipRect2.height);
1690   float bitmapWidth, bitmapHeight;
1691
1692   bitmapWidth = bitmap->GetWidth();
1693   bitmapHeight = bitmap->GetHeight();
1694
1695   // Do alignment
1696   long x,y;
1697   switch (flag)
1698   {
1699     case wxRIGHT:
1700     {
1701       x = (long)(rect->x + rect->width - bitmapWidth - 1);
1702       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1703       break;
1704     }
1705     case wxCENTRE:
1706     {
1707       x = (long)(rect->x + (rect->width - bitmapWidth)/2.0);
1708       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1709       break;
1710     }
1711     case wxLEFT:
1712     default:
1713     {
1714       x = (long)(rect->x + 1);
1715       y = (long)(rect->y + (rect->height - bitmapHeight)/2.0);
1716       break;
1717     }
1718   }
1719   wxMemoryDC dcTemp;
1720   dcTemp.SelectObject(*bitmap);
1721
1722   dc->Blit( (long)x, (long)y, (long)bitmapWidth, (long)bitmapHeight, &dcTemp, 0, 0);
1723   dcTemp.SelectObject(wxNullBitmap);
1724
1725   dc->DestroyClippingRegion();
1726
1727   // Restore old clipping
1728   if (alreadyClipping)
1729     dc->SetClippingRegion(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
1730
1731   dc->EndDrawing();
1732 }
1733
1734 void wxGenericGrid::OnActivate(bool active)
1735 {
1736   if (active)
1737   {
1738     // Edit control should always have the focus
1739     if (GetTextItem() && GetEditable())
1740     {
1741       GetTextItem()->SetFocus();
1742       wxGridCell *cell = GetCell(GetCursorRow(), GetCursorColumn());
1743       if (cell)
1744         GetTextItem()->SetValue(cell->GetTextValue());
1745     }
1746   }
1747 }
1748
1749 void wxGenericGrid::SetCellValue(const wxString& val, int row, int col)
1750 {
1751   wxGridCell *cell = GetCell(row, col);
1752   if (cell)
1753   {
1754     cell->SetTextValue(val);
1755
1756     RefreshCell(row, col, TRUE);
1757   }
1758 }
1759
1760 void wxGenericGrid::RefreshCell(int row, int col, bool setText)
1761 {
1762     // Don't refresh within a pair of batch brackets
1763     if (GetBatchCount() > 0)
1764         return;
1765
1766     int cw, ch;
1767     GetClientSize(&cw, &ch);
1768
1769     SetCurrentRect(row, col, cw, ch);
1770     if (m_currentRectVisible)
1771     {
1772       wxGridCell *cell = GetCell(row, col);
1773
1774       bool currentPos = FALSE;
1775       if (row == m_wCursorRow && col == m_wCursorColumn && GetTextItem() && GetTextItem()->IsShown() && setText)
1776       {
1777         GetTextItem()->SetValue(cell->GetTextValue());
1778         currentPos = TRUE;
1779       }
1780       // Gets refreshed anyway in MSW
1781 #ifdef __WXMSW__
1782       if (!currentPos)
1783 #endif
1784       {
1785         wxClientDC dc(this);
1786         dc.BeginDrawing();
1787         DrawCellBackground(& dc, &m_currentRect, row, col);
1788         DrawCellValue(& dc, &m_currentRect, row, col);
1789         dc.EndDrawing();
1790       }
1791     }
1792 }
1793
1794 wxString& wxGenericGrid::GetCellValue(int row, int col)
1795 {
1796   static wxString emptyString("");
1797
1798   wxGridCell *cell = GetCell(row, col);
1799   if (cell)
1800     return cell->GetTextValue();
1801   else
1802     return emptyString;
1803 }
1804
1805 void wxGenericGrid::SetColumnWidth(int col, int width)
1806 {
1807   if (col <= m_totalCols)
1808     m_colWidths[col] = width;
1809 }
1810
1811 int wxGenericGrid::GetColumnWidth(int col)
1812 {
1813   if (col <= m_totalCols)
1814     return m_colWidths[col];
1815   else
1816     return 0;
1817 }
1818
1819 void wxGenericGrid::SetRowHeight(int row, int height)
1820 {
1821   if (row <= m_totalRows)
1822     m_rowHeights[row] = height;
1823 }
1824
1825 int wxGenericGrid::GetRowHeight(int row)
1826 {
1827   if (row <= m_totalRows)
1828     return m_rowHeights[row];
1829   else
1830     return 0;
1831 }
1832
1833 void wxGenericGrid::SetLabelSize(int orientation, int sz)
1834 {
1835   if (orientation == wxHORIZONTAL)
1836     m_horizontalLabelHeight = sz;
1837   else
1838     m_verticalLabelWidth = sz;
1839   UpdateDimensions();
1840   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1841 }
1842
1843 int wxGenericGrid::GetLabelSize(int orientation)
1844 {
1845   if (orientation == wxHORIZONTAL)
1846     return m_horizontalLabelHeight;
1847   else
1848     return m_verticalLabelWidth;
1849 }
1850
1851 wxGridCell *wxGenericGrid::GetLabelCell(int orientation, int pos)
1852 {
1853   if (orientation == wxHORIZONTAL)
1854   {
1855     if (m_colLabelCells && pos < m_totalCols)
1856       return m_colLabelCells[pos];
1857     else
1858       return (wxGridCell *) NULL;
1859   }
1860   else
1861   {
1862     if (m_rowLabelCells && pos < m_totalRows)
1863       return m_rowLabelCells[pos];
1864     else
1865       return (wxGridCell *) NULL;
1866   }
1867 }
1868
1869 void wxGenericGrid::SetLabelValue(int orientation, const wxString& val, int pos)
1870 {
1871   wxGridCell *cell = GetLabelCell(orientation, pos);
1872   if (cell)
1873     cell->SetTextValue(val);
1874 }
1875
1876 wxString& wxGenericGrid::GetLabelValue(int orientation, int pos)
1877 {
1878  static wxString emptyString = "";
1879   wxGridCell *cell = GetLabelCell(orientation, pos);
1880   if (cell)
1881     return cell->GetTextValue();
1882   else
1883     return emptyString;
1884 }
1885
1886 void wxGenericGrid::SetLabelAlignment(int orientation, int align)
1887 {
1888   if (orientation == wxHORIZONTAL)
1889     m_horizontalLabelAlignment = align;
1890   else
1891     m_verticalLabelAlignment = align;
1892   UpdateDimensions();
1893   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1894 }
1895
1896 int wxGenericGrid::GetLabelAlignment(int orientation)
1897 {
1898   if (orientation == wxHORIZONTAL)
1899     return m_horizontalLabelAlignment;
1900   else
1901     return m_verticalLabelAlignment;
1902 }
1903
1904 void wxGenericGrid::SetLabelTextColour(const wxColour& colour)
1905 {
1906   m_labelTextColour = colour;
1907
1908 }
1909
1910 void wxGenericGrid::SetLabelBackgroundColour(const wxColour& colour)
1911 {
1912   m_labelBackgroundColour = colour;
1913   m_labelBackgroundBrush = wxTheBrushList->FindOrCreateBrush(m_labelBackgroundColour, wxSOLID);
1914 }
1915
1916 void wxGenericGrid::SetEditable(bool edit)
1917 {
1918   m_editable = edit;
1919   if (edit)
1920   {
1921     int controlW, controlH;
1922     m_textItem->GetSize(&controlW, &controlH);
1923     m_editControlPosition.height = controlH;
1924
1925     m_topOfSheet = m_editControlPosition.x + controlH + 2;
1926     if (m_textItem)
1927     {
1928       m_editingPanel->Show(TRUE);
1929       m_textItem->Show(TRUE);
1930       m_textItem->SetFocus();
1931     }
1932   }
1933   else
1934   {
1935     m_topOfSheet = 0;
1936     if (m_textItem)
1937     {
1938       m_textItem->Show(FALSE);
1939       m_editingPanel->Show(FALSE);
1940     }
1941   }
1942   UpdateDimensions();
1943   SetCurrentRect(GetCursorRow(), GetCursorColumn());
1944
1945   int cw, ch;
1946   GetClientSize(&cw, &ch);
1947   wxSizeEvent evt;
1948   OnSize(evt);
1949 /*
1950   int cw, ch;
1951   int m_scrollWidth = 16;
1952   GetClientSize(&cw, &ch);
1953
1954   if (m_vScrollBar)
1955     m_vScrollBar->SetSize(cw - m_scrollWidth, m_topOfSheet,
1956        m_scrollWidth, ch - m_topOfSheet - m_scrollWidth);
1957 */
1958 }
1959
1960 void wxGenericGrid::SetCellAlignment(int flag, int row, int col)
1961 {
1962   wxGridCell *cell = GetCell(row, col);
1963   if (cell)
1964     cell->SetAlignment(flag);
1965 }
1966
1967 int wxGenericGrid::GetCellAlignment(int row, int col)
1968 {
1969   wxGridCell *cell = GetCell(row, col);
1970   if (cell)
1971     return cell->GetAlignment();
1972   else
1973     return m_cellAlignment;
1974 }
1975
1976 void wxGenericGrid::SetCellAlignment(int flag)
1977 {
1978   m_cellAlignment = flag;
1979   int i,j;
1980   for (i = 0; i < GetRows(); i++)
1981     for (j = 0; j < GetCols(); j++)
1982       if (GetCell(i, j))
1983         GetCell(i, j)->SetAlignment(flag);
1984 }
1985
1986 int wxGenericGrid::GetCellAlignment(void)
1987 {
1988   return m_cellAlignment;
1989 }
1990
1991 void wxGenericGrid::SetCellBackgroundColour(const wxColour& col)
1992 {
1993   m_cellBackgroundColour = col;
1994   int i,j;
1995   for (i = 0; i < GetRows(); i++)
1996     for (j = 0; j < GetCols(); j++)
1997       if (GetCell(i, j))
1998         GetCell(i, j)->SetBackgroundColour(col);
1999 }
2000
2001 void wxGenericGrid::SetCellBackgroundColour(const wxColour& val, int row, int col)
2002 {
2003   wxGridCell *cell = GetCell(row, col);
2004   if (cell)
2005   {
2006     cell->SetBackgroundColour(val);
2007     RefreshCell(row, col);
2008   }
2009 }
2010
2011 wxColour& wxGenericGrid::GetCellBackgroundColour(int row, int col)
2012 {
2013   wxGridCell *cell = GetCell(row, col);
2014   if (cell)
2015     return cell->GetBackgroundColour();
2016   else
2017     return m_cellBackgroundColour;
2018 }
2019
2020 void wxGenericGrid::SetCellTextColour(const wxColour& val, int row, int col)
2021 {
2022   wxGridCell *cell = GetCell(row, col);
2023   if (cell)
2024   {
2025     cell->SetTextColour(val);
2026     RefreshCell(row, col);
2027   }
2028 }
2029
2030 void wxGenericGrid::SetCellTextFont(wxFont *fnt, int row, int col)
2031 {
2032   wxGridCell *cell = GetCell(row, col);
2033   if (cell)
2034   {
2035     cell->SetFont(fnt);
2036     RefreshCell(row, col);
2037   }
2038 }
2039
2040 wxFont *wxGenericGrid::GetCellTextFont(int row, int col)
2041 {
2042   wxGridCell *cell = GetCell(row, col);
2043   if (cell)
2044     return cell->GetFont();
2045   else
2046     return m_cellTextFont;
2047 }
2048
2049 wxColour& wxGenericGrid::GetCellTextColour(int row, int col)
2050 {
2051   wxGridCell *cell = GetCell(row, col);
2052   if (cell)
2053     return cell->GetTextColour();
2054   else
2055     return m_cellTextColour;
2056 }
2057
2058 void wxGenericGrid::SetCellTextColour(const wxColour& val)
2059 {
2060   m_cellTextColour = val;
2061   int i,j;
2062   for (i = 0; i < GetRows(); i++)
2063     for (j = 0; j < GetCols(); j++)
2064       if (GetCell(i, j))
2065         GetCell(i, j)->SetTextColour(val);
2066 }
2067
2068 void wxGenericGrid::SetCellTextFont(wxFont *fnt)
2069 {
2070   m_cellTextFont = fnt;
2071   int i,j;
2072   for (i = 0; i < GetRows(); i++)
2073     for (j = 0; j < GetCols(); j++)
2074       if (GetCell(i, j))
2075         GetCell(i, j)->SetFont(fnt);
2076 }
2077
2078 void wxGenericGrid::SetCellBitmap(wxBitmap *bitmap, int row, int col)
2079 {
2080   wxGridCell *cell = GetCell(row, col);
2081   if (cell)
2082   {
2083     cell->SetCellBitmap(bitmap);
2084     RefreshCell(row, col);
2085   }
2086 }
2087
2088 wxBitmap *wxGenericGrid::GetCellBitmap(int row, int col)
2089 {
2090   wxGridCell *cell = GetCell(row, col);
2091   if (cell)
2092   {
2093     return cell->GetCellBitmap();
2094   }
2095   else
2096     return (wxBitmap *) NULL;
2097 }
2098
2099 bool wxGenericGrid::InsertCols(int pos, int n, bool updateLabels)
2100 {
2101   if (pos > m_totalCols)
2102     return FALSE;
2103
2104   if (!m_gridCells)
2105     return CreateGrid(1, n);
2106   else
2107   {
2108     int i, j;
2109     // Cells
2110     for (i = 0; i < m_totalRows; i++)
2111     {
2112       wxGridCell **cols = m_gridCells[i];
2113       wxGridCell **newCols = new wxGridCell *[m_totalCols + n];
2114       for (j = 0; j < pos; j++)
2115         newCols[j] = cols[j];
2116       for (j = pos; j < pos + n; j++)
2117         newCols[j] = new wxGridCell(this);
2118       for (j = pos + n; j < m_totalCols + n; j++)
2119         newCols[j] = cols[j - n];
2120
2121       delete[] cols;
2122       m_gridCells[i] = newCols;
2123     }
2124
2125     // Column widths
2126     short *newColWidths = new short[m_totalCols + n];
2127     for (j = 0; j < pos; j++)
2128       newColWidths[j] = m_colWidths[j];
2129     for (j = pos; j < pos + n; j++)
2130       newColWidths[j] = wxGRID_DEFAULT_CELL_WIDTH;
2131     for (j = pos + n; j < m_totalCols + n; j++)
2132       newColWidths[j] = m_colWidths[j - n];
2133     delete[] m_colWidths;
2134     m_colWidths = newColWidths;
2135
2136     // Column labels
2137     wxGridCell **newLabels = new wxGridCell *[m_totalCols + n];
2138     for (j = 0; j < pos; j++)
2139       newLabels[j] = m_colLabelCells[j];
2140     for (j = pos; j < pos + n; j++)
2141       newLabels[j] = new wxGridCell(this);
2142     for (j = pos + n; j < m_totalCols + n; j++)
2143       newLabels[j] = m_colLabelCells[j - n];
2144
2145     delete[] m_colLabelCells;
2146     m_colLabelCells = newLabels;
2147
2148     m_totalCols += n;
2149
2150     if (updateLabels)
2151       OnChangeLabels();
2152     UpdateDimensions();
2153     AdjustScrollbars();
2154     return TRUE;
2155   }
2156 }
2157
2158 bool wxGenericGrid::InsertRows(int pos, int n, bool updateLabels)
2159 {
2160   if (pos > m_totalRows)
2161     return FALSE;
2162
2163   if (!m_gridCells)
2164     return CreateGrid(n, 1);
2165   else
2166   {
2167     int i, j;
2168
2169     wxGridCell ***rows = new wxGridCell **[m_totalRows + n];
2170
2171     // Cells
2172     for (i = 0; i < pos; i++)
2173       rows[i] = m_gridCells[i];
2174
2175     for (i = pos; i < pos + n; i++)
2176     {
2177       rows[i] = new wxGridCell *[m_totalCols];
2178       for (j = 0; j < m_totalCols; j++)
2179         rows[i][j] = new wxGridCell(this);
2180     }
2181
2182     for (i = pos + n; i < m_totalRows + n; i++)
2183       rows[i] = m_gridCells[i - n];
2184
2185     delete[] m_gridCells;
2186     m_gridCells = rows;
2187
2188     // Row heights
2189     short *newRowHeights = new short[m_totalRows + n];
2190     for (i = 0; i < pos; i++)
2191       newRowHeights[i] = m_rowHeights[i];
2192     for (i = pos; i < pos + n; i++)
2193       newRowHeights[i] = wxGRID_DEFAULT_CELL_HEIGHT;
2194     for (i = pos + n; i < m_totalRows + n; i++)
2195       newRowHeights[i] = m_rowHeights[i - n];
2196     delete[] m_rowHeights;
2197     m_rowHeights = newRowHeights;
2198
2199     // Column labels
2200     wxGridCell **newLabels = new wxGridCell *[m_totalRows + n];
2201     for (i = 0; i < pos; i++)
2202       newLabels[i] = m_rowLabelCells[i];
2203     for (i = pos; i < pos + n; i++)
2204       newLabels[i] = new wxGridCell(this);
2205     for (i = pos + n; i < m_totalRows + n; i++)
2206       newLabels[i] = m_rowLabelCells[i - n];
2207
2208     delete[] m_rowLabelCells;
2209     m_rowLabelCells = newLabels;
2210
2211     m_totalRows += n;
2212
2213     if (updateLabels)
2214       OnChangeLabels();
2215     UpdateDimensions();
2216     AdjustScrollbars();
2217     return TRUE;
2218   }
2219 }
2220
2221 bool wxGenericGrid::AppendCols(int n, bool updateLabels)
2222 {
2223   return InsertCols(GetCols(), n, updateLabels);
2224 }
2225
2226 bool wxGenericGrid::AppendRows(int n, bool updateLabels)
2227 {
2228   return InsertRows(GetRows(), n, updateLabels);
2229 }
2230
2231 bool wxGenericGrid::DeleteRows(int pos, int n, bool updateLabels)
2232 {
2233   if (pos > m_totalRows)
2234     return FALSE;
2235   if (!m_gridCells)
2236     return FALSE;
2237
2238   int i;
2239
2240   wxGridCell ***rows = new wxGridCell **[m_totalRows - n];
2241
2242   // Cells
2243   for (i = 0; i < pos; i++)
2244     rows[i] = m_gridCells[i];
2245
2246   for (i = pos + n; i < m_totalRows; i++)
2247     rows[i-n] = m_gridCells[i];
2248
2249   delete[] m_gridCells;
2250   m_gridCells = rows;
2251
2252   // Row heights
2253   short *newRowHeights = new short[m_totalRows - n];
2254   for (i = 0; i < pos; i++)
2255     newRowHeights[i] = m_rowHeights[i];
2256   for (i = pos + n; i < m_totalRows; i++)
2257     newRowHeights[i-n] = m_rowHeights[i];
2258   delete[] m_rowHeights;
2259   m_rowHeights = newRowHeights;
2260
2261   // Column labels
2262   wxGridCell **newLabels = new wxGridCell *[m_totalRows - n];
2263   for (i = 0; i < pos; i++)
2264     newLabels[i] = m_rowLabelCells[i];
2265   for (i = pos + n; i < m_totalRows; i++)
2266     newLabels[i-n] = m_rowLabelCells[i];
2267
2268   delete[] m_rowLabelCells;
2269   m_rowLabelCells = newLabels;
2270
2271   m_totalRows -= n;
2272
2273   if (updateLabels)
2274     OnChangeLabels();
2275   UpdateDimensions();
2276   AdjustScrollbars();
2277   return TRUE;
2278 }
2279
2280 bool wxGenericGrid::DeleteCols(int pos, int n, bool updateLabels)
2281 {
2282   if (pos + n > m_totalCols)
2283     return FALSE;
2284   if (!m_gridCells)
2285     return FALSE;
2286
2287   int i, j;
2288
2289   // Cells
2290   for (i = 0; i < m_totalRows; i++)
2291   {
2292       wxGridCell **cols = m_gridCells[i];
2293       wxGridCell **newCols = new wxGridCell *[m_totalCols - n];
2294       for (j = 0; j < pos; j++)
2295         newCols[j] = cols[j];
2296       for (j = pos; j < pos + n; j++)
2297         delete cols[j];
2298       for (j = pos + n; j < m_totalCols; j++)
2299         newCols[j-n] = cols[j];
2300
2301       delete[] cols;
2302       m_gridCells[i] = newCols;
2303   }
2304
2305   // Column widths
2306   short *newColWidths = new short[m_totalCols - n];
2307   for (j = 0; j < pos; j++)
2308     newColWidths[j] = m_colWidths[j];
2309   for (j = pos + n; j < m_totalCols; j++)
2310     newColWidths[j-n] = m_colWidths[j];
2311   delete[] m_colWidths;
2312   m_colWidths = newColWidths;
2313
2314   // Column labels
2315   wxGridCell **newLabels = new wxGridCell *[m_totalCols - n];
2316   for (j = 0; j < pos; j++)
2317     newLabels[j] = m_colLabelCells[j];
2318   for (j = pos + n; j < m_totalCols; j++)
2319     newLabels[j-n] = m_colLabelCells[j];
2320
2321   delete[] m_colLabelCells;
2322   m_colLabelCells = newLabels;
2323
2324   m_totalCols -= n;
2325
2326   if (updateLabels)
2327     OnChangeLabels();
2328   UpdateDimensions();
2329   AdjustScrollbars();
2330   return TRUE;
2331 }
2332
2333 void wxGenericGrid::SetGridCursor(int row, int col)
2334 {
2335   if (row >= m_totalRows || col >= m_totalCols)
2336     return;
2337
2338   if (row == GetCursorRow() && col == GetCursorColumn())
2339     return;
2340
2341   wxClientDC dc(this);
2342   dc.BeginDrawing();
2343
2344   SetGridClippingRegion(& dc);
2345
2346   if (m_currentRectVisible)
2347     HighlightCell(& dc);
2348
2349   m_wCursorRow = row;
2350   m_wCursorColumn = col;
2351   SetCurrentRect(row, col);
2352   if (m_currentRectVisible)
2353     HighlightCell(& dc);
2354
2355   dc.DestroyClippingRegion();
2356   dc.EndDrawing();
2357 }
2358
2359 /*
2360  * Grid cell
2361  */
2362
2363 wxGridCell::wxGridCell(wxGenericGrid *window)
2364 {
2365   cellBitmap = (wxBitmap *) NULL;
2366   font = (wxFont *) NULL;
2367   backgroundBrush = (wxBrush *) NULL;
2368   if (window)
2369     textColour = window->GetCellTextColour();
2370   else
2371     textColour.Set(0,0,0);
2372   if (window)
2373     backgroundColour = window->GetCellBackgroundColour();
2374   else
2375     backgroundColour.Set(255,255,255);
2376
2377   if (window)
2378     font = window->GetCellTextFont();
2379   else
2380     font = wxTheFontList->FindOrCreateFont(12, wxSWISS, wxNORMAL, wxNORMAL);
2381
2382   SetBackgroundColour(backgroundColour);
2383
2384   if (window)
2385     alignment = window->GetCellAlignment();
2386   else
2387     alignment = wxLEFT;
2388 }
2389
2390 wxGridCell::~wxGridCell(void)
2391 {
2392 }
2393
2394 void wxGridCell::SetBackgroundColour(const wxColour& colour)
2395 {
2396   backgroundColour = colour;
2397   backgroundBrush = wxTheBrushList->FindOrCreateBrush(backgroundColour, wxSOLID);
2398 }
2399
2400 void wxGenericGrid::OnText(wxCommandEvent& WXUNUSED(ev) )
2401 {
2402   wxGenericGrid *grid = this;
2403   wxGridCell *cell = grid->GetCell(grid->GetCursorRow(), grid->GetCursorColumn());
2404   if (cell && grid->CurrentCellVisible())
2405   {
2406     cell->SetTextValue(grid->GetTextItem()->GetValue());
2407     wxClientDC dc(grid);
2408
2409     dc.BeginDrawing();
2410     grid->SetGridClippingRegion(& dc);
2411     grid->DrawCellBackground(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
2412     grid->DrawCellValue(& dc, &grid->GetCurrentRect(), grid->GetCursorRow(), grid->GetCursorColumn());
2413     grid->HighlightCell(& dc);
2414     dc.DestroyClippingRegion();
2415     dc.EndDrawing();
2416
2417     grid->OnCellChange(grid->GetCursorRow(), grid->GetCursorColumn());
2418
2419 //    grid->DrawCellText();
2420   }
2421 }
2422
2423 void wxGenericGrid::OnGridScroll(wxScrollEvent& ev)
2424 {
2425   static bool inScroll = FALSE;
2426
2427   if ( inScroll )
2428         return;
2429
2430   inScroll = TRUE;
2431   wxGenericGrid *win = this;
2432
2433   bool change = FALSE;
2434
2435   if (ev.GetEventObject() == win->GetHorizScrollBar())
2436   {
2437     change = (ev.GetPosition() != m_scrollPosX);
2438     win->SetScrollPosX(ev.GetPosition());
2439   }
2440   else
2441   {
2442     change = (ev.GetPosition() != m_scrollPosY);
2443     win->SetScrollPosY(ev.GetPosition());
2444   }
2445
2446   win->UpdateDimensions();
2447   win->SetCurrentRect(win->GetCursorRow(), win->GetCursorColumn());
2448
2449   // Because rows and columns can be arbitrary sizes,
2450   // the scrollbars will need to be adjusted to reflect the
2451   // current view.
2452   AdjustScrollbars();
2453
2454   if (change) win->Refresh(FALSE);
2455   inScroll = FALSE;
2456
2457 }