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