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