]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/generic/grid.cpp
Fix link errors under Cygwin with wxUSE_GRAPHICS_CONTEXT==1.
[wxWidgets.git] / src / generic / grid.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////
2// Name: src/generic/grid.cpp
3// Purpose: wxGrid and related classes
4// Author: Michael Bedward (based on code by Julian Smart, Robin Dunn)
5// Modified by: Robin Dunn, Vadim Zeitlin, Santiago Palacios
6// Created: 1/08/1999
7// RCS-ID: $Id$
8// Copyright: (c) Michael Bedward (mbedward@ozemail.com.au)
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12/*
13 TODO:
14
15 - Replace use of wxINVERT with wxOverlay
16 - Make Begin/EndBatch() the same as the generic Freeze/Thaw()
17 - Review the column reordering code, it's a mess.
18 - Implement row reordering after dealing with the columns.
19 */
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#include "wx/grid.h"
31
32#ifndef WX_PRECOMP
33 #include "wx/utils.h"
34 #include "wx/dcclient.h"
35 #include "wx/settings.h"
36 #include "wx/log.h"
37 #include "wx/textctrl.h"
38 #include "wx/checkbox.h"
39 #include "wx/combobox.h"
40 #include "wx/valtext.h"
41 #include "wx/intl.h"
42 #include "wx/math.h"
43 #include "wx/listbox.h"
44#endif
45
46#include "wx/textfile.h"
47#include "wx/spinctrl.h"
48#include "wx/tokenzr.h"
49#include "wx/renderer.h"
50#include "wx/headerctrl.h"
51#include "wx/hashset.h"
52
53#include "wx/generic/gridsel.h"
54#include "wx/generic/gridctrl.h"
55#include "wx/generic/grideditors.h"
56#include "wx/generic/private/grid.h"
57
58const char wxGridNameStr[] = "grid";
59
60#if defined(__WXMOTIF__)
61 #define WXUNUSED_MOTIF(identifier) WXUNUSED(identifier)
62#else
63 #define WXUNUSED_MOTIF(identifier) identifier
64#endif
65
66#if defined(__WXGTK__)
67 #define WXUNUSED_GTK(identifier) WXUNUSED(identifier)
68#else
69 #define WXUNUSED_GTK(identifier) identifier
70#endif
71
72// Required for wxIs... functions
73#include <ctype.h>
74
75WX_DECLARE_HASH_SET_WITH_DECL(int, wxIntegerHash, wxIntegerEqual,
76 wxGridFixedIndicesSet, class WXDLLIMPEXP_ADV);
77
78
79// ----------------------------------------------------------------------------
80// globals
81// ----------------------------------------------------------------------------
82
83namespace
84{
85
86//#define DEBUG_ATTR_CACHE
87#ifdef DEBUG_ATTR_CACHE
88 static size_t gs_nAttrCacheHits = 0;
89 static size_t gs_nAttrCacheMisses = 0;
90#endif
91
92// this struct simply combines together the default header renderers
93//
94// as the renderers ctors are trivial, there is no problem with making them
95// globals
96struct DefaultHeaderRenderers
97{
98 wxGridColumnHeaderRendererDefault colRenderer;
99 wxGridRowHeaderRendererDefault rowRenderer;
100 wxGridCornerHeaderRendererDefault cornerRenderer;
101} gs_defaultHeaderRenderers;
102
103} // anonymous namespace
104
105// ----------------------------------------------------------------------------
106// constants
107// ----------------------------------------------------------------------------
108
109wxGridCellCoords wxGridNoCellCoords( -1, -1 );
110wxRect wxGridNoCellRect( -1, -1, -1, -1 );
111
112namespace
113{
114
115// scroll line size
116const size_t GRID_SCROLL_LINE_X = 15;
117const size_t GRID_SCROLL_LINE_Y = GRID_SCROLL_LINE_X;
118
119// the size of hash tables used a bit everywhere (the max number of elements
120// in these hash tables is the number of rows/columns)
121const int GRID_HASH_SIZE = 100;
122
123// the minimal distance in pixels the mouse needs to move to start a drag
124// operation
125const int DRAG_SENSITIVITY = 3;
126
127} // anonymous namespace
128
129#include "wx/arrimpl.cpp"
130
131WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
132WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
133
134// ----------------------------------------------------------------------------
135// events
136// ----------------------------------------------------------------------------
137
138wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_CLICK, wxGridEvent );
139wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_CLICK, wxGridEvent );
140wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_DCLICK, wxGridEvent );
141wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_DCLICK, wxGridEvent );
142wxDEFINE_EVENT( wxEVT_GRID_CELL_BEGIN_DRAG, wxGridEvent );
143wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_CLICK, wxGridEvent );
144wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_CLICK, wxGridEvent );
145wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_DCLICK, wxGridEvent );
146wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_DCLICK, wxGridEvent );
147wxDEFINE_EVENT( wxEVT_GRID_ROW_SIZE, wxGridSizeEvent );
148wxDEFINE_EVENT( wxEVT_GRID_COL_SIZE, wxGridSizeEvent );
149wxDEFINE_EVENT( wxEVT_GRID_COL_MOVE, wxGridEvent );
150wxDEFINE_EVENT( wxEVT_GRID_COL_SORT, wxGridEvent );
151wxDEFINE_EVENT( wxEVT_GRID_RANGE_SELECT, wxGridRangeSelectEvent );
152wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGING, wxGridEvent );
153wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGED, wxGridEvent );
154wxDEFINE_EVENT( wxEVT_GRID_SELECT_CELL, wxGridEvent );
155wxDEFINE_EVENT( wxEVT_GRID_EDITOR_SHOWN, wxGridEvent );
156wxDEFINE_EVENT( wxEVT_GRID_EDITOR_HIDDEN, wxGridEvent );
157wxDEFINE_EVENT( wxEVT_GRID_EDITOR_CREATED, wxGridEditorCreatedEvent );
158
159// ============================================================================
160// implementation
161// ============================================================================
162
163IMPLEMENT_ABSTRACT_CLASS(wxGridCellEditorEvtHandler, wxEvtHandler)
164
165BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
166 EVT_KILL_FOCUS( wxGridCellEditorEvtHandler::OnKillFocus )
167 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
168 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
169END_EVENT_TABLE()
170
171BEGIN_EVENT_TABLE(wxGridHeaderCtrl, wxHeaderCtrl)
172 EVT_HEADER_CLICK(wxID_ANY, wxGridHeaderCtrl::OnClick)
173 EVT_HEADER_DCLICK(wxID_ANY, wxGridHeaderCtrl::OnDoubleClick)
174 EVT_HEADER_RIGHT_CLICK(wxID_ANY, wxGridHeaderCtrl::OnRightClick)
175
176 EVT_HEADER_BEGIN_RESIZE(wxID_ANY, wxGridHeaderCtrl::OnBeginResize)
177 EVT_HEADER_RESIZING(wxID_ANY, wxGridHeaderCtrl::OnResizing)
178 EVT_HEADER_END_RESIZE(wxID_ANY, wxGridHeaderCtrl::OnEndResize)
179
180 EVT_HEADER_BEGIN_REORDER(wxID_ANY, wxGridHeaderCtrl::OnBeginReorder)
181 EVT_HEADER_END_REORDER(wxID_ANY, wxGridHeaderCtrl::OnEndReorder)
182END_EVENT_TABLE()
183
184wxGridOperations& wxGridRowOperations::Dual() const
185{
186 static wxGridColumnOperations s_colOper;
187
188 return s_colOper;
189}
190
191wxGridOperations& wxGridColumnOperations::Dual() const
192{
193 static wxGridRowOperations s_rowOper;
194
195 return s_rowOper;
196}
197
198// ----------------------------------------------------------------------------
199// wxGridCellWorker is an (almost) empty common base class for
200// wxGridCellRenderer and wxGridCellEditor managing ref counting
201// ----------------------------------------------------------------------------
202
203void wxGridCellWorker::SetParameters(const wxString& WXUNUSED(params))
204{
205 // nothing to do
206}
207
208wxGridCellWorker::~wxGridCellWorker()
209{
210}
211
212// ----------------------------------------------------------------------------
213// wxGridHeaderLabelsRenderer and related classes
214// ----------------------------------------------------------------------------
215
216void wxGridHeaderLabelsRenderer::DrawLabel(const wxGrid& grid,
217 wxDC& dc,
218 const wxString& value,
219 const wxRect& rect,
220 int horizAlign,
221 int vertAlign,
222 int textOrientation) const
223{
224 dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
225 dc.SetTextForeground(grid.GetLabelTextColour());
226 dc.SetFont(grid.GetLabelFont());
227 grid.DrawTextRectangle(dc, value, rect, horizAlign, vertAlign, textOrientation);
228}
229
230
231void wxGridRowHeaderRendererDefault::DrawBorder(const wxGrid& WXUNUSED(grid),
232 wxDC& dc,
233 wxRect& rect) const
234{
235 dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW)));
236 dc.DrawLine(rect.GetRight(), rect.GetTop(),
237 rect.GetRight(), rect.GetBottom());
238 dc.DrawLine(rect.GetLeft(), rect.GetTop(),
239 rect.GetLeft(), rect.GetBottom());
240 dc.DrawLine(rect.GetLeft(), rect.GetBottom(),
241 rect.GetRight() + 1, rect.GetBottom());
242
243 dc.SetPen(*wxWHITE_PEN);
244 dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(),
245 rect.GetLeft() + 1, rect.GetBottom());
246 dc.DrawLine(rect.GetLeft() + 1, rect.GetTop(),
247 rect.GetRight(), rect.GetTop());
248
249 rect.Deflate(2);
250}
251
252void wxGridColumnHeaderRendererDefault::DrawBorder(const wxGrid& WXUNUSED(grid),
253 wxDC& dc,
254 wxRect& rect) const
255{
256 dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW)));
257 dc.DrawLine(rect.GetRight(), rect.GetTop(),
258 rect.GetRight(), rect.GetBottom());
259 dc.DrawLine(rect.GetLeft(), rect.GetTop(),
260 rect.GetRight(), rect.GetTop());
261 dc.DrawLine(rect.GetLeft(), rect.GetBottom(),
262 rect.GetRight() + 1, rect.GetBottom());
263
264 dc.SetPen(*wxWHITE_PEN);
265 dc.DrawLine(rect.GetLeft(), rect.GetTop() + 1,
266 rect.GetLeft(), rect.GetBottom());
267 dc.DrawLine(rect.GetLeft(), rect.GetTop() + 1,
268 rect.GetRight(), rect.GetTop() + 1);
269
270 rect.Deflate(2);
271}
272
273void wxGridCornerHeaderRendererDefault::DrawBorder(const wxGrid& WXUNUSED(grid),
274 wxDC& dc,
275 wxRect& rect) const
276{
277 dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW)));
278 dc.DrawLine(rect.GetRight() - 1, rect.GetBottom() - 1,
279 rect.GetRight() - 1, rect.GetTop());
280 dc.DrawLine(rect.GetRight() - 1, rect.GetBottom() - 1,
281 rect.GetLeft(), rect.GetBottom() - 1);
282 dc.DrawLine(rect.GetLeft(), rect.GetTop(),
283 rect.GetRight(), rect.GetTop());
284 dc.DrawLine(rect.GetLeft(), rect.GetTop(),
285 rect.GetLeft(), rect.GetBottom());
286
287 dc.SetPen(*wxWHITE_PEN);
288 dc.DrawLine(rect.GetLeft() + 1, rect.GetTop() + 1,
289 rect.GetRight() - 1, rect.GetTop() + 1);
290 dc.DrawLine(rect.GetLeft() + 1, rect.GetTop() + 1,
291 rect.GetLeft() + 1, rect.GetBottom() - 1);
292
293 rect.Deflate(2);
294}
295
296// ----------------------------------------------------------------------------
297// wxGridCellAttr
298// ----------------------------------------------------------------------------
299
300void wxGridCellAttr::Init(wxGridCellAttr *attrDefault)
301{
302 m_isReadOnly = Unset;
303
304 m_renderer = NULL;
305 m_editor = NULL;
306
307 m_attrkind = wxGridCellAttr::Cell;
308
309 m_sizeRows = m_sizeCols = 1;
310 m_overflow = UnsetOverflow;
311
312 SetDefAttr(attrDefault);
313}
314
315wxGridCellAttr *wxGridCellAttr::Clone() const
316{
317 wxGridCellAttr *attr = new wxGridCellAttr(m_defGridAttr);
318
319 if ( HasTextColour() )
320 attr->SetTextColour(GetTextColour());
321 if ( HasBackgroundColour() )
322 attr->SetBackgroundColour(GetBackgroundColour());
323 if ( HasFont() )
324 attr->SetFont(GetFont());
325 if ( HasAlignment() )
326 attr->SetAlignment(m_hAlign, m_vAlign);
327
328 attr->SetSize( m_sizeRows, m_sizeCols );
329
330 if ( m_renderer )
331 {
332 attr->SetRenderer(m_renderer);
333 m_renderer->IncRef();
334 }
335 if ( m_editor )
336 {
337 attr->SetEditor(m_editor);
338 m_editor->IncRef();
339 }
340
341 if ( IsReadOnly() )
342 attr->SetReadOnly();
343
344 attr->SetOverflow( m_overflow == Overflow );
345 attr->SetKind( m_attrkind );
346
347 return attr;
348}
349
350void wxGridCellAttr::MergeWith(wxGridCellAttr *mergefrom)
351{
352 if ( !HasTextColour() && mergefrom->HasTextColour() )
353 SetTextColour(mergefrom->GetTextColour());
354 if ( !HasBackgroundColour() && mergefrom->HasBackgroundColour() )
355 SetBackgroundColour(mergefrom->GetBackgroundColour());
356 if ( !HasFont() && mergefrom->HasFont() )
357 SetFont(mergefrom->GetFont());
358 if ( !HasAlignment() && mergefrom->HasAlignment() )
359 {
360 int hAlign, vAlign;
361 mergefrom->GetAlignment( &hAlign, &vAlign);
362 SetAlignment(hAlign, vAlign);
363 }
364 if ( !HasSize() && mergefrom->HasSize() )
365 mergefrom->GetSize( &m_sizeRows, &m_sizeCols );
366
367 // Directly access member functions as GetRender/Editor don't just return
368 // m_renderer/m_editor
369 //
370 // Maybe add support for merge of Render and Editor?
371 if (!HasRenderer() && mergefrom->HasRenderer() )
372 {
373 m_renderer = mergefrom->m_renderer;
374 m_renderer->IncRef();
375 }
376 if ( !HasEditor() && mergefrom->HasEditor() )
377 {
378 m_editor = mergefrom->m_editor;
379 m_editor->IncRef();
380 }
381 if ( !HasReadWriteMode() && mergefrom->HasReadWriteMode() )
382 SetReadOnly(mergefrom->IsReadOnly());
383
384 if (!HasOverflowMode() && mergefrom->HasOverflowMode() )
385 SetOverflow(mergefrom->GetOverflow());
386
387 SetDefAttr(mergefrom->m_defGridAttr);
388}
389
390void wxGridCellAttr::SetSize(int num_rows, int num_cols)
391{
392 // The size of a cell is normally 1,1
393
394 // If this cell is larger (2,2) then this is the top left cell
395 // the other cells that will be covered (lower right cells) must be
396 // set to negative or zero values such that
397 // row + num_rows of the covered cell points to the larger cell (this cell)
398 // same goes for the col + num_cols.
399
400 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
401
402 wxASSERT_MSG( (!((num_rows > 0) && (num_cols <= 0)) ||
403 !((num_rows <= 0) && (num_cols > 0)) ||
404 !((num_rows == 0) && (num_cols == 0))),
405 wxT("wxGridCellAttr::SetSize only takes two postive values or negative/zero values"));
406
407 m_sizeRows = num_rows;
408 m_sizeCols = num_cols;
409}
410
411const wxColour& wxGridCellAttr::GetTextColour() const
412{
413 if (HasTextColour())
414 {
415 return m_colText;
416 }
417 else if (m_defGridAttr && m_defGridAttr != this)
418 {
419 return m_defGridAttr->GetTextColour();
420 }
421 else
422 {
423 wxFAIL_MSG(wxT("Missing default cell attribute"));
424 return wxNullColour;
425 }
426}
427
428const wxColour& wxGridCellAttr::GetBackgroundColour() const
429{
430 if (HasBackgroundColour())
431 {
432 return m_colBack;
433 }
434 else if (m_defGridAttr && m_defGridAttr != this)
435 {
436 return m_defGridAttr->GetBackgroundColour();
437 }
438 else
439 {
440 wxFAIL_MSG(wxT("Missing default cell attribute"));
441 return wxNullColour;
442 }
443}
444
445const wxFont& wxGridCellAttr::GetFont() const
446{
447 if (HasFont())
448 {
449 return m_font;
450 }
451 else if (m_defGridAttr && m_defGridAttr != this)
452 {
453 return m_defGridAttr->GetFont();
454 }
455 else
456 {
457 wxFAIL_MSG(wxT("Missing default cell attribute"));
458 return wxNullFont;
459 }
460}
461
462void wxGridCellAttr::GetAlignment(int *hAlign, int *vAlign) const
463{
464 if (HasAlignment())
465 {
466 if ( hAlign )
467 *hAlign = m_hAlign;
468 if ( vAlign )
469 *vAlign = m_vAlign;
470 }
471 else if (m_defGridAttr && m_defGridAttr != this)
472 {
473 m_defGridAttr->GetAlignment(hAlign, vAlign);
474 }
475 else
476 {
477 wxFAIL_MSG(wxT("Missing default cell attribute"));
478 }
479}
480
481void wxGridCellAttr::GetNonDefaultAlignment(int *hAlign, int *vAlign) const
482{
483 if ( hAlign && m_hAlign != wxALIGN_INVALID )
484 *hAlign = m_hAlign;
485
486 if ( vAlign && m_vAlign != wxALIGN_INVALID )
487 *vAlign = m_vAlign;
488}
489
490void wxGridCellAttr::GetSize( int *num_rows, int *num_cols ) const
491{
492 if ( num_rows )
493 *num_rows = m_sizeRows;
494 if ( num_cols )
495 *num_cols = m_sizeCols;
496}
497
498// GetRenderer and GetEditor use a slightly different decision path about
499// which attribute to use. If a non-default attr object has one then it is
500// used, otherwise the default editor or renderer is fetched from the grid and
501// used. It should be the default for the data type of the cell. If it is
502// NULL (because the table has a type that the grid does not have in its
503// registry), then the grid's default editor or renderer is used.
504
505wxGridCellRenderer* wxGridCellAttr::GetRenderer(const wxGrid* grid, int row, int col) const
506{
507 wxGridCellRenderer *renderer = NULL;
508
509 if ( m_renderer && this != m_defGridAttr )
510 {
511 // use the cells renderer if it has one
512 renderer = m_renderer;
513 renderer->IncRef();
514 }
515 else // no non-default cell renderer
516 {
517 // get default renderer for the data type
518 if ( grid )
519 {
520 // GetDefaultRendererForCell() will do IncRef() for us
521 renderer = grid->GetDefaultRendererForCell(row, col);
522 }
523
524 if ( renderer == NULL )
525 {
526 if ( (m_defGridAttr != NULL) && (m_defGridAttr != this) )
527 {
528 // if we still don't have one then use the grid default
529 // (no need for IncRef() here neither)
530 renderer = m_defGridAttr->GetRenderer(NULL, 0, 0);
531 }
532 else // default grid attr
533 {
534 // use m_renderer which we had decided not to use initially
535 renderer = m_renderer;
536 if ( renderer )
537 renderer->IncRef();
538 }
539 }
540 }
541
542 // we're supposed to always find something
543 wxASSERT_MSG(renderer, wxT("Missing default cell renderer"));
544
545 return renderer;
546}
547
548// same as above, except for s/renderer/editor/g
549wxGridCellEditor* wxGridCellAttr::GetEditor(const wxGrid* grid, int row, int col) const
550{
551 wxGridCellEditor *editor = NULL;
552
553 if ( m_editor && this != m_defGridAttr )
554 {
555 // use the cells editor if it has one
556 editor = m_editor;
557 editor->IncRef();
558 }
559 else // no non default cell editor
560 {
561 // get default editor for the data type
562 if ( grid )
563 {
564 // GetDefaultEditorForCell() will do IncRef() for us
565 editor = grid->GetDefaultEditorForCell(row, col);
566 }
567
568 if ( editor == NULL )
569 {
570 if ( (m_defGridAttr != NULL) && (m_defGridAttr != this) )
571 {
572 // if we still don't have one then use the grid default
573 // (no need for IncRef() here neither)
574 editor = m_defGridAttr->GetEditor(NULL, 0, 0);
575 }
576 else // default grid attr
577 {
578 // use m_editor which we had decided not to use initially
579 editor = m_editor;
580 if ( editor )
581 editor->IncRef();
582 }
583 }
584 }
585
586 // we're supposed to always find something
587 wxASSERT_MSG(editor, wxT("Missing default cell editor"));
588
589 return editor;
590}
591
592// ----------------------------------------------------------------------------
593// wxGridCellAttrData
594// ----------------------------------------------------------------------------
595
596void wxGridCellAttrData::SetAttr(wxGridCellAttr *attr, int row, int col)
597{
598 // Note: contrary to wxGridRowOrColAttrData::SetAttr, we must not
599 // touch attribute's reference counting explicitly, since this
600 // is managed by class wxGridCellWithAttr
601 int n = FindIndex(row, col);
602 if ( n == wxNOT_FOUND )
603 {
604 if ( attr )
605 {
606 // add the attribute
607 m_attrs.Add(new wxGridCellWithAttr(row, col, attr));
608 }
609 //else: nothing to do
610 }
611 else // we already have an attribute for this cell
612 {
613 if ( attr )
614 {
615 // change the attribute
616 m_attrs[(size_t)n].ChangeAttr(attr);
617 }
618 else
619 {
620 // remove this attribute
621 m_attrs.RemoveAt((size_t)n);
622 }
623 }
624}
625
626wxGridCellAttr *wxGridCellAttrData::GetAttr(int row, int col) const
627{
628 wxGridCellAttr *attr = NULL;
629
630 int n = FindIndex(row, col);
631 if ( n != wxNOT_FOUND )
632 {
633 attr = m_attrs[(size_t)n].attr;
634 attr->IncRef();
635 }
636
637 return attr;
638}
639
640void wxGridCellAttrData::UpdateAttrRows( size_t pos, int numRows )
641{
642 size_t count = m_attrs.GetCount();
643 for ( size_t n = 0; n < count; n++ )
644 {
645 wxGridCellCoords& coords = m_attrs[n].coords;
646 wxCoord row = coords.GetRow();
647 if ((size_t)row >= pos)
648 {
649 if (numRows > 0)
650 {
651 // If rows inserted, include row counter where necessary
652 coords.SetRow(row + numRows);
653 }
654 else if (numRows < 0)
655 {
656 // If rows deleted ...
657 if ((size_t)row >= pos - numRows)
658 {
659 // ...either decrement row counter (if row still exists)...
660 coords.SetRow(row + numRows);
661 }
662 else
663 {
664 // ...or remove the attribute
665 m_attrs.RemoveAt(n);
666 n--;
667 count--;
668 }
669 }
670 }
671 }
672}
673
674void wxGridCellAttrData::UpdateAttrCols( size_t pos, int numCols )
675{
676 size_t count = m_attrs.GetCount();
677 for ( size_t n = 0; n < count; n++ )
678 {
679 wxGridCellCoords& coords = m_attrs[n].coords;
680 wxCoord col = coords.GetCol();
681 if ( (size_t)col >= pos )
682 {
683 if ( numCols > 0 )
684 {
685 // If rows inserted, include row counter where necessary
686 coords.SetCol(col + numCols);
687 }
688 else if (numCols < 0)
689 {
690 // If rows deleted ...
691 if ((size_t)col >= pos - numCols)
692 {
693 // ...either decrement row counter (if row still exists)...
694 coords.SetCol(col + numCols);
695 }
696 else
697 {
698 // ...or remove the attribute
699 m_attrs.RemoveAt(n);
700 n--;
701 count--;
702 }
703 }
704 }
705 }
706}
707
708int wxGridCellAttrData::FindIndex(int row, int col) const
709{
710 size_t count = m_attrs.GetCount();
711 for ( size_t n = 0; n < count; n++ )
712 {
713 const wxGridCellCoords& coords = m_attrs[n].coords;
714 if ( (coords.GetRow() == row) && (coords.GetCol() == col) )
715 {
716 return n;
717 }
718 }
719
720 return wxNOT_FOUND;
721}
722
723// ----------------------------------------------------------------------------
724// wxGridRowOrColAttrData
725// ----------------------------------------------------------------------------
726
727wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
728{
729 size_t count = m_attrs.GetCount();
730 for ( size_t n = 0; n < count; n++ )
731 {
732 m_attrs[n]->DecRef();
733 }
734}
735
736wxGridCellAttr *wxGridRowOrColAttrData::GetAttr(int rowOrCol) const
737{
738 wxGridCellAttr *attr = NULL;
739
740 int n = m_rowsOrCols.Index(rowOrCol);
741 if ( n != wxNOT_FOUND )
742 {
743 attr = m_attrs[(size_t)n];
744 attr->IncRef();
745 }
746
747 return attr;
748}
749
750void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr *attr, int rowOrCol)
751{
752 int i = m_rowsOrCols.Index(rowOrCol);
753 if ( i == wxNOT_FOUND )
754 {
755 if ( attr )
756 {
757 // store the new attribute, taking its ownership
758 m_rowsOrCols.Add(rowOrCol);
759 m_attrs.Add(attr);
760 }
761 // nothing to remove
762 }
763 else // we have an attribute for this row or column
764 {
765 size_t n = (size_t)i;
766
767 // notice that this code works correctly even when the old attribute is
768 // the same as the new one: as we own of it, we must call DecRef() on
769 // it in any case and this won't result in destruction of the new
770 // attribute if it's the same as old one because it must have ref count
771 // of at least 2 to be passed to us while we keep a reference to it too
772 m_attrs[n]->DecRef();
773
774 if ( attr )
775 {
776 // replace the attribute with the new one
777 m_attrs[n] = attr;
778 }
779 else // remove the attribute
780 {
781 m_rowsOrCols.RemoveAt(n);
782 m_attrs.RemoveAt(n);
783 }
784 }
785}
786
787void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols )
788{
789 size_t count = m_attrs.GetCount();
790 for ( size_t n = 0; n < count; n++ )
791 {
792 int & rowOrCol = m_rowsOrCols[n];
793 if ( (size_t)rowOrCol >= pos )
794 {
795 if ( numRowsOrCols > 0 )
796 {
797 // If rows inserted, include row counter where necessary
798 rowOrCol += numRowsOrCols;
799 }
800 else if ( numRowsOrCols < 0)
801 {
802 // If rows deleted, either decrement row counter (if row still exists)
803 if ((size_t)rowOrCol >= pos - numRowsOrCols)
804 rowOrCol += numRowsOrCols;
805 else
806 {
807 m_rowsOrCols.RemoveAt(n);
808 m_attrs[n]->DecRef();
809 m_attrs.RemoveAt(n);
810 n--;
811 count--;
812 }
813 }
814 }
815 }
816}
817
818// ----------------------------------------------------------------------------
819// wxGridCellAttrProvider
820// ----------------------------------------------------------------------------
821
822wxGridCellAttrProvider::wxGridCellAttrProvider()
823{
824 m_data = NULL;
825}
826
827wxGridCellAttrProvider::~wxGridCellAttrProvider()
828{
829 delete m_data;
830}
831
832void wxGridCellAttrProvider::InitData()
833{
834 m_data = new wxGridCellAttrProviderData;
835}
836
837wxGridCellAttr *wxGridCellAttrProvider::GetAttr(int row, int col,
838 wxGridCellAttr::wxAttrKind kind ) const
839{
840 wxGridCellAttr *attr = NULL;
841 if ( m_data )
842 {
843 switch (kind)
844 {
845 case (wxGridCellAttr::Any):
846 // Get cached merge attributes.
847 // Currently not used as no cache implemented as not mutable
848 // attr = m_data->m_mergeAttr.GetAttr(row, col);
849 if (!attr)
850 {
851 // Basically implement old version.
852 // Also check merge cache, so we don't have to re-merge every time..
853 wxGridCellAttr *attrcell = m_data->m_cellAttrs.GetAttr(row, col);
854 wxGridCellAttr *attrrow = m_data->m_rowAttrs.GetAttr(row);
855 wxGridCellAttr *attrcol = m_data->m_colAttrs.GetAttr(col);
856
857 if ((attrcell != attrrow) && (attrrow != attrcol) && (attrcell != attrcol))
858 {
859 // Two or more are non NULL
860 attr = new wxGridCellAttr;
861 attr->SetKind(wxGridCellAttr::Merged);
862
863 // Order is important..
864 if (attrcell)
865 {
866 attr->MergeWith(attrcell);
867 attrcell->DecRef();
868 }
869 if (attrcol)
870 {
871 attr->MergeWith(attrcol);
872 attrcol->DecRef();
873 }
874 if (attrrow)
875 {
876 attr->MergeWith(attrrow);
877 attrrow->DecRef();
878 }
879
880 // store merge attr if cache implemented
881 //attr->IncRef();
882 //m_data->m_mergeAttr.SetAttr(attr, row, col);
883 }
884 else
885 {
886 // one or none is non null return it or null.
887 if (attrrow)
888 attr = attrrow;
889 if (attrcol)
890 {
891 if (attr)
892 attr->DecRef();
893 attr = attrcol;
894 }
895 if (attrcell)
896 {
897 if (attr)
898 attr->DecRef();
899 attr = attrcell;
900 }
901 }
902 }
903 break;
904
905 case (wxGridCellAttr::Cell):
906 attr = m_data->m_cellAttrs.GetAttr(row, col);
907 break;
908
909 case (wxGridCellAttr::Col):
910 attr = m_data->m_colAttrs.GetAttr(col);
911 break;
912
913 case (wxGridCellAttr::Row):
914 attr = m_data->m_rowAttrs.GetAttr(row);
915 break;
916
917 default:
918 // unused as yet...
919 // (wxGridCellAttr::Default):
920 // (wxGridCellAttr::Merged):
921 break;
922 }
923 }
924
925 return attr;
926}
927
928void wxGridCellAttrProvider::SetAttr(wxGridCellAttr *attr,
929 int row, int col)
930{
931 if ( !m_data )
932 InitData();
933
934 m_data->m_cellAttrs.SetAttr(attr, row, col);
935}
936
937void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr *attr, int row)
938{
939 if ( !m_data )
940 InitData();
941
942 m_data->m_rowAttrs.SetAttr(attr, row);
943}
944
945void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr *attr, int col)
946{
947 if ( !m_data )
948 InitData();
949
950 m_data->m_colAttrs.SetAttr(attr, col);
951}
952
953void wxGridCellAttrProvider::UpdateAttrRows( size_t pos, int numRows )
954{
955 if ( m_data )
956 {
957 m_data->m_cellAttrs.UpdateAttrRows( pos, numRows );
958
959 m_data->m_rowAttrs.UpdateAttrRowsOrCols( pos, numRows );
960 }
961}
962
963void wxGridCellAttrProvider::UpdateAttrCols( size_t pos, int numCols )
964{
965 if ( m_data )
966 {
967 m_data->m_cellAttrs.UpdateAttrCols( pos, numCols );
968
969 m_data->m_colAttrs.UpdateAttrRowsOrCols( pos, numCols );
970 }
971}
972
973const wxGridColumnHeaderRenderer&
974wxGridCellAttrProvider::GetColumnHeaderRenderer(int WXUNUSED(col))
975{
976 return gs_defaultHeaderRenderers.colRenderer;
977}
978
979const wxGridRowHeaderRenderer&
980wxGridCellAttrProvider::GetRowHeaderRenderer(int WXUNUSED(row))
981{
982 return gs_defaultHeaderRenderers.rowRenderer;
983}
984
985const wxGridCornerHeaderRenderer& wxGridCellAttrProvider::GetCornerRenderer()
986{
987 return gs_defaultHeaderRenderers.cornerRenderer;
988}
989
990// ----------------------------------------------------------------------------
991// wxGridTableBase
992// ----------------------------------------------------------------------------
993
994IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase, wxObject )
995
996wxGridTableBase::wxGridTableBase()
997{
998 m_view = NULL;
999 m_attrProvider = NULL;
1000}
1001
1002wxGridTableBase::~wxGridTableBase()
1003{
1004 delete m_attrProvider;
1005}
1006
1007void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider *attrProvider)
1008{
1009 delete m_attrProvider;
1010 m_attrProvider = attrProvider;
1011}
1012
1013bool wxGridTableBase::CanHaveAttributes()
1014{
1015 if ( ! GetAttrProvider() )
1016 {
1017 // use the default attr provider by default
1018 SetAttrProvider(new wxGridCellAttrProvider);
1019 }
1020
1021 return true;
1022}
1023
1024wxGridCellAttr *wxGridTableBase::GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind)
1025{
1026 if ( m_attrProvider )
1027 return m_attrProvider->GetAttr(row, col, kind);
1028 else
1029 return NULL;
1030}
1031
1032void wxGridTableBase::SetAttr(wxGridCellAttr* attr, int row, int col)
1033{
1034 if ( m_attrProvider )
1035 {
1036 if ( attr )
1037 attr->SetKind(wxGridCellAttr::Cell);
1038 m_attrProvider->SetAttr(attr, row, col);
1039 }
1040 else
1041 {
1042 // as we take ownership of the pointer and don't store it, we must
1043 // free it now
1044 wxSafeDecRef(attr);
1045 }
1046}
1047
1048void wxGridTableBase::SetRowAttr(wxGridCellAttr *attr, int row)
1049{
1050 if ( m_attrProvider )
1051 {
1052 attr->SetKind(wxGridCellAttr::Row);
1053 m_attrProvider->SetRowAttr(attr, row);
1054 }
1055 else
1056 {
1057 // as we take ownership of the pointer and don't store it, we must
1058 // free it now
1059 wxSafeDecRef(attr);
1060 }
1061}
1062
1063void wxGridTableBase::SetColAttr(wxGridCellAttr *attr, int col)
1064{
1065 if ( m_attrProvider )
1066 {
1067 attr->SetKind(wxGridCellAttr::Col);
1068 m_attrProvider->SetColAttr(attr, col);
1069 }
1070 else
1071 {
1072 // as we take ownership of the pointer and don't store it, we must
1073 // free it now
1074 wxSafeDecRef(attr);
1075 }
1076}
1077
1078bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos),
1079 size_t WXUNUSED(numRows) )
1080{
1081 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
1082
1083 return false;
1084}
1085
1086bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows) )
1087{
1088 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
1089
1090 return false;
1091}
1092
1093bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos),
1094 size_t WXUNUSED(numRows) )
1095{
1096 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
1097
1098 return false;
1099}
1100
1101bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos),
1102 size_t WXUNUSED(numCols) )
1103{
1104 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
1105
1106 return false;
1107}
1108
1109bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols) )
1110{
1111 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
1112
1113 return false;
1114}
1115
1116bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos),
1117 size_t WXUNUSED(numCols) )
1118{
1119 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
1120
1121 return false;
1122}
1123
1124wxString wxGridTableBase::GetRowLabelValue( int row )
1125{
1126 wxString s;
1127
1128 // RD: Starting the rows at zero confuses users,
1129 // no matter how much it makes sense to us geeks.
1130 s << row + 1;
1131
1132 return s;
1133}
1134
1135wxString wxGridTableBase::GetColLabelValue( int col )
1136{
1137 // default col labels are:
1138 // cols 0 to 25 : A-Z
1139 // cols 26 to 675 : AA-ZZ
1140 // etc.
1141
1142 wxString s;
1143 unsigned int i, n;
1144 for ( n = 1; ; n++ )
1145 {
1146 s += (wxChar) (wxT('A') + (wxChar)(col % 26));
1147 col = col / 26 - 1;
1148 if ( col < 0 )
1149 break;
1150 }
1151
1152 // reverse the string...
1153 wxString s2;
1154 for ( i = 0; i < n; i++ )
1155 {
1156 s2 += s[n - i - 1];
1157 }
1158
1159 return s2;
1160}
1161
1162wxString wxGridTableBase::GetTypeName( int WXUNUSED(row), int WXUNUSED(col) )
1163{
1164 return wxGRID_VALUE_STRING;
1165}
1166
1167bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row), int WXUNUSED(col),
1168 const wxString& typeName )
1169{
1170 return typeName == wxGRID_VALUE_STRING;
1171}
1172
1173bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString& typeName )
1174{
1175 return CanGetValueAs(row, col, typeName);
1176}
1177
1178long wxGridTableBase::GetValueAsLong( int WXUNUSED(row), int WXUNUSED(col) )
1179{
1180 return 0;
1181}
1182
1183double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col) )
1184{
1185 return 0.0;
1186}
1187
1188bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row), int WXUNUSED(col) )
1189{
1190 return false;
1191}
1192
1193void wxGridTableBase::SetValueAsLong( int WXUNUSED(row), int WXUNUSED(col),
1194 long WXUNUSED(value) )
1195{
1196}
1197
1198void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row), int WXUNUSED(col),
1199 double WXUNUSED(value) )
1200{
1201}
1202
1203void wxGridTableBase::SetValueAsBool( int WXUNUSED(row), int WXUNUSED(col),
1204 bool WXUNUSED(value) )
1205{
1206}
1207
1208void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
1209 const wxString& WXUNUSED(typeName) )
1210{
1211 return NULL;
1212}
1213
1214void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row), int WXUNUSED(col),
1215 const wxString& WXUNUSED(typeName),
1216 void* WXUNUSED(value) )
1217{
1218}
1219
1220//////////////////////////////////////////////////////////////////////
1221//
1222// Message class for the grid table to send requests and notifications
1223// to the grid view
1224//
1225
1226wxGridTableMessage::wxGridTableMessage()
1227{
1228 m_table = NULL;
1229 m_id = -1;
1230 m_comInt1 = -1;
1231 m_comInt2 = -1;
1232}
1233
1234wxGridTableMessage::wxGridTableMessage( wxGridTableBase *table, int id,
1235 int commandInt1, int commandInt2 )
1236{
1237 m_table = table;
1238 m_id = id;
1239 m_comInt1 = commandInt1;
1240 m_comInt2 = commandInt2;
1241}
1242
1243//////////////////////////////////////////////////////////////////////
1244//
1245// A basic grid table for string data. An object of this class will
1246// created by wxGrid if you don't specify an alternative table class.
1247//
1248
1249WX_DEFINE_OBJARRAY(wxGridStringArray)
1250
1251IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable, wxGridTableBase )
1252
1253wxGridStringTable::wxGridStringTable()
1254 : wxGridTableBase()
1255{
1256 m_numCols = 0;
1257}
1258
1259wxGridStringTable::wxGridStringTable( int numRows, int numCols )
1260 : wxGridTableBase()
1261{
1262 m_numCols = numCols;
1263
1264 m_data.Alloc( numRows );
1265
1266 wxArrayString sa;
1267 sa.Alloc( numCols );
1268 sa.Add( wxEmptyString, numCols );
1269
1270 m_data.Add( sa, numRows );
1271}
1272
1273wxString wxGridStringTable::GetValue( int row, int col )
1274{
1275 wxCHECK_MSG( (row >= 0 && row < GetNumberRows()) &&
1276 (col >= 0 && col < GetNumberCols()),
1277 wxEmptyString,
1278 wxT("invalid row or column index in wxGridStringTable") );
1279
1280 return m_data[row][col];
1281}
1282
1283void wxGridStringTable::SetValue( int row, int col, const wxString& value )
1284{
1285 wxCHECK_RET( (row >= 0 && row < GetNumberRows()) &&
1286 (col >= 0 && col < GetNumberCols()),
1287 wxT("invalid row or column index in wxGridStringTable") );
1288
1289 m_data[row][col] = value;
1290}
1291
1292void wxGridStringTable::Clear()
1293{
1294 int row, col;
1295 int numRows, numCols;
1296
1297 numRows = m_data.GetCount();
1298 if ( numRows > 0 )
1299 {
1300 numCols = m_data[0].GetCount();
1301
1302 for ( row = 0; row < numRows; row++ )
1303 {
1304 for ( col = 0; col < numCols; col++ )
1305 {
1306 m_data[row][col] = wxEmptyString;
1307 }
1308 }
1309 }
1310}
1311
1312bool wxGridStringTable::InsertRows( size_t pos, size_t numRows )
1313{
1314 size_t curNumRows = m_data.GetCount();
1315 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
1316 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1317
1318 if ( pos >= curNumRows )
1319 {
1320 return AppendRows( numRows );
1321 }
1322
1323 wxArrayString sa;
1324 sa.Alloc( curNumCols );
1325 sa.Add( wxEmptyString, curNumCols );
1326 m_data.Insert( sa, pos, numRows );
1327
1328 if ( GetView() )
1329 {
1330 wxGridTableMessage msg( this,
1331 wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
1332 pos,
1333 numRows );
1334
1335 GetView()->ProcessTableMessage( msg );
1336 }
1337
1338 return true;
1339}
1340
1341bool wxGridStringTable::AppendRows( size_t numRows )
1342{
1343 size_t curNumRows = m_data.GetCount();
1344 size_t curNumCols = ( curNumRows > 0
1345 ? m_data[0].GetCount()
1346 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1347
1348 wxArrayString sa;
1349 if ( curNumCols > 0 )
1350 {
1351 sa.Alloc( curNumCols );
1352 sa.Add( wxEmptyString, curNumCols );
1353 }
1354
1355 m_data.Add( sa, numRows );
1356
1357 if ( GetView() )
1358 {
1359 wxGridTableMessage msg( this,
1360 wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
1361 numRows );
1362
1363 GetView()->ProcessTableMessage( msg );
1364 }
1365
1366 return true;
1367}
1368
1369bool wxGridStringTable::DeleteRows( size_t pos, size_t numRows )
1370{
1371 size_t curNumRows = m_data.GetCount();
1372
1373 if ( pos >= curNumRows )
1374 {
1375 wxFAIL_MSG( wxString::Format
1376 (
1377 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
1378 (unsigned long)pos,
1379 (unsigned long)numRows,
1380 (unsigned long)curNumRows
1381 ) );
1382
1383 return false;
1384 }
1385
1386 if ( numRows > curNumRows - pos )
1387 {
1388 numRows = curNumRows - pos;
1389 }
1390
1391 if ( numRows >= curNumRows )
1392 {
1393 m_data.Clear();
1394 }
1395 else
1396 {
1397 m_data.RemoveAt( pos, numRows );
1398 }
1399
1400 if ( GetView() )
1401 {
1402 wxGridTableMessage msg( this,
1403 wxGRIDTABLE_NOTIFY_ROWS_DELETED,
1404 pos,
1405 numRows );
1406
1407 GetView()->ProcessTableMessage( msg );
1408 }
1409
1410 return true;
1411}
1412
1413bool wxGridStringTable::InsertCols( size_t pos, size_t numCols )
1414{
1415 size_t row, col;
1416
1417 size_t curNumRows = m_data.GetCount();
1418 size_t curNumCols = ( curNumRows > 0
1419 ? m_data[0].GetCount()
1420 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1421
1422 if ( pos >= curNumCols )
1423 {
1424 return AppendCols( numCols );
1425 }
1426
1427 if ( !m_colLabels.IsEmpty() )
1428 {
1429 m_colLabels.Insert( wxEmptyString, pos, numCols );
1430
1431 size_t i;
1432 for ( i = pos; i < pos + numCols; i++ )
1433 m_colLabels[i] = wxGridTableBase::GetColLabelValue( i );
1434 }
1435
1436 for ( row = 0; row < curNumRows; row++ )
1437 {
1438 for ( col = pos; col < pos + numCols; col++ )
1439 {
1440 m_data[row].Insert( wxEmptyString, col );
1441 }
1442 }
1443
1444 m_numCols += numCols;
1445
1446 if ( GetView() )
1447 {
1448 wxGridTableMessage msg( this,
1449 wxGRIDTABLE_NOTIFY_COLS_INSERTED,
1450 pos,
1451 numCols );
1452
1453 GetView()->ProcessTableMessage( msg );
1454 }
1455
1456 return true;
1457}
1458
1459bool wxGridStringTable::AppendCols( size_t numCols )
1460{
1461 size_t row;
1462
1463 size_t curNumRows = m_data.GetCount();
1464
1465 for ( row = 0; row < curNumRows; row++ )
1466 {
1467 m_data[row].Add( wxEmptyString, numCols );
1468 }
1469
1470 m_numCols += numCols;
1471
1472 if ( GetView() )
1473 {
1474 wxGridTableMessage msg( this,
1475 wxGRIDTABLE_NOTIFY_COLS_APPENDED,
1476 numCols );
1477
1478 GetView()->ProcessTableMessage( msg );
1479 }
1480
1481 return true;
1482}
1483
1484bool wxGridStringTable::DeleteCols( size_t pos, size_t numCols )
1485{
1486 size_t row;
1487
1488 size_t curNumRows = m_data.GetCount();
1489 size_t curNumCols = ( curNumRows > 0 ? m_data[0].GetCount() :
1490 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1491
1492 if ( pos >= curNumCols )
1493 {
1494 wxFAIL_MSG( wxString::Format
1495 (
1496 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
1497 (unsigned long)pos,
1498 (unsigned long)numCols,
1499 (unsigned long)curNumCols
1500 ) );
1501 return false;
1502 }
1503
1504 int colID;
1505 if ( GetView() )
1506 colID = GetView()->GetColAt( pos );
1507 else
1508 colID = pos;
1509
1510 if ( numCols > curNumCols - colID )
1511 {
1512 numCols = curNumCols - colID;
1513 }
1514
1515 if ( !m_colLabels.IsEmpty() )
1516 {
1517 // m_colLabels stores just as many elements as it needs, e.g. if only
1518 // the label of the first column had been set it would have only one
1519 // element and not numCols, so account for it
1520 int nToRm = m_colLabels.size() - colID;
1521 if ( nToRm > 0 )
1522 m_colLabels.RemoveAt( colID, nToRm );
1523 }
1524
1525 if ( numCols >= curNumCols )
1526 {
1527 for ( row = 0; row < curNumRows; row++ )
1528 {
1529 m_data[row].Clear();
1530 }
1531
1532 m_numCols = 0;
1533 }
1534 else // something will be left
1535 {
1536 for ( row = 0; row < curNumRows; row++ )
1537 {
1538 m_data[row].RemoveAt( colID, numCols );
1539 }
1540
1541 m_numCols -= numCols;
1542 }
1543
1544 if ( GetView() )
1545 {
1546 wxGridTableMessage msg( this,
1547 wxGRIDTABLE_NOTIFY_COLS_DELETED,
1548 pos,
1549 numCols );
1550
1551 GetView()->ProcessTableMessage( msg );
1552 }
1553
1554 return true;
1555}
1556
1557wxString wxGridStringTable::GetRowLabelValue( int row )
1558{
1559 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
1560 {
1561 // using default label
1562 //
1563 return wxGridTableBase::GetRowLabelValue( row );
1564 }
1565 else
1566 {
1567 return m_rowLabels[row];
1568 }
1569}
1570
1571wxString wxGridStringTable::GetColLabelValue( int col )
1572{
1573 if ( col > (int)(m_colLabels.GetCount()) - 1 )
1574 {
1575 // using default label
1576 //
1577 return wxGridTableBase::GetColLabelValue( col );
1578 }
1579 else
1580 {
1581 return m_colLabels[col];
1582 }
1583}
1584
1585void wxGridStringTable::SetRowLabelValue( int row, const wxString& value )
1586{
1587 if ( row > (int)(m_rowLabels.GetCount()) - 1 )
1588 {
1589 int n = m_rowLabels.GetCount();
1590 int i;
1591
1592 for ( i = n; i <= row; i++ )
1593 {
1594 m_rowLabels.Add( wxGridTableBase::GetRowLabelValue(i) );
1595 }
1596 }
1597
1598 m_rowLabels[row] = value;
1599}
1600
1601void wxGridStringTable::SetColLabelValue( int col, const wxString& value )
1602{
1603 if ( col > (int)(m_colLabels.GetCount()) - 1 )
1604 {
1605 int n = m_colLabels.GetCount();
1606 int i;
1607
1608 for ( i = n; i <= col; i++ )
1609 {
1610 m_colLabels.Add( wxGridTableBase::GetColLabelValue(i) );
1611 }
1612 }
1613
1614 m_colLabels[col] = value;
1615}
1616
1617
1618//////////////////////////////////////////////////////////////////////
1619//////////////////////////////////////////////////////////////////////
1620
1621BEGIN_EVENT_TABLE(wxGridSubwindow, wxWindow)
1622 EVT_MOUSE_CAPTURE_LOST(wxGridSubwindow::OnMouseCaptureLost)
1623END_EVENT_TABLE()
1624
1625void wxGridSubwindow::OnMouseCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
1626{
1627 m_owner->CancelMouseCapture();
1628}
1629
1630BEGIN_EVENT_TABLE( wxGridRowLabelWindow, wxGridSubwindow )
1631 EVT_PAINT( wxGridRowLabelWindow::OnPaint )
1632 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel )
1633 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent )
1634END_EVENT_TABLE()
1635
1636void wxGridRowLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
1637{
1638 wxPaintDC dc(this);
1639
1640 // NO - don't do this because it will set both the x and y origin
1641 // coords to match the parent scrolled window and we just want to
1642 // set the y coord - MB
1643 //
1644 // m_owner->PrepareDC( dc );
1645
1646 int x, y;
1647 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
1648 wxPoint pt = dc.GetDeviceOrigin();
1649 dc.SetDeviceOrigin( pt.x, pt.y-y );
1650
1651 wxArrayInt rows = m_owner->CalcRowLabelsExposed( GetUpdateRegion() );
1652 m_owner->DrawRowLabels( dc, rows );
1653}
1654
1655void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent& event )
1656{
1657 m_owner->ProcessRowLabelMouseEvent( event );
1658}
1659
1660void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent& event )
1661{
1662 if (!m_owner->GetEventHandler()->ProcessEvent( event ))
1663 event.Skip();
1664}
1665
1666//////////////////////////////////////////////////////////////////////
1667
1668BEGIN_EVENT_TABLE( wxGridColLabelWindow, wxGridSubwindow )
1669 EVT_PAINT( wxGridColLabelWindow::OnPaint )
1670 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel )
1671 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent )
1672END_EVENT_TABLE()
1673
1674void wxGridColLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
1675{
1676 wxPaintDC dc(this);
1677
1678 // NO - don't do this because it will set both the x and y origin
1679 // coords to match the parent scrolled window and we just want to
1680 // set the x coord - MB
1681 //
1682 // m_owner->PrepareDC( dc );
1683
1684 int x, y;
1685 m_owner->CalcUnscrolledPosition( 0, 0, &x, &y );
1686 wxPoint pt = dc.GetDeviceOrigin();
1687 if (GetLayoutDirection() == wxLayout_RightToLeft)
1688 dc.SetDeviceOrigin( pt.x+x, pt.y );
1689 else
1690 dc.SetDeviceOrigin( pt.x-x, pt.y );
1691
1692 wxArrayInt cols = m_owner->CalcColLabelsExposed( GetUpdateRegion() );
1693 m_owner->DrawColLabels( dc, cols );
1694}
1695
1696void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent& event )
1697{
1698 m_owner->ProcessColLabelMouseEvent( event );
1699}
1700
1701void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent& event )
1702{
1703 if (!m_owner->GetEventHandler()->ProcessEvent( event ))
1704 event.Skip();
1705}
1706
1707//////////////////////////////////////////////////////////////////////
1708
1709BEGIN_EVENT_TABLE( wxGridCornerLabelWindow, wxGridSubwindow )
1710 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel )
1711 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent )
1712 EVT_PAINT( wxGridCornerLabelWindow::OnPaint )
1713END_EVENT_TABLE()
1714
1715void wxGridCornerLabelWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
1716{
1717 wxPaintDC dc(this);
1718
1719 m_owner->DrawCornerLabel(dc);
1720}
1721
1722void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent& event )
1723{
1724 m_owner->ProcessCornerLabelMouseEvent( event );
1725}
1726
1727void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent& event )
1728{
1729 if (!m_owner->GetEventHandler()->ProcessEvent(event))
1730 event.Skip();
1731}
1732
1733//////////////////////////////////////////////////////////////////////
1734
1735BEGIN_EVENT_TABLE( wxGridWindow, wxGridSubwindow )
1736 EVT_PAINT( wxGridWindow::OnPaint )
1737 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel )
1738 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent )
1739 EVT_KEY_DOWN( wxGridWindow::OnKeyDown )
1740 EVT_KEY_UP( wxGridWindow::OnKeyUp )
1741 EVT_CHAR( wxGridWindow::OnChar )
1742 EVT_SET_FOCUS( wxGridWindow::OnFocus )
1743 EVT_KILL_FOCUS( wxGridWindow::OnFocus )
1744 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground )
1745END_EVENT_TABLE()
1746
1747void wxGridWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1748{
1749 wxPaintDC dc( this );
1750 m_owner->PrepareDC( dc );
1751 wxRegion reg = GetUpdateRegion();
1752 wxGridCellCoordsArray dirtyCells = m_owner->CalcCellsExposed( reg );
1753 m_owner->DrawGridCellArea( dc, dirtyCells );
1754
1755 m_owner->DrawGridSpace( dc );
1756
1757 m_owner->DrawAllGridLines( dc, reg );
1758
1759 m_owner->DrawHighlight( dc, dirtyCells );
1760}
1761
1762void wxGridWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
1763{
1764 wxWindow::ScrollWindow( dx, dy, rect );
1765 m_owner->GetGridRowLabelWindow()->ScrollWindow( 0, dy, rect );
1766 m_owner->GetGridColLabelWindow()->ScrollWindow( dx, 0, rect );
1767}
1768
1769void wxGridWindow::OnMouseEvent( wxMouseEvent& event )
1770{
1771 if (event.ButtonDown(wxMOUSE_BTN_LEFT) && FindFocus() != this)
1772 SetFocus();
1773
1774 m_owner->ProcessGridCellMouseEvent( event );
1775}
1776
1777void wxGridWindow::OnMouseWheel( wxMouseEvent& event )
1778{
1779 if (!m_owner->GetEventHandler()->ProcessEvent( event ))
1780 event.Skip();
1781}
1782
1783// This seems to be required for wxMotif/wxGTK otherwise the mouse
1784// cursor must be in the cell edit control to get key events
1785//
1786void wxGridWindow::OnKeyDown( wxKeyEvent& event )
1787{
1788 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
1789 event.Skip();
1790}
1791
1792void wxGridWindow::OnKeyUp( wxKeyEvent& event )
1793{
1794 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
1795 event.Skip();
1796}
1797
1798void wxGridWindow::OnChar( wxKeyEvent& event )
1799{
1800 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
1801 event.Skip();
1802}
1803
1804void wxGridWindow::OnEraseBackground( wxEraseEvent& WXUNUSED(event) )
1805{
1806}
1807
1808void wxGridWindow::OnFocus(wxFocusEvent& event)
1809{
1810 // and if we have any selection, it has to be repainted, because it
1811 // uses different colour when the grid is not focused:
1812 if ( m_owner->IsSelection() )
1813 {
1814 Refresh();
1815 }
1816 else
1817 {
1818 // NB: Note that this code is in "else" branch only because the other
1819 // branch refreshes everything and so there's no point in calling
1820 // Refresh() again, *not* because it should only be done if
1821 // !IsSelection(). If the above code is ever optimized to refresh
1822 // only selected area, this needs to be moved out of the "else"
1823 // branch so that it's always executed.
1824
1825 // current cell cursor {dis,re}appears on focus change:
1826 const wxGridCellCoords cursorCoords(m_owner->GetGridCursorRow(),
1827 m_owner->GetGridCursorCol());
1828 const wxRect cursor =
1829 m_owner->BlockToDeviceRect(cursorCoords, cursorCoords);
1830 Refresh(true, &cursor);
1831 }
1832
1833 if ( !m_owner->GetEventHandler()->ProcessEvent( event ) )
1834 event.Skip();
1835}
1836
1837#define internalXToCol(x) XToCol(x, true)
1838#define internalYToRow(y) YToRow(y, true)
1839
1840/////////////////////////////////////////////////////////////////////
1841
1842BEGIN_EVENT_TABLE( wxGrid, wxScrolledWindow )
1843 EVT_PAINT( wxGrid::OnPaint )
1844 EVT_SIZE( wxGrid::OnSize )
1845 EVT_KEY_DOWN( wxGrid::OnKeyDown )
1846 EVT_KEY_UP( wxGrid::OnKeyUp )
1847 EVT_CHAR ( wxGrid::OnChar )
1848 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground )
1849END_EVENT_TABLE()
1850
1851bool wxGrid::Create(wxWindow *parent, wxWindowID id,
1852 const wxPoint& pos, const wxSize& size,
1853 long style, const wxString& name)
1854{
1855 if (!wxScrolledWindow::Create(parent, id, pos, size,
1856 style | wxWANTS_CHARS, name))
1857 return false;
1858
1859 m_colMinWidths = wxLongToLongHashMap(GRID_HASH_SIZE);
1860 m_rowMinHeights = wxLongToLongHashMap(GRID_HASH_SIZE);
1861
1862 Create();
1863 SetInitialSize(size);
1864 CalcDimensions();
1865
1866 return true;
1867}
1868
1869wxGrid::~wxGrid()
1870{
1871 if ( m_winCapture )
1872 m_winCapture->ReleaseMouse();
1873
1874 // Ensure that the editor control is destroyed before the grid is,
1875 // otherwise we crash later when the editor tries to do something with the
1876 // half destroyed grid
1877 HideCellEditControl();
1878
1879 // Must do this or ~wxScrollHelper will pop the wrong event handler
1880 SetTargetWindow(this);
1881 ClearAttrCache();
1882 wxSafeDecRef(m_defaultCellAttr);
1883
1884#ifdef DEBUG_ATTR_CACHE
1885 size_t total = gs_nAttrCacheHits + gs_nAttrCacheMisses;
1886 wxPrintf(wxT("wxGrid attribute cache statistics: "
1887 "total: %u, hits: %u (%u%%)\n"),
1888 total, gs_nAttrCacheHits,
1889 total ? (gs_nAttrCacheHits*100) / total : 0);
1890#endif
1891
1892 // if we own the table, just delete it, otherwise at least don't leave it
1893 // with dangling view pointer
1894 if ( m_ownTable )
1895 delete m_table;
1896 else if ( m_table && m_table->GetView() == this )
1897 m_table->SetView(NULL);
1898
1899 delete m_typeRegistry;
1900 delete m_selection;
1901
1902 delete m_setFixedRows;
1903 delete m_setFixedCols;
1904}
1905
1906//
1907// ----- internal init and update functions
1908//
1909
1910// NOTE: If using the default visual attributes works everywhere then this can
1911// be removed as well as the #else cases below.
1912#define _USE_VISATTR 0
1913
1914void wxGrid::Create()
1915{
1916 // create the type registry
1917 m_typeRegistry = new wxGridTypeRegistry;
1918
1919 m_cellEditCtrlEnabled = false;
1920
1921 m_defaultCellAttr = new wxGridCellAttr();
1922
1923 // Set default cell attributes
1924 m_defaultCellAttr->SetDefAttr(m_defaultCellAttr);
1925 m_defaultCellAttr->SetKind(wxGridCellAttr::Default);
1926 m_defaultCellAttr->SetFont(GetFont());
1927 m_defaultCellAttr->SetAlignment(wxALIGN_LEFT, wxALIGN_TOP);
1928 m_defaultCellAttr->SetRenderer(new wxGridCellStringRenderer);
1929 m_defaultCellAttr->SetEditor(new wxGridCellTextEditor);
1930
1931#if _USE_VISATTR
1932 wxVisualAttributes gva = wxListBox::GetClassDefaultAttributes();
1933 wxVisualAttributes lva = wxPanel::GetClassDefaultAttributes();
1934
1935 m_defaultCellAttr->SetTextColour(gva.colFg);
1936 m_defaultCellAttr->SetBackgroundColour(gva.colBg);
1937
1938#else
1939 m_defaultCellAttr->SetTextColour(
1940 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
1941 m_defaultCellAttr->SetBackgroundColour(
1942 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
1943#endif
1944
1945 m_numRows = 0;
1946 m_numCols = 0;
1947 m_currentCellCoords = wxGridNoCellCoords;
1948
1949 // subwindow components that make up the wxGrid
1950 m_rowLabelWin = new wxGridRowLabelWindow(this);
1951 CreateColumnWindow();
1952 m_cornerLabelWin = new wxGridCornerLabelWindow(this);
1953 m_gridWin = new wxGridWindow( this );
1954
1955 SetTargetWindow( m_gridWin );
1956
1957#if _USE_VISATTR
1958 wxColour gfg = gva.colFg;
1959 wxColour gbg = gva.colBg;
1960 wxColour lfg = lva.colFg;
1961 wxColour lbg = lva.colBg;
1962#else
1963 wxColour gfg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
1964 wxColour gbg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
1965 wxColour lfg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
1966 wxColour lbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
1967#endif
1968
1969 m_cornerLabelWin->SetOwnForegroundColour(lfg);
1970 m_cornerLabelWin->SetOwnBackgroundColour(lbg);
1971 m_rowLabelWin->SetOwnForegroundColour(lfg);
1972 m_rowLabelWin->SetOwnBackgroundColour(lbg);
1973 m_colWindow->SetOwnForegroundColour(lfg);
1974 m_colWindow->SetOwnBackgroundColour(lbg);
1975
1976 m_gridWin->SetOwnForegroundColour(gfg);
1977 m_gridWin->SetOwnBackgroundColour(gbg);
1978
1979 m_labelBackgroundColour = m_rowLabelWin->GetBackgroundColour();
1980 m_labelTextColour = m_rowLabelWin->GetForegroundColour();
1981
1982 // now that we have the grid window, use its font to compute the default
1983 // row height
1984 m_defaultRowHeight = m_gridWin->GetCharHeight();
1985#if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
1986 m_defaultRowHeight += 8;
1987#else
1988 m_defaultRowHeight += 4;
1989#endif
1990
1991}
1992
1993void wxGrid::CreateColumnWindow()
1994{
1995 if ( m_useNativeHeader )
1996 {
1997 m_colWindow = new wxGridHeaderCtrl(this);
1998 m_colLabelHeight = m_colWindow->GetBestSize().y;
1999 }
2000 else // draw labels ourselves
2001 {
2002 m_colWindow = new wxGridColLabelWindow(this);
2003 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
2004 }
2005}
2006
2007bool wxGrid::CreateGrid( int numRows, int numCols,
2008 wxGridSelectionModes selmode )
2009{
2010 wxCHECK_MSG( !m_created,
2011 false,
2012 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
2013
2014 return SetTable(new wxGridStringTable(numRows, numCols), true, selmode);
2015}
2016
2017void wxGrid::SetSelectionMode(wxGridSelectionModes selmode)
2018{
2019 wxCHECK_RET( m_created,
2020 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
2021
2022 m_selection->SetSelectionMode( selmode );
2023}
2024
2025wxGrid::wxGridSelectionModes wxGrid::GetSelectionMode() const
2026{
2027 wxCHECK_MSG( m_created, wxGridSelectCells,
2028 wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
2029
2030 return m_selection->GetSelectionMode();
2031}
2032
2033bool
2034wxGrid::SetTable(wxGridTableBase *table,
2035 bool takeOwnership,
2036 wxGrid::wxGridSelectionModes selmode )
2037{
2038 bool checkSelection = false;
2039 if ( m_created )
2040 {
2041 // stop all processing
2042 m_created = false;
2043
2044 if (m_table)
2045 {
2046 m_table->SetView(0);
2047 if( m_ownTable )
2048 delete m_table;
2049 m_table = NULL;
2050 }
2051
2052 wxDELETE(m_selection);
2053
2054 m_ownTable = false;
2055 m_numRows = 0;
2056 m_numCols = 0;
2057 checkSelection = true;
2058
2059 // kill row and column size arrays
2060 m_colWidths.Empty();
2061 m_colRights.Empty();
2062 m_rowHeights.Empty();
2063 m_rowBottoms.Empty();
2064 }
2065
2066 if (table)
2067 {
2068 m_numRows = table->GetNumberRows();
2069 m_numCols = table->GetNumberCols();
2070
2071 if ( m_useNativeHeader )
2072 GetGridColHeader()->SetColumnCount(m_numCols);
2073
2074 m_table = table;
2075 m_table->SetView( this );
2076 m_ownTable = takeOwnership;
2077 m_selection = new wxGridSelection( this, selmode );
2078 if (checkSelection)
2079 {
2080 // If the newly set table is smaller than the
2081 // original one current cell and selection regions
2082 // might be invalid,
2083 m_selectedBlockCorner = wxGridNoCellCoords;
2084 m_currentCellCoords =
2085 wxGridCellCoords(wxMin(m_numRows, m_currentCellCoords.GetRow()),
2086 wxMin(m_numCols, m_currentCellCoords.GetCol()));
2087 if (m_selectedBlockTopLeft.GetRow() >= m_numRows ||
2088 m_selectedBlockTopLeft.GetCol() >= m_numCols)
2089 {
2090 m_selectedBlockTopLeft = wxGridNoCellCoords;
2091 m_selectedBlockBottomRight = wxGridNoCellCoords;
2092 }
2093 else
2094 m_selectedBlockBottomRight =
2095 wxGridCellCoords(wxMin(m_numRows,
2096 m_selectedBlockBottomRight.GetRow()),
2097 wxMin(m_numCols,
2098 m_selectedBlockBottomRight.GetCol()));
2099 }
2100 CalcDimensions();
2101
2102 m_created = true;
2103 }
2104
2105 return m_created;
2106}
2107
2108void wxGrid::Init()
2109{
2110 m_created = false;
2111
2112 m_cornerLabelWin = NULL;
2113 m_rowLabelWin = NULL;
2114 m_colWindow = NULL;
2115 m_gridWin = NULL;
2116
2117 m_table = NULL;
2118 m_ownTable = false;
2119
2120 m_selection = NULL;
2121 m_defaultCellAttr = NULL;
2122 m_typeRegistry = NULL;
2123 m_winCapture = NULL;
2124
2125 m_rowLabelWidth = WXGRID_DEFAULT_ROW_LABEL_WIDTH;
2126 m_colLabelHeight = WXGRID_DEFAULT_COL_LABEL_HEIGHT;
2127
2128 m_setFixedRows =
2129 m_setFixedCols = NULL;
2130
2131 // init attr cache
2132 m_attrCache.row = -1;
2133 m_attrCache.col = -1;
2134 m_attrCache.attr = NULL;
2135
2136 m_labelFont = GetFont();
2137 m_labelFont.SetWeight( wxBOLD );
2138
2139 m_rowLabelHorizAlign = wxALIGN_CENTRE;
2140 m_rowLabelVertAlign = wxALIGN_CENTRE;
2141
2142 m_colLabelHorizAlign = wxALIGN_CENTRE;
2143 m_colLabelVertAlign = wxALIGN_CENTRE;
2144 m_colLabelTextOrientation = wxHORIZONTAL;
2145
2146 m_defaultColWidth = WXGRID_DEFAULT_COL_WIDTH;
2147 m_defaultRowHeight = 0; // this will be initialized after creation
2148
2149 m_minAcceptableColWidth = WXGRID_MIN_COL_WIDTH;
2150 m_minAcceptableRowHeight = WXGRID_MIN_ROW_HEIGHT;
2151
2152 m_gridLineColour = wxColour( 192,192,192 );
2153 m_gridLinesEnabled = true;
2154 m_gridLinesClipHorz =
2155 m_gridLinesClipVert = true;
2156 m_cellHighlightColour = *wxBLACK;
2157 m_cellHighlightPenWidth = 2;
2158 m_cellHighlightROPenWidth = 1;
2159
2160 m_canDragColMove = false;
2161
2162 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
2163 m_winCapture = NULL;
2164 m_canDragRowSize = true;
2165 m_canDragColSize = true;
2166 m_canDragGridSize = true;
2167 m_canDragCell = false;
2168 m_dragLastPos = -1;
2169 m_dragRowOrCol = -1;
2170 m_isDragging = false;
2171 m_startDragPos = wxDefaultPosition;
2172
2173 m_sortCol = wxNOT_FOUND;
2174 m_sortIsAscending = true;
2175
2176 m_useNativeHeader =
2177 m_nativeColumnLabels = false;
2178
2179 m_waitForSlowClick = false;
2180
2181 m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
2182 m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
2183
2184 m_currentCellCoords = wxGridNoCellCoords;
2185
2186 m_selectedBlockTopLeft =
2187 m_selectedBlockBottomRight =
2188 m_selectedBlockCorner = wxGridNoCellCoords;
2189
2190 m_selectionBackground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
2191 m_selectionForeground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
2192
2193 m_editable = true; // default for whole grid
2194
2195 m_inOnKeyDown = false;
2196 m_batchCount = 0;
2197
2198 m_extraWidth =
2199 m_extraHeight = 0;
2200
2201 // we can't call SetScrollRate() as the window isn't created yet but OTOH
2202 // we don't need to call it neither as the scroll position is (0, 0) right
2203 // now anyhow, so just set the parameters directly
2204 m_xScrollPixelsPerLine = GRID_SCROLL_LINE_X;
2205 m_yScrollPixelsPerLine = GRID_SCROLL_LINE_Y;
2206}
2207
2208// ----------------------------------------------------------------------------
2209// the idea is to call these functions only when necessary because they create
2210// quite big arrays which eat memory mostly unnecessary - in particular, if
2211// default widths/heights are used for all rows/columns, we may not use these
2212// arrays at all
2213//
2214// with some extra code, it should be possible to only store the widths/heights
2215// different from default ones (resulting in space savings for huge grids) but
2216// this is not done currently
2217// ----------------------------------------------------------------------------
2218
2219void wxGrid::InitRowHeights()
2220{
2221 m_rowHeights.Empty();
2222 m_rowBottoms.Empty();
2223
2224 m_rowHeights.Alloc( m_numRows );
2225 m_rowBottoms.Alloc( m_numRows );
2226
2227 m_rowHeights.Add( m_defaultRowHeight, m_numRows );
2228
2229 int rowBottom = 0;
2230 for ( int i = 0; i < m_numRows; i++ )
2231 {
2232 rowBottom += m_defaultRowHeight;
2233 m_rowBottoms.Add( rowBottom );
2234 }
2235}
2236
2237void wxGrid::InitColWidths()
2238{
2239 m_colWidths.Empty();
2240 m_colRights.Empty();
2241
2242 m_colWidths.Alloc( m_numCols );
2243 m_colRights.Alloc( m_numCols );
2244
2245 m_colWidths.Add( m_defaultColWidth, m_numCols );
2246
2247 for ( int i = 0; i < m_numCols; i++ )
2248 {
2249 int colRight = ( GetColPos( i ) + 1 ) * m_defaultColWidth;
2250 m_colRights.Add( colRight );
2251 }
2252}
2253
2254int wxGrid::GetColWidth(int col) const
2255{
2256 return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
2257}
2258
2259int wxGrid::GetColLeft(int col) const
2260{
2261 return m_colRights.IsEmpty() ? GetColPos( col ) * m_defaultColWidth
2262 : m_colRights[col] - m_colWidths[col];
2263}
2264
2265int wxGrid::GetColRight(int col) const
2266{
2267 return m_colRights.IsEmpty() ? (GetColPos( col ) + 1) * m_defaultColWidth
2268 : m_colRights[col];
2269}
2270
2271int wxGrid::GetRowHeight(int row) const
2272{
2273 return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
2274}
2275
2276int wxGrid::GetRowTop(int row) const
2277{
2278 return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
2279 : m_rowBottoms[row] - m_rowHeights[row];
2280}
2281
2282int wxGrid::GetRowBottom(int row) const
2283{
2284 return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
2285 : m_rowBottoms[row];
2286}
2287
2288void wxGrid::CalcDimensions()
2289{
2290 // compute the size of the scrollable area
2291 int w = m_numCols > 0 ? GetColRight(GetColAt(m_numCols - 1)) : 0;
2292 int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
2293
2294 w += m_extraWidth;
2295 h += m_extraHeight;
2296
2297 // take into account editor if shown
2298 if ( IsCellEditControlShown() )
2299 {
2300 int w2, h2;
2301 int r = m_currentCellCoords.GetRow();
2302 int c = m_currentCellCoords.GetCol();
2303 int x = GetColLeft(c);
2304 int y = GetRowTop(r);
2305
2306 // how big is the editor
2307 wxGridCellAttr* attr = GetCellAttr(r, c);
2308 wxGridCellEditor* editor = attr->GetEditor(this, r, c);
2309 editor->GetControl()->GetSize(&w2, &h2);
2310 w2 += x;
2311 h2 += y;
2312 if ( w2 > w )
2313 w = w2;
2314 if ( h2 > h )
2315 h = h2;
2316 editor->DecRef();
2317 attr->DecRef();
2318 }
2319
2320 // preserve (more or less) the previous position
2321 int x, y;
2322 GetViewStart( &x, &y );
2323
2324 // ensure the position is valid for the new scroll ranges
2325 if ( x >= w )
2326 x = wxMax( w - 1, 0 );
2327 if ( y >= h )
2328 y = wxMax( h - 1, 0 );
2329
2330 // update the virtual size and refresh the scrollbars to reflect it
2331 m_gridWin->SetVirtualSize(w, h);
2332 Scroll(x, y);
2333 AdjustScrollbars();
2334
2335 // if our OnSize() hadn't been called (it would if we have scrollbars), we
2336 // still must reposition the children
2337 CalcWindowSizes();
2338}
2339
2340wxSize wxGrid::GetSizeAvailableForScrollTarget(const wxSize& size)
2341{
2342 wxSize sizeGridWin(size);
2343 sizeGridWin.x -= m_rowLabelWidth;
2344 sizeGridWin.y -= m_colLabelHeight;
2345
2346 return sizeGridWin;
2347}
2348
2349void wxGrid::CalcWindowSizes()
2350{
2351 // escape if the window is has not been fully created yet
2352
2353 if ( m_cornerLabelWin == NULL )
2354 return;
2355
2356 int cw, ch;
2357 GetClientSize( &cw, &ch );
2358
2359 // the grid may be too small to have enough space for the labels yet, don't
2360 // size the windows to negative sizes in this case
2361 int gw = cw - m_rowLabelWidth;
2362 int gh = ch - m_colLabelHeight;
2363 if (gw < 0)
2364 gw = 0;
2365 if (gh < 0)
2366 gh = 0;
2367
2368 if ( m_cornerLabelWin && m_cornerLabelWin->IsShown() )
2369 m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
2370
2371 if ( m_colWindow && m_colWindow->IsShown() )
2372 m_colWindow->SetSize( m_rowLabelWidth, 0, gw, m_colLabelHeight );
2373
2374 if ( m_rowLabelWin && m_rowLabelWin->IsShown() )
2375 m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, gh );
2376
2377 if ( m_gridWin && m_gridWin->IsShown() )
2378 m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, gw, gh );
2379}
2380
2381// this is called when the grid table sends a message
2382// to indicate that it has been redimensioned
2383//
2384bool wxGrid::Redimension( wxGridTableMessage& msg )
2385{
2386 int i;
2387 bool result = false;
2388
2389 // Clear the attribute cache as the attribute might refer to a different
2390 // cell than stored in the cache after adding/removing rows/columns.
2391 ClearAttrCache();
2392
2393 // By the same reasoning, the editor should be dismissed if columns are
2394 // added or removed. And for consistency, it should IMHO always be
2395 // removed, not only if the cell "underneath" it actually changes.
2396 // For now, I intentionally do not save the editor's content as the
2397 // cell it might want to save that stuff to might no longer exist.
2398 HideCellEditControl();
2399
2400 switch ( msg.GetId() )
2401 {
2402 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
2403 {
2404 size_t pos = msg.GetCommandInt();
2405 int numRows = msg.GetCommandInt2();
2406
2407 m_numRows += numRows;
2408
2409 if ( !m_rowHeights.IsEmpty() )
2410 {
2411 m_rowHeights.Insert( m_defaultRowHeight, pos, numRows );
2412 m_rowBottoms.Insert( 0, pos, numRows );
2413
2414 int bottom = 0;
2415 if ( pos > 0 )
2416 bottom = m_rowBottoms[pos - 1];
2417
2418 for ( i = pos; i < m_numRows; i++ )
2419 {
2420 bottom += m_rowHeights[i];
2421 m_rowBottoms[i] = bottom;
2422 }
2423 }
2424
2425 if ( m_currentCellCoords == wxGridNoCellCoords )
2426 {
2427 // if we have just inserted cols into an empty grid the current
2428 // cell will be undefined...
2429 //
2430 SetCurrentCell( 0, 0 );
2431 }
2432
2433 if ( m_selection )
2434 m_selection->UpdateRows( pos, numRows );
2435 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
2436 if (attrProvider)
2437 attrProvider->UpdateAttrRows( pos, numRows );
2438
2439 if ( !GetBatchCount() )
2440 {
2441 CalcDimensions();
2442 m_rowLabelWin->Refresh();
2443 }
2444 }
2445 result = true;
2446 break;
2447
2448 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
2449 {
2450 int numRows = msg.GetCommandInt();
2451 int oldNumRows = m_numRows;
2452 m_numRows += numRows;
2453
2454 if ( !m_rowHeights.IsEmpty() )
2455 {
2456 m_rowHeights.Add( m_defaultRowHeight, numRows );
2457 m_rowBottoms.Add( 0, numRows );
2458
2459 int bottom = 0;
2460 if ( oldNumRows > 0 )
2461 bottom = m_rowBottoms[oldNumRows - 1];
2462
2463 for ( i = oldNumRows; i < m_numRows; i++ )
2464 {
2465 bottom += m_rowHeights[i];
2466 m_rowBottoms[i] = bottom;
2467 }
2468 }
2469
2470 if ( m_currentCellCoords == wxGridNoCellCoords )
2471 {
2472 // if we have just inserted cols into an empty grid the current
2473 // cell will be undefined...
2474 //
2475 SetCurrentCell( 0, 0 );
2476 }
2477
2478 if ( !GetBatchCount() )
2479 {
2480 CalcDimensions();
2481 m_rowLabelWin->Refresh();
2482 }
2483 }
2484 result = true;
2485 break;
2486
2487 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
2488 {
2489 size_t pos = msg.GetCommandInt();
2490 int numRows = msg.GetCommandInt2();
2491 m_numRows -= numRows;
2492
2493 if ( !m_rowHeights.IsEmpty() )
2494 {
2495 m_rowHeights.RemoveAt( pos, numRows );
2496 m_rowBottoms.RemoveAt( pos, numRows );
2497
2498 int h = 0;
2499 for ( i = 0; i < m_numRows; i++ )
2500 {
2501 h += m_rowHeights[i];
2502 m_rowBottoms[i] = h;
2503 }
2504 }
2505
2506 if ( !m_numRows )
2507 {
2508 m_currentCellCoords = wxGridNoCellCoords;
2509 }
2510 else
2511 {
2512 if ( m_currentCellCoords.GetRow() >= m_numRows )
2513 m_currentCellCoords.Set( 0, 0 );
2514 }
2515
2516 if ( m_selection )
2517 m_selection->UpdateRows( pos, -((int)numRows) );
2518 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
2519 if (attrProvider)
2520 {
2521 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
2522
2523// ifdef'd out following patch from Paul Gammans
2524#if 0
2525 // No need to touch column attributes, unless we
2526 // removed _all_ rows, in this case, we remove
2527 // all column attributes.
2528 // I hate to do this here, but the
2529 // needed data is not available inside UpdateAttrRows.
2530 if ( !GetNumberRows() )
2531 attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
2532#endif
2533 }
2534
2535 if ( !GetBatchCount() )
2536 {
2537 CalcDimensions();
2538 m_rowLabelWin->Refresh();
2539 }
2540 }
2541 result = true;
2542 break;
2543
2544 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
2545 {
2546 size_t pos = msg.GetCommandInt();
2547 int numCols = msg.GetCommandInt2();
2548 m_numCols += numCols;
2549
2550 if ( m_useNativeHeader )
2551 GetGridColHeader()->SetColumnCount(m_numCols);
2552
2553 if ( !m_colAt.IsEmpty() )
2554 {
2555 //Shift the column IDs
2556 int i;
2557 for ( i = 0; i < m_numCols - numCols; i++ )
2558 {
2559 if ( m_colAt[i] >= (int)pos )
2560 m_colAt[i] += numCols;
2561 }
2562
2563 m_colAt.Insert( pos, pos, numCols );
2564
2565 //Set the new columns' positions
2566 for ( i = pos + 1; i < (int)pos + numCols; i++ )
2567 {
2568 m_colAt[i] = i;
2569 }
2570 }
2571
2572 if ( !m_colWidths.IsEmpty() )
2573 {
2574 m_colWidths.Insert( m_defaultColWidth, pos, numCols );
2575 m_colRights.Insert( 0, pos, numCols );
2576
2577 int right = 0;
2578 if ( pos > 0 )
2579 right = m_colRights[GetColAt( pos - 1 )];
2580
2581 int colPos;
2582 for ( colPos = pos; colPos < m_numCols; colPos++ )
2583 {
2584 i = GetColAt( colPos );
2585
2586 right += m_colWidths[i];
2587 m_colRights[i] = right;
2588 }
2589 }
2590
2591 if ( m_currentCellCoords == wxGridNoCellCoords )
2592 {
2593 // if we have just inserted cols into an empty grid the current
2594 // cell will be undefined...
2595 //
2596 SetCurrentCell( 0, 0 );
2597 }
2598
2599 if ( m_selection )
2600 m_selection->UpdateCols( pos, numCols );
2601 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
2602 if (attrProvider)
2603 attrProvider->UpdateAttrCols( pos, numCols );
2604 if ( !GetBatchCount() )
2605 {
2606 CalcDimensions();
2607 m_colWindow->Refresh();
2608 }
2609 }
2610 result = true;
2611 break;
2612
2613 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
2614 {
2615 int numCols = msg.GetCommandInt();
2616 int oldNumCols = m_numCols;
2617 m_numCols += numCols;
2618 if ( m_useNativeHeader )
2619 GetGridColHeader()->SetColumnCount(m_numCols);
2620
2621 if ( !m_colAt.IsEmpty() )
2622 {
2623 m_colAt.Add( 0, numCols );
2624
2625 //Set the new columns' positions
2626 int i;
2627 for ( i = oldNumCols; i < m_numCols; i++ )
2628 {
2629 m_colAt[i] = i;
2630 }
2631 }
2632
2633 if ( !m_colWidths.IsEmpty() )
2634 {
2635 m_colWidths.Add( m_defaultColWidth, numCols );
2636 m_colRights.Add( 0, numCols );
2637
2638 int right = 0;
2639 if ( oldNumCols > 0 )
2640 right = m_colRights[GetColAt( oldNumCols - 1 )];
2641
2642 int colPos;
2643 for ( colPos = oldNumCols; colPos < m_numCols; colPos++ )
2644 {
2645 i = GetColAt( colPos );
2646
2647 right += m_colWidths[i];
2648 m_colRights[i] = right;
2649 }
2650 }
2651
2652 if ( m_currentCellCoords == wxGridNoCellCoords )
2653 {
2654 // if we have just inserted cols into an empty grid the current
2655 // cell will be undefined...
2656 //
2657 SetCurrentCell( 0, 0 );
2658 }
2659 if ( !GetBatchCount() )
2660 {
2661 CalcDimensions();
2662 m_colWindow->Refresh();
2663 }
2664 }
2665 result = true;
2666 break;
2667
2668 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
2669 {
2670 size_t pos = msg.GetCommandInt();
2671 int numCols = msg.GetCommandInt2();
2672 m_numCols -= numCols;
2673 if ( m_useNativeHeader )
2674 GetGridColHeader()->SetColumnCount(m_numCols);
2675
2676 if ( !m_colAt.IsEmpty() )
2677 {
2678 int colID = GetColAt( pos );
2679
2680 m_colAt.RemoveAt( pos, numCols );
2681
2682 //Shift the column IDs
2683 int colPos;
2684 for ( colPos = 0; colPos < m_numCols; colPos++ )
2685 {
2686 if ( m_colAt[colPos] > colID )
2687 m_colAt[colPos] -= numCols;
2688 }
2689 }
2690
2691 if ( !m_colWidths.IsEmpty() )
2692 {
2693 m_colWidths.RemoveAt( pos, numCols );
2694 m_colRights.RemoveAt( pos, numCols );
2695
2696 int w = 0;
2697 int colPos;
2698 for ( colPos = 0; colPos < m_numCols; colPos++ )
2699 {
2700 i = GetColAt( colPos );
2701
2702 w += m_colWidths[i];
2703 m_colRights[i] = w;
2704 }
2705 }
2706
2707 if ( !m_numCols )
2708 {
2709 m_currentCellCoords = wxGridNoCellCoords;
2710 }
2711 else
2712 {
2713 if ( m_currentCellCoords.GetCol() >= m_numCols )
2714 m_currentCellCoords.Set( 0, 0 );
2715 }
2716
2717 if ( m_selection )
2718 m_selection->UpdateCols( pos, -((int)numCols) );
2719 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
2720 if (attrProvider)
2721 {
2722 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
2723
2724// ifdef'd out following patch from Paul Gammans
2725#if 0
2726 // No need to touch row attributes, unless we
2727 // removed _all_ columns, in this case, we remove
2728 // all row attributes.
2729 // I hate to do this here, but the
2730 // needed data is not available inside UpdateAttrCols.
2731 if ( !GetNumberCols() )
2732 attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
2733#endif
2734 }
2735
2736 if ( !GetBatchCount() )
2737 {
2738 CalcDimensions();
2739 m_colWindow->Refresh();
2740 }
2741 }
2742 result = true;
2743 break;
2744 }
2745
2746 if (result && !GetBatchCount() )
2747 m_gridWin->Refresh();
2748
2749 return result;
2750}
2751
2752wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg ) const
2753{
2754 wxRegionIterator iter( reg );
2755 wxRect r;
2756
2757 wxArrayInt rowlabels;
2758
2759 int top, bottom;
2760 while ( iter )
2761 {
2762 r = iter.GetRect();
2763
2764 // TODO: remove this when we can...
2765 // There is a bug in wxMotif that gives garbage update
2766 // rectangles if you jump-scroll a long way by clicking the
2767 // scrollbar with middle button. This is a work-around
2768 //
2769#if defined(__WXMOTIF__)
2770 int cw, ch;
2771 m_gridWin->GetClientSize( &cw, &ch );
2772 if ( r.GetTop() > ch )
2773 r.SetTop( 0 );
2774 r.SetBottom( wxMin( r.GetBottom(), ch ) );
2775#endif
2776
2777 // logical bounds of update region
2778 //
2779 int dummy;
2780 CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
2781 CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
2782
2783 // find the row labels within these bounds
2784 //
2785 int row;
2786 for ( row = internalYToRow(top); row < m_numRows; row++ )
2787 {
2788 if ( GetRowBottom(row) < top )
2789 continue;
2790
2791 if ( GetRowTop(row) > bottom )
2792 break;
2793
2794 rowlabels.Add( row );
2795 }
2796
2797 ++iter;
2798 }
2799
2800 return rowlabels;
2801}
2802
2803wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg ) const
2804{
2805 wxRegionIterator iter( reg );
2806 wxRect r;
2807
2808 wxArrayInt colLabels;
2809
2810 int left, right;
2811 while ( iter )
2812 {
2813 r = iter.GetRect();
2814
2815 // TODO: remove this when we can...
2816 // There is a bug in wxMotif that gives garbage update
2817 // rectangles if you jump-scroll a long way by clicking the
2818 // scrollbar with middle button. This is a work-around
2819 //
2820#if defined(__WXMOTIF__)
2821 int cw, ch;
2822 m_gridWin->GetClientSize( &cw, &ch );
2823 if ( r.GetLeft() > cw )
2824 r.SetLeft( 0 );
2825 r.SetRight( wxMin( r.GetRight(), cw ) );
2826#endif
2827
2828 // logical bounds of update region
2829 //
2830 int dummy;
2831 CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
2832 CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
2833
2834 // find the cells within these bounds
2835 //
2836 int col;
2837 int colPos;
2838 for ( colPos = GetColPos( internalXToCol(left) ); colPos < m_numCols; colPos++ )
2839 {
2840 col = GetColAt( colPos );
2841
2842 if ( GetColRight(col) < left )
2843 continue;
2844
2845 if ( GetColLeft(col) > right )
2846 break;
2847
2848 colLabels.Add( col );
2849 }
2850
2851 ++iter;
2852 }
2853
2854 return colLabels;
2855}
2856
2857wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg ) const
2858{
2859 wxRegionIterator iter( reg );
2860 wxRect r;
2861
2862 wxGridCellCoordsArray cellsExposed;
2863
2864 int left, top, right, bottom;
2865 while ( iter )
2866 {
2867 r = iter.GetRect();
2868
2869 // TODO: remove this when we can...
2870 // There is a bug in wxMotif that gives garbage update
2871 // rectangles if you jump-scroll a long way by clicking the
2872 // scrollbar with middle button. This is a work-around
2873 //
2874#if defined(__WXMOTIF__)
2875 int cw, ch;
2876 m_gridWin->GetClientSize( &cw, &ch );
2877 if ( r.GetTop() > ch ) r.SetTop( 0 );
2878 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
2879 r.SetRight( wxMin( r.GetRight(), cw ) );
2880 r.SetBottom( wxMin( r.GetBottom(), ch ) );
2881#endif
2882
2883 // logical bounds of update region
2884 //
2885 CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
2886 CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
2887
2888 // find the cells within these bounds
2889 wxArrayInt cols;
2890 for ( int row = internalYToRow(top); row < m_numRows; row++ )
2891 {
2892 if ( GetRowBottom(row) <= top )
2893 continue;
2894
2895 if ( GetRowTop(row) > bottom )
2896 break;
2897
2898 // add all dirty cells in this row: notice that the columns which
2899 // are dirty don't depend on the row so we compute them only once
2900 // for the first dirty row and then reuse for all the next ones
2901 if ( cols.empty() )
2902 {
2903 // do determine the dirty columns
2904 for ( int pos = XToPos(left); pos <= XToPos(right); pos++ )
2905 cols.push_back(GetColAt(pos));
2906
2907 // if there are no dirty columns at all, nothing to do
2908 if ( cols.empty() )
2909 break;
2910 }
2911
2912 const size_t count = cols.size();
2913 for ( size_t n = 0; n < count; n++ )
2914 cellsExposed.Add(wxGridCellCoords(row, cols[n]));
2915 }
2916
2917 ++iter;
2918 }
2919
2920 return cellsExposed;
2921}
2922
2923
2924void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
2925{
2926 int x, y, row;
2927 wxPoint pos( event.GetPosition() );
2928 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
2929
2930 if ( event.Dragging() )
2931 {
2932 if (!m_isDragging)
2933 {
2934 m_isDragging = true;
2935 m_rowLabelWin->CaptureMouse();
2936 }
2937
2938 if ( event.LeftIsDown() )
2939 {
2940 switch ( m_cursorMode )
2941 {
2942 case WXGRID_CURSOR_RESIZE_ROW:
2943 {
2944 int cw, ch, left, dummy;
2945 m_gridWin->GetClientSize( &cw, &ch );
2946 CalcUnscrolledPosition( 0, 0, &left, &dummy );
2947
2948 wxClientDC dc( m_gridWin );
2949 PrepareDC( dc );
2950 y = wxMax( y,
2951 GetRowTop(m_dragRowOrCol) +
2952 GetRowMinimalHeight(m_dragRowOrCol) );
2953 dc.SetLogicalFunction(wxINVERT);
2954 if ( m_dragLastPos >= 0 )
2955 {
2956 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
2957 }
2958 dc.DrawLine( left, y, left+cw, y );
2959 m_dragLastPos = y;
2960 }
2961 break;
2962
2963 case WXGRID_CURSOR_SELECT_ROW:
2964 {
2965 if ( (row = YToRow( y )) >= 0 )
2966 {
2967 if ( m_selection )
2968 m_selection->SelectRow(row, event);
2969 }
2970 }
2971 break;
2972
2973 // default label to suppress warnings about "enumeration value
2974 // 'xxx' not handled in switch
2975 default:
2976 break;
2977 }
2978 }
2979 return;
2980 }
2981
2982 if ( m_isDragging && (event.Entering() || event.Leaving()) )
2983 return;
2984
2985 if (m_isDragging)
2986 {
2987 if (m_rowLabelWin->HasCapture())
2988 m_rowLabelWin->ReleaseMouse();
2989 m_isDragging = false;
2990 }
2991
2992 // ------------ Entering or leaving the window
2993 //
2994 if ( event.Entering() || event.Leaving() )
2995 {
2996 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
2997 }
2998
2999 // ------------ Left button pressed
3000 //
3001 else if ( event.LeftDown() )
3002 {
3003 row = YToEdgeOfRow(y);
3004 if ( row != wxNOT_FOUND && CanDragRowSize(row) )
3005 {
3006 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
3007 }
3008 else // not a request to start resizing
3009 {
3010 row = YToRow(y);
3011 if ( row >= 0 &&
3012 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
3013 {
3014 if ( !event.ShiftDown() && !event.CmdDown() )
3015 ClearSelection();
3016 if ( m_selection )
3017 {
3018 if ( event.ShiftDown() )
3019 {
3020 m_selection->SelectBlock
3021 (
3022 m_currentCellCoords.GetRow(), 0,
3023 row, GetNumberCols() - 1,
3024 event
3025 );
3026 }
3027 else
3028 {
3029 m_selection->SelectRow(row, event);
3030 }
3031 }
3032
3033 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
3034 }
3035 }
3036 }
3037
3038 // ------------ Left double click
3039 //
3040 else if (event.LeftDClick() )
3041 {
3042 row = YToEdgeOfRow(y);
3043 if ( row != wxNOT_FOUND && CanDragRowSize(row) )
3044 {
3045 // adjust row height depending on label text
3046 //
3047 // TODO: generate RESIZING event, see #10754
3048 AutoSizeRowLabelSize( row );
3049
3050 SendGridSizeEvent(wxEVT_GRID_ROW_SIZE, row, -1, event);
3051
3052 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
3053 m_dragLastPos = -1;
3054 }
3055 else // not on row separator or it's not resizeable
3056 {
3057 row = YToRow(y);
3058 if ( row >=0 &&
3059 !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event ) )
3060 {
3061 // no default action at the moment
3062 }
3063 }
3064 }
3065
3066 // ------------ Left button released
3067 //
3068 else if ( event.LeftUp() )
3069 {
3070 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
3071 DoEndDragResizeRow(event);
3072
3073 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
3074 m_dragLastPos = -1;
3075 }
3076
3077 // ------------ Right button down
3078 //
3079 else if ( event.RightDown() )
3080 {
3081 row = YToRow(y);
3082 if ( row >=0 &&
3083 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
3084 {
3085 // no default action at the moment
3086 }
3087 }
3088
3089 // ------------ Right double click
3090 //
3091 else if ( event.RightDClick() )
3092 {
3093 row = YToRow(y);
3094 if ( row >= 0 &&
3095 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
3096 {
3097 // no default action at the moment
3098 }
3099 }
3100
3101 // ------------ No buttons down and mouse moving
3102 //
3103 else if ( event.Moving() )
3104 {
3105 m_dragRowOrCol = YToEdgeOfRow( y );
3106 if ( m_dragRowOrCol != wxNOT_FOUND )
3107 {
3108 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3109 {
3110 if ( CanDragRowSize(m_dragRowOrCol) )
3111 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, false);
3112 }
3113 }
3114 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3115 {
3116 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, false);
3117 }
3118 }
3119}
3120
3121void wxGrid::UpdateColumnSortingIndicator(int col)
3122{
3123 wxCHECK_RET( col != wxNOT_FOUND, "invalid column index" );
3124
3125 if ( m_useNativeHeader )
3126 GetGridColHeader()->UpdateColumn(col);
3127 else if ( m_nativeColumnLabels )
3128 m_colWindow->Refresh();
3129 //else: sorting indicator display not yet implemented in grid version
3130}
3131
3132void wxGrid::SetSortingColumn(int col, bool ascending)
3133{
3134 if ( col == m_sortCol )
3135 {
3136 // we are already using this column for sorting (or not sorting at all)
3137 // but we might still change the sorting order, check for it
3138 if ( m_sortCol != wxNOT_FOUND && ascending != m_sortIsAscending )
3139 {
3140 m_sortIsAscending = ascending;
3141
3142 UpdateColumnSortingIndicator(m_sortCol);
3143 }
3144 }
3145 else // we're changing the column used for sorting
3146 {
3147 const int sortColOld = m_sortCol;
3148
3149 // change it before updating the column as we want GetSortingColumn()
3150 // to return the correct new value
3151 m_sortCol = col;
3152
3153 if ( sortColOld != wxNOT_FOUND )
3154 UpdateColumnSortingIndicator(sortColOld);
3155
3156 if ( m_sortCol != wxNOT_FOUND )
3157 {
3158 m_sortIsAscending = ascending;
3159 UpdateColumnSortingIndicator(m_sortCol);
3160 }
3161 }
3162}
3163
3164void wxGrid::DoColHeaderClick(int col)
3165{
3166 // we consider that the grid was resorted if this event is processed and
3167 // not vetoed
3168 if ( SendEvent(wxEVT_GRID_COL_SORT, -1, col) == 1 )
3169 {
3170 SetSortingColumn(col, IsSortingBy(col) ? !m_sortIsAscending : true);
3171 Refresh();
3172 }
3173}
3174
3175void wxGrid::DoStartResizeCol(int col)
3176{
3177 m_dragRowOrCol = col;
3178 m_dragLastPos = -1;
3179 DoUpdateResizeColWidth(GetColWidth(m_dragRowOrCol));
3180}
3181
3182void wxGrid::DoUpdateResizeCol(int x)
3183{
3184 int cw, ch, dummy, top;
3185 m_gridWin->GetClientSize( &cw, &ch );
3186 CalcUnscrolledPosition( 0, 0, &dummy, &top );
3187
3188 wxClientDC dc( m_gridWin );
3189 PrepareDC( dc );
3190
3191 x = wxMax( x, GetColLeft(m_dragRowOrCol) + GetColMinimalWidth(m_dragRowOrCol));
3192 dc.SetLogicalFunction(wxINVERT);
3193 if ( m_dragLastPos >= 0 )
3194 {
3195 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top + ch );
3196 }
3197 dc.DrawLine( x, top, x, top + ch );
3198 m_dragLastPos = x;
3199}
3200
3201void wxGrid::DoUpdateResizeColWidth(int w)
3202{
3203 DoUpdateResizeCol(GetColLeft(m_dragRowOrCol) + w);
3204}
3205
3206void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
3207{
3208 int x, y;
3209 wxPoint pos( event.GetPosition() );
3210 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
3211
3212 int col = XToCol(x);
3213 if ( event.Dragging() )
3214 {
3215 if (!m_isDragging)
3216 {
3217 m_isDragging = true;
3218 GetColLabelWindow()->CaptureMouse();
3219
3220 if ( m_cursorMode == WXGRID_CURSOR_MOVE_COL && col != -1 )
3221 DoStartMoveCol(col);
3222 }
3223
3224 if ( event.LeftIsDown() )
3225 {
3226 switch ( m_cursorMode )
3227 {
3228 case WXGRID_CURSOR_RESIZE_COL:
3229 DoUpdateResizeCol(x);
3230 break;
3231
3232 case WXGRID_CURSOR_SELECT_COL:
3233 {
3234 if ( col != -1 )
3235 {
3236 if ( m_selection )
3237 m_selection->SelectCol(col, event);
3238 }
3239 }
3240 break;
3241
3242 case WXGRID_CURSOR_MOVE_COL:
3243 {
3244 int posNew = XToPos(x);
3245 int colNew = GetColAt(posNew);
3246
3247 // determine the position of the drop marker
3248 int markerX;
3249 if ( x >= GetColLeft(colNew) + (GetColWidth(colNew) / 2) )
3250 markerX = GetColRight(colNew);
3251 else
3252 markerX = GetColLeft(colNew);
3253
3254 if ( markerX != m_dragLastPos )
3255 {
3256 wxClientDC dc( GetColLabelWindow() );
3257 DoPrepareDC(dc);
3258
3259 int cw, ch;
3260 GetColLabelWindow()->GetClientSize( &cw, &ch );
3261
3262 markerX++;
3263
3264 //Clean up the last indicator
3265 if ( m_dragLastPos >= 0 )
3266 {
3267 wxPen pen( GetColLabelWindow()->GetBackgroundColour(), 2 );
3268 dc.SetPen(pen);
3269 dc.DrawLine( m_dragLastPos + 1, 0, m_dragLastPos + 1, ch );
3270 dc.SetPen(wxNullPen);
3271
3272 if ( XToCol( m_dragLastPos ) != -1 )
3273 DrawColLabel( dc, XToCol( m_dragLastPos ) );
3274 }
3275
3276 const wxColour *color;
3277 //Moving to the same place? Don't draw a marker
3278 if ( colNew == m_dragRowOrCol )
3279 color = wxLIGHT_GREY;
3280 else
3281 color = wxBLUE;
3282
3283 //Draw the marker
3284 wxPen pen( *color, 2 );
3285 dc.SetPen(pen);
3286
3287 dc.DrawLine( markerX, 0, markerX, ch );
3288
3289 dc.SetPen(wxNullPen);
3290
3291 m_dragLastPos = markerX - 1;
3292 }
3293 }
3294 break;
3295
3296 // default label to suppress warnings about "enumeration value
3297 // 'xxx' not handled in switch
3298 default:
3299 break;
3300 }
3301 }
3302 return;
3303 }
3304
3305 if ( m_isDragging && (event.Entering() || event.Leaving()) )
3306 return;
3307
3308 if (m_isDragging)
3309 {
3310 if (GetColLabelWindow()->HasCapture())
3311 GetColLabelWindow()->ReleaseMouse();
3312 m_isDragging = false;
3313 }
3314
3315 // ------------ Entering or leaving the window
3316 //
3317 if ( event.Entering() || event.Leaving() )
3318 {
3319 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
3320 }
3321
3322 // ------------ Left button pressed
3323 //
3324 else if ( event.LeftDown() )
3325 {
3326 int col = XToEdgeOfCol(x);
3327 if ( col != wxNOT_FOUND && CanDragColSize(col) )
3328 {
3329 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, GetColLabelWindow());
3330 }
3331 else // not a request to start resizing
3332 {
3333 col = XToCol(x);
3334 if ( col >= 0 &&
3335 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
3336 {
3337 if ( m_canDragColMove )
3338 {
3339 //Show button as pressed
3340 wxClientDC dc( GetColLabelWindow() );
3341 int colLeft = GetColLeft( col );
3342 int colRight = GetColRight( col ) - 1;
3343 dc.SetPen( wxPen( GetColLabelWindow()->GetBackgroundColour(), 1 ) );
3344 dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight-1 );
3345 dc.DrawLine( colLeft, 1, colRight, 1 );
3346
3347 ChangeCursorMode(WXGRID_CURSOR_MOVE_COL, GetColLabelWindow());
3348 }
3349 else
3350 {
3351 if ( !event.ShiftDown() && !event.CmdDown() )
3352 ClearSelection();
3353 if ( m_selection )
3354 {
3355 if ( event.ShiftDown() )
3356 {
3357 m_selection->SelectBlock
3358 (
3359 0, m_currentCellCoords.GetCol(),
3360 GetNumberRows() - 1, col,
3361 event
3362 );
3363 }
3364 else
3365 {
3366 m_selection->SelectCol(col, event);
3367 }
3368 }
3369
3370 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, GetColLabelWindow());
3371 }
3372 }
3373 }
3374 }
3375
3376 // ------------ Left double click
3377 //
3378 if ( event.LeftDClick() )
3379 {
3380 const int colEdge = XToEdgeOfCol(x);
3381 if ( colEdge == -1 )
3382 {
3383 if ( col >= 0 &&
3384 ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event ) )
3385 {
3386 // no default action at the moment
3387 }
3388 }
3389 else
3390 {
3391 // adjust column width depending on label text
3392 //
3393 // TODO: generate RESIZING event, see #10754
3394 AutoSizeColLabelSize( colEdge );
3395
3396 SendGridSizeEvent(wxEVT_GRID_COL_SIZE, -1, colEdge, event);
3397
3398 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
3399 m_dragLastPos = -1;
3400 }
3401 }
3402
3403 // ------------ Left button released
3404 //
3405 else if ( event.LeftUp() )
3406 {
3407 switch ( m_cursorMode )
3408 {
3409 case WXGRID_CURSOR_RESIZE_COL:
3410 DoEndDragResizeCol(event);
3411 break;
3412
3413 case WXGRID_CURSOR_MOVE_COL:
3414 if ( m_dragLastPos == -1 || col == m_dragRowOrCol )
3415 {
3416 // the column didn't actually move anywhere
3417 if ( col != -1 )
3418 DoColHeaderClick(col);
3419 m_colWindow->Refresh(); // "unpress" the column
3420 }
3421 else
3422 {
3423 // get the position of the column we're over
3424 int pos = XToPos(x);
3425
3426 // we may need to adjust the drop position but don't bother
3427 // checking for it if we can't anyhow
3428 if ( pos > 1 )
3429 {
3430 // also find the index of the column we're over: notice
3431 // that the existing "col" variable may be invalid but
3432 // we need a valid one here
3433 const int colValid = GetColAt(pos);
3434
3435 // if we're on the "near" (usually left but right in
3436 // RTL case) part of the column, the actual position we
3437 // should be placed in is actually the one before it
3438 bool onNearPart;
3439 const int middle = GetColLeft(colValid) +
3440 GetColWidth(colValid)/2;
3441 if ( GetLayoutDirection() == wxLayout_LeftToRight )
3442 onNearPart = (x <= middle);
3443 else // wxLayout_RightToLeft
3444 onNearPart = (x > middle);
3445
3446 if ( onNearPart )
3447 pos--;
3448 }
3449
3450 DoEndMoveCol(pos);
3451 }
3452 break;
3453
3454 case WXGRID_CURSOR_SELECT_COL:
3455 case WXGRID_CURSOR_SELECT_CELL:
3456 case WXGRID_CURSOR_RESIZE_ROW:
3457 case WXGRID_CURSOR_SELECT_ROW:
3458 if ( col != -1 )
3459 DoColHeaderClick(col);
3460 break;
3461 }
3462
3463 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow());
3464 m_dragLastPos = -1;
3465 }
3466
3467 // ------------ Right button down
3468 //
3469 else if ( event.RightDown() )
3470 {
3471 if ( col >= 0 &&
3472 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
3473 {
3474 // no default action at the moment
3475 }
3476 }
3477
3478 // ------------ Right double click
3479 //
3480 else if ( event.RightDClick() )
3481 {
3482 if ( col >= 0 &&
3483 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
3484 {
3485 // no default action at the moment
3486 }
3487 }
3488
3489 // ------------ No buttons down and mouse moving
3490 //
3491 else if ( event.Moving() )
3492 {
3493 m_dragRowOrCol = XToEdgeOfCol( x );
3494 if ( m_dragRowOrCol >= 0 )
3495 {
3496 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3497 {
3498 if ( CanDragColSize(m_dragRowOrCol) )
3499 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, GetColLabelWindow(), false);
3500 }
3501 }
3502 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3503 {
3504 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, GetColLabelWindow(), false);
3505 }
3506 }
3507}
3508
3509void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
3510{
3511 if ( event.LeftDown() )
3512 {
3513 // indicate corner label by having both row and
3514 // col args == -1
3515 //
3516 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
3517 {
3518 SelectAll();
3519 }
3520 }
3521 else if ( event.LeftDClick() )
3522 {
3523 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
3524 }
3525 else if ( event.RightDown() )
3526 {
3527 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
3528 {
3529 // no default action at the moment
3530 }
3531 }
3532 else if ( event.RightDClick() )
3533 {
3534 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
3535 {
3536 // no default action at the moment
3537 }
3538 }
3539}
3540
3541void wxGrid::CancelMouseCapture()
3542{
3543 // cancel operation currently in progress, whatever it is
3544 if ( m_winCapture )
3545 {
3546 m_isDragging = false;
3547 m_startDragPos = wxDefaultPosition;
3548
3549 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
3550 m_winCapture->SetCursor( *wxSTANDARD_CURSOR );
3551 m_winCapture = NULL;
3552
3553 // remove traces of whatever we drew on screen
3554 Refresh();
3555 }
3556}
3557
3558void wxGrid::ChangeCursorMode(CursorMode mode,
3559 wxWindow *win,
3560 bool captureMouse)
3561{
3562#if wxUSE_LOG_TRACE
3563 static const wxChar *const cursorModes[] =
3564 {
3565 wxT("SELECT_CELL"),
3566 wxT("RESIZE_ROW"),
3567 wxT("RESIZE_COL"),
3568 wxT("SELECT_ROW"),
3569 wxT("SELECT_COL"),
3570 wxT("MOVE_COL"),
3571 };
3572
3573 wxLogTrace(wxT("grid"),
3574 wxT("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
3575 win == m_colWindow ? wxT("colLabelWin")
3576 : win ? wxT("rowLabelWin")
3577 : wxT("gridWin"),
3578 cursorModes[m_cursorMode], cursorModes[mode]);
3579#endif // wxUSE_LOG_TRACE
3580
3581 if ( mode == m_cursorMode &&
3582 win == m_winCapture &&
3583 captureMouse == (m_winCapture != NULL))
3584 return;
3585
3586 if ( !win )
3587 {
3588 // by default use the grid itself
3589 win = m_gridWin;
3590 }
3591
3592 if ( m_winCapture )
3593 {
3594 m_winCapture->ReleaseMouse();
3595 m_winCapture = NULL;
3596 }
3597
3598 m_cursorMode = mode;
3599
3600 switch ( m_cursorMode )
3601 {
3602 case WXGRID_CURSOR_RESIZE_ROW:
3603 win->SetCursor( m_rowResizeCursor );
3604 break;
3605
3606 case WXGRID_CURSOR_RESIZE_COL:
3607 win->SetCursor( m_colResizeCursor );
3608 break;
3609
3610 case WXGRID_CURSOR_MOVE_COL:
3611 win->SetCursor( wxCursor(wxCURSOR_HAND) );
3612 break;
3613
3614 default:
3615 win->SetCursor( *wxSTANDARD_CURSOR );
3616 break;
3617 }
3618
3619 // we need to capture mouse when resizing
3620 bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
3621 m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
3622
3623 if ( captureMouse && resize )
3624 {
3625 win->CaptureMouse();
3626 m_winCapture = win;
3627 }
3628}
3629
3630// ----------------------------------------------------------------------------
3631// grid mouse event processing
3632// ----------------------------------------------------------------------------
3633
3634void
3635wxGrid::DoGridCellDrag(wxMouseEvent& event,
3636 const wxGridCellCoords& coords,
3637 bool isFirstDrag)
3638{
3639 if ( coords == wxGridNoCellCoords )
3640 return; // we're outside any valid cell
3641
3642 // Hide the edit control, so it won't interfere with drag-shrinking.
3643 if ( IsCellEditControlShown() )
3644 {
3645 HideCellEditControl();
3646 SaveEditControlValue();
3647 }
3648
3649 switch ( event.GetModifiers() )
3650 {
3651 case wxMOD_CMD:
3652 if ( m_selectedBlockCorner == wxGridNoCellCoords)
3653 m_selectedBlockCorner = coords;
3654 UpdateBlockBeingSelected(m_selectedBlockCorner, coords);
3655 break;
3656
3657 case wxMOD_NONE:
3658 if ( CanDragCell() )
3659 {
3660 if ( isFirstDrag )
3661 {
3662 if ( m_selectedBlockCorner == wxGridNoCellCoords)
3663 m_selectedBlockCorner = coords;
3664
3665 SendEvent(wxEVT_GRID_CELL_BEGIN_DRAG, coords, event);
3666 return;
3667 }
3668 }
3669
3670 UpdateBlockBeingSelected(m_currentCellCoords, coords);
3671 break;
3672
3673 default:
3674 // we don't handle the other key modifiers
3675 event.Skip();
3676 }
3677}
3678
3679void wxGrid::DoGridLineDrag(wxMouseEvent& event, const wxGridOperations& oper)
3680{
3681 wxClientDC dc(m_gridWin);
3682 PrepareDC(dc);
3683 dc.SetLogicalFunction(wxINVERT);
3684
3685 const wxRect rectWin(CalcUnscrolledPosition(wxPoint(0, 0)),
3686 m_gridWin->GetClientSize());
3687
3688 // erase the previously drawn line, if any
3689 if ( m_dragLastPos >= 0 )
3690 oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
3691
3692 // we need the vertical position for rows and horizontal for columns here
3693 m_dragLastPos = oper.Dual().Select(CalcUnscrolledPosition(event.GetPosition()));
3694
3695 // don't allow resizing beneath the minimal size
3696 const int posMin = oper.GetLineStartPos(this, m_dragRowOrCol) +
3697 oper.GetMinimalLineSize(this, m_dragRowOrCol);
3698 if ( m_dragLastPos < posMin )
3699 m_dragLastPos = posMin;
3700
3701 // and draw it at the new position
3702 oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
3703}
3704
3705void wxGrid::DoGridDragEvent(wxMouseEvent& event, const wxGridCellCoords& coords)
3706{
3707 if ( !m_isDragging )
3708 {
3709 // Don't start doing anything until the mouse has been dragged far
3710 // enough
3711 const wxPoint& pt = event.GetPosition();
3712 if ( m_startDragPos == wxDefaultPosition )
3713 {
3714 m_startDragPos = pt;
3715 return;
3716 }
3717
3718 if ( abs(m_startDragPos.x - pt.x) <= DRAG_SENSITIVITY &&
3719 abs(m_startDragPos.y - pt.y) <= DRAG_SENSITIVITY )
3720 return;
3721 }
3722
3723 const bool isFirstDrag = !m_isDragging;
3724 m_isDragging = true;
3725
3726 switch ( m_cursorMode )
3727 {
3728 case WXGRID_CURSOR_SELECT_CELL:
3729 DoGridCellDrag(event, coords, isFirstDrag);
3730 break;
3731
3732 case WXGRID_CURSOR_RESIZE_ROW:
3733 DoGridLineDrag(event, wxGridRowOperations());
3734 break;
3735
3736 case WXGRID_CURSOR_RESIZE_COL:
3737 DoGridLineDrag(event, wxGridColumnOperations());
3738 break;
3739
3740 default:
3741 event.Skip();
3742 }
3743
3744 if ( isFirstDrag )
3745 {
3746 wxASSERT_MSG( !m_winCapture, "shouldn't capture the mouse twice" );
3747
3748 m_winCapture = m_gridWin;
3749 m_winCapture->CaptureMouse();
3750 }
3751}
3752
3753void
3754wxGrid::DoGridCellLeftDown(wxMouseEvent& event,
3755 const wxGridCellCoords& coords,
3756 const wxPoint& pos)
3757{
3758 if ( SendEvent(wxEVT_GRID_CELL_LEFT_CLICK, coords, event) )
3759 {
3760 // event handled by user code, no need to do anything here
3761 return;
3762 }
3763
3764 if ( !event.CmdDown() )
3765 ClearSelection();
3766
3767 if ( event.ShiftDown() )
3768 {
3769 if ( m_selection )
3770 {
3771 m_selection->SelectBlock(m_currentCellCoords, coords, event);
3772 m_selectedBlockCorner = coords;
3773 }
3774 }
3775 else if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
3776 {
3777 DisableCellEditControl();
3778 MakeCellVisible( coords );
3779
3780 if ( event.CmdDown() )
3781 {
3782 if ( m_selection )
3783 {
3784 m_selection->ToggleCellSelection(coords, event);
3785 }
3786
3787 m_selectedBlockTopLeft = wxGridNoCellCoords;
3788 m_selectedBlockBottomRight = wxGridNoCellCoords;
3789 m_selectedBlockCorner = coords;
3790 }
3791 else
3792 {
3793 if ( m_selection )
3794 {
3795 // In row or column selection mode just clicking on the cell
3796 // should select the row or column containing it: this is more
3797 // convenient for the kinds of controls that use such selection
3798 // mode and is compatible with 2.8 behaviour (see #12062).
3799 switch ( m_selection->GetSelectionMode() )
3800 {
3801 case wxGridSelectCells:
3802 case wxGridSelectRowsOrColumns:
3803 // nothing to do in these cases
3804 break;
3805
3806 case wxGridSelectRows:
3807 m_selection->SelectRow(coords.GetRow());
3808 break;
3809
3810 case wxGridSelectColumns:
3811 m_selection->SelectCol(coords.GetCol());
3812 break;
3813 }
3814 }
3815
3816 m_waitForSlowClick = m_currentCellCoords == coords &&
3817 coords != wxGridNoCellCoords;
3818 SetCurrentCell( coords );
3819 }
3820 }
3821}
3822
3823void
3824wxGrid::DoGridCellLeftDClick(wxMouseEvent& event,
3825 const wxGridCellCoords& coords,
3826 const wxPoint& pos)
3827{
3828 if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
3829 {
3830 if ( !SendEvent(wxEVT_GRID_CELL_LEFT_DCLICK, coords, event) )
3831 {
3832 // we want double click to select a cell and start editing
3833 // (i.e. to behave in same way as sequence of two slow clicks):
3834 m_waitForSlowClick = true;
3835 }
3836 }
3837}
3838
3839void
3840wxGrid::DoGridCellLeftUp(wxMouseEvent& event, const wxGridCellCoords& coords)
3841{
3842 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3843 {
3844 if (m_winCapture)
3845 {
3846 m_winCapture->ReleaseMouse();
3847 m_winCapture = NULL;
3848 }
3849
3850 if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl() )
3851 {
3852 ClearSelection();
3853 EnableCellEditControl();
3854
3855 wxGridCellAttr *attr = GetCellAttr(coords);
3856 wxGridCellEditor *editor = attr->GetEditor(this, coords.GetRow(), coords.GetCol());
3857 editor->StartingClick();
3858 editor->DecRef();
3859 attr->DecRef();
3860
3861 m_waitForSlowClick = false;
3862 }
3863 else if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
3864 m_selectedBlockBottomRight != wxGridNoCellCoords )
3865 {
3866 if ( m_selection )
3867 {
3868 m_selection->SelectBlock( m_selectedBlockTopLeft,
3869 m_selectedBlockBottomRight,
3870 event );
3871 }
3872
3873 m_selectedBlockTopLeft = wxGridNoCellCoords;
3874 m_selectedBlockBottomRight = wxGridNoCellCoords;
3875
3876 // Show the edit control, if it has been hidden for
3877 // drag-shrinking.
3878 ShowCellEditControl();
3879 }
3880 }
3881 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
3882 {
3883 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3884 DoEndDragResizeRow(event);
3885 }
3886 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
3887 {
3888 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3889 DoEndDragResizeCol(event);
3890 }
3891
3892 m_dragLastPos = -1;
3893}
3894
3895void
3896wxGrid::DoGridMouseMoveEvent(wxMouseEvent& WXUNUSED(event),
3897 const wxGridCellCoords& coords,
3898 const wxPoint& pos)
3899{
3900 if ( coords.GetRow() < 0 || coords.GetCol() < 0 )
3901 {
3902 // out of grid cell area
3903 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3904 return;
3905 }
3906
3907 int dragRow = YToEdgeOfRow( pos.y );
3908 int dragCol = XToEdgeOfCol( pos.x );
3909
3910 // Dragging on the corner of a cell to resize in both
3911 // directions is not implemented yet...
3912 //
3913 if ( dragRow >= 0 && dragCol >= 0 )
3914 {
3915 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3916 return;
3917 }
3918
3919 if ( dragRow >= 0 && CanDragGridSize() && CanDragRowSize(dragRow) )
3920 {
3921 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3922 {
3923 m_dragRowOrCol = dragRow;
3924 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, NULL, false);
3925 }
3926 }
3927 // When using the native header window we can only resize the columns by
3928 // dragging the dividers in it because we can't make it enter into the
3929 // column resizing mode programmatically
3930 else if ( dragCol >= 0 && !m_useNativeHeader &&
3931 CanDragGridSize() && CanDragColSize(dragCol) )
3932 {
3933 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3934 {
3935 m_dragRowOrCol = dragCol;
3936 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, NULL, false);
3937 }
3938 }
3939 else // Neither on a row or col edge
3940 {
3941 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3942 {
3943 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3944 }
3945 }
3946}
3947
3948void wxGrid::ProcessGridCellMouseEvent(wxMouseEvent& event)
3949{
3950 if ( event.Entering() || event.Leaving() )
3951 {
3952 // we don't care about these events but we must not reset m_isDragging
3953 // if they happen so return before anything else is done
3954 event.Skip();
3955 return;
3956 }
3957
3958 const wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
3959
3960 // coordinates of the cell under mouse
3961 wxGridCellCoords coords = XYToCell(pos);
3962
3963 int cell_rows, cell_cols;
3964 GetCellSize( coords.GetRow(), coords.GetCol(), &cell_rows, &cell_cols );
3965 if ( (cell_rows < 0) || (cell_cols < 0) )
3966 {
3967 coords.SetRow(coords.GetRow() + cell_rows);
3968 coords.SetCol(coords.GetCol() + cell_cols);
3969 }
3970
3971 if ( event.Dragging() )
3972 {
3973 if ( event.LeftIsDown() )
3974 DoGridDragEvent(event, coords);
3975 else
3976 event.Skip();
3977 return;
3978 }
3979
3980 m_isDragging = false;
3981 m_startDragPos = wxDefaultPosition;
3982
3983 // deal with various button presses
3984 if ( event.IsButton() )
3985 {
3986 if ( coords != wxGridNoCellCoords )
3987 {
3988 DisableCellEditControl();
3989
3990 if ( event.LeftDown() )
3991 DoGridCellLeftDown(event, coords, pos);
3992 else if ( event.LeftDClick() )
3993 DoGridCellLeftDClick(event, coords, pos);
3994 else if ( event.RightDown() )
3995 SendEvent(wxEVT_GRID_CELL_RIGHT_CLICK, coords, event);
3996 else if ( event.RightDClick() )
3997 SendEvent(wxEVT_GRID_CELL_RIGHT_DCLICK, coords, event);
3998 }
3999
4000 // this one should be called even if we're not over any cell
4001 if ( event.LeftUp() )
4002 {
4003 DoGridCellLeftUp(event, coords);
4004 }
4005 }
4006 else if ( event.Moving() )
4007 {
4008 DoGridMouseMoveEvent(event, coords, pos);
4009 }
4010 else // unknown mouse event?
4011 {
4012 event.Skip();
4013 }
4014}
4015
4016// this function returns true only if the size really changed
4017bool wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)
4018{
4019 if ( m_dragLastPos == -1 )
4020 return false;
4021
4022 const wxGridOperations& doper = oper.Dual();
4023
4024 const wxSize size = m_gridWin->GetClientSize();
4025
4026 const wxPoint ptOrigin = CalcUnscrolledPosition(wxPoint(0, 0));
4027
4028 // erase the last line we drew
4029 wxClientDC dc(m_gridWin);
4030 PrepareDC(dc);
4031 dc.SetLogicalFunction(wxINVERT);
4032
4033 const int posLineStart = oper.Select(ptOrigin);
4034 const int posLineEnd = oper.Select(ptOrigin) + oper.Select(size);
4035
4036 oper.DrawParallelLine(dc, posLineStart, posLineEnd, m_dragLastPos);
4037
4038 // temporarily hide the edit control before resizing
4039 HideCellEditControl();
4040 SaveEditControlValue();
4041
4042 // do resize the line
4043 const int lineStart = oper.GetLineStartPos(this, m_dragRowOrCol);
4044 const int lineSizeOld = oper.GetLineSize(this, m_dragRowOrCol);
4045 oper.SetLineSize(this, m_dragRowOrCol,
4046 wxMax(m_dragLastPos - lineStart,
4047 oper.GetMinimalLineSize(this, m_dragRowOrCol)));
4048 const bool
4049 sizeChanged = oper.GetLineSize(this, m_dragRowOrCol) != lineSizeOld;
4050
4051 m_dragLastPos = -1;
4052
4053 // refresh now if we're not frozen
4054 if ( !GetBatchCount() )
4055 {
4056 // we need to refresh everything beyond the resized line in the header
4057 // window
4058
4059 // get the position from which to refresh in the other direction
4060 wxRect rect(CellToRect(oper.MakeCoords(m_dragRowOrCol, 0)));
4061 rect.SetPosition(CalcScrolledPosition(rect.GetPosition()));
4062
4063 // we only need the ordinate (for rows) or abscissa (for columns) here,
4064 // and need to cover the entire window in the other direction
4065 oper.Select(rect) = 0;
4066
4067 wxRect rectHeader(rect.GetPosition(),
4068 oper.MakeSize
4069 (
4070 oper.GetHeaderWindowSize(this),
4071 doper.Select(size) - doper.Select(rect)
4072 ));
4073
4074 oper.GetHeaderWindow(this)->Refresh(true, &rectHeader);
4075
4076
4077 // also refresh the grid window: extend the rectangle
4078 if ( m_table )
4079 {
4080 oper.SelectSize(rect) = oper.Select(size);
4081
4082 int subtractLines = 0;
4083 const int lineStart = doper.PosToLine(this, posLineStart);
4084 if ( lineStart >= 0 )
4085 {
4086 // ensure that if we have a multi-cell block we redraw all of
4087 // it by increasing the refresh area to cover it entirely if a
4088 // part of it is affected
4089 const int lineEnd = doper.PosToLine(this, posLineEnd, true);
4090 for ( int line = lineStart; line < lineEnd; line++ )
4091 {
4092 int cellLines = oper.Select(
4093 GetCellSize(oper.MakeCoords(m_dragRowOrCol, line)));
4094 if ( cellLines < subtractLines )
4095 subtractLines = cellLines;
4096 }
4097 }
4098
4099 int startPos =
4100 oper.GetLineStartPos(this, m_dragRowOrCol + subtractLines);
4101 startPos = doper.CalcScrolledPosition(this, startPos);
4102
4103 doper.Select(rect) = startPos;
4104 doper.SelectSize(rect) = doper.Select(size) - startPos;
4105
4106 m_gridWin->Refresh(false, &rect);
4107 }
4108 }
4109
4110 // show the edit control back again
4111 ShowCellEditControl();
4112
4113 return sizeChanged;
4114}
4115
4116void wxGrid::DoEndDragResizeRow(const wxMouseEvent& event)
4117{
4118 // TODO: generate RESIZING event, see #10754
4119
4120 if ( DoEndDragResizeLine(wxGridRowOperations()) )
4121 SendGridSizeEvent(wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event);
4122}
4123
4124void wxGrid::DoEndDragResizeCol(const wxMouseEvent& event)
4125{
4126 // TODO: generate RESIZING event, see #10754
4127
4128 if ( DoEndDragResizeLine(wxGridColumnOperations()) )
4129 SendGridSizeEvent(wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event);
4130}
4131
4132void wxGrid::DoStartMoveCol(int col)
4133{
4134 m_dragRowOrCol = col;
4135}
4136
4137void wxGrid::DoEndMoveCol(int pos)
4138{
4139 wxASSERT_MSG( m_dragRowOrCol != -1, "no matching DoStartMoveCol?" );
4140
4141 if ( SendEvent(wxEVT_GRID_COL_MOVE, -1, m_dragRowOrCol) != -1 )
4142 SetColPos(m_dragRowOrCol, pos);
4143 //else: vetoed by user
4144
4145 m_dragRowOrCol = -1;
4146}
4147
4148void wxGrid::RefreshAfterColPosChange()
4149{
4150 // recalculate the column rights as the column positions have changed,
4151 // unless we calculate them dynamically because all columns widths are the
4152 // same and it's easy to do
4153 if ( !m_colWidths.empty() )
4154 {
4155 int colRight = 0;
4156 for ( int colPos = 0; colPos < m_numCols; colPos++ )
4157 {
4158 int colID = GetColAt( colPos );
4159
4160 colRight += m_colWidths[colID];
4161 m_colRights[colID] = colRight;
4162 }
4163 }
4164
4165 // and make the changes visible
4166 if ( m_useNativeHeader )
4167 {
4168 if ( m_colAt.empty() )
4169 GetGridColHeader()->ResetColumnsOrder();
4170 else
4171 GetGridColHeader()->SetColumnsOrder(m_colAt);
4172 }
4173 else
4174 {
4175 m_colWindow->Refresh();
4176 }
4177 m_gridWin->Refresh();
4178}
4179
4180void wxGrid::SetColumnsOrder(const wxArrayInt& order)
4181{
4182 m_colAt = order;
4183
4184 RefreshAfterColPosChange();
4185}
4186
4187void wxGrid::SetColPos(int idx, int pos)
4188{
4189 // we're going to need m_colAt now, initialize it if needed
4190 if ( m_colAt.empty() )
4191 {
4192 m_colAt.reserve(m_numCols);
4193 for ( int i = 0; i < m_numCols; i++ )
4194 m_colAt.push_back(i);
4195 }
4196
4197 wxHeaderCtrl::MoveColumnInOrderArray(m_colAt, idx, pos);
4198
4199 RefreshAfterColPosChange();
4200}
4201
4202void wxGrid::ResetColPos()
4203{
4204 m_colAt.clear();
4205
4206 RefreshAfterColPosChange();
4207}
4208
4209void wxGrid::EnableDragColMove( bool enable )
4210{
4211 if ( m_canDragColMove == enable )
4212 return;
4213
4214 if ( m_useNativeHeader )
4215 {
4216 // update all columns to make them [not] reorderable
4217 GetGridColHeader()->SetColumnCount(m_numCols);
4218 }
4219
4220 m_canDragColMove = enable;
4221
4222 // we use to call ResetColPos() from here if !enable but this doesn't seem
4223 // right as it would mean there would be no way to "freeze" the current
4224 // columns order by disabling moving them after putting them in the desired
4225 // order, whereas now you can always call ResetColPos() manually if needed
4226}
4227
4228
4229//
4230// ------ interaction with data model
4231//
4232bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
4233{
4234 switch ( msg.GetId() )
4235 {
4236 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
4237 return GetModelValues();
4238
4239 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
4240 return SetModelValues();
4241
4242 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4243 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4244 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4245 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4246 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4247 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4248 return Redimension( msg );
4249
4250 default:
4251 return false;
4252 }
4253}
4254
4255// The behaviour of this function depends on the grid table class
4256// Clear() function. For the default wxGridStringTable class the
4257// behaviour is to replace all cell contents with wxEmptyString but
4258// not to change the number of rows or cols.
4259//
4260void wxGrid::ClearGrid()
4261{
4262 if ( m_table )
4263 {
4264 if (IsCellEditControlEnabled())
4265 DisableCellEditControl();
4266
4267 m_table->Clear();
4268 if (!GetBatchCount())
4269 m_gridWin->Refresh();
4270 }
4271}
4272
4273bool
4274wxGrid::DoModifyLines(bool (wxGridTableBase::*funcModify)(size_t, size_t),
4275 int pos, int num, bool WXUNUSED(updateLabels) )
4276{
4277 wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
4278
4279 if ( !m_table )
4280 return false;
4281
4282 if ( IsCellEditControlEnabled() )
4283 DisableCellEditControl();
4284
4285 return (m_table->*funcModify)(pos, num);
4286
4287 // the table will have sent the results of the insert row
4288 // operation to this view object as a grid table message
4289}
4290
4291bool
4292wxGrid::DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
4293 int num, bool WXUNUSED(updateLabels))
4294{
4295 wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
4296
4297 if ( !m_table )
4298 return false;
4299
4300 return (m_table->*funcAppend)(num);
4301}
4302
4303// ----------------------------------------------------------------------------
4304// event generation helpers
4305// ----------------------------------------------------------------------------
4306
4307void
4308wxGrid::SendGridSizeEvent(wxEventType type,
4309 int row, int col,
4310 const wxMouseEvent& mouseEv)
4311{
4312 int rowOrCol = row == -1 ? col : row;
4313
4314 wxGridSizeEvent gridEvt( GetId(),
4315 type,
4316 this,
4317 rowOrCol,
4318 mouseEv.GetX() + GetRowLabelSize(),
4319 mouseEv.GetY() + GetColLabelSize(),
4320 mouseEv);
4321
4322 GetEventHandler()->ProcessEvent(gridEvt);
4323}
4324
4325// Generate a grid event based on a mouse event and return:
4326// -1 if the event was vetoed
4327// +1 if the event was processed (but not vetoed)
4328// 0 if the event wasn't handled
4329int
4330wxGrid::SendEvent(const wxEventType type,
4331 int row, int col,
4332 const wxMouseEvent& mouseEv)
4333{
4334 bool claimed, vetoed;
4335
4336 if ( type == wxEVT_GRID_RANGE_SELECT )
4337 {
4338 // Right now, it should _never_ end up here!
4339 wxGridRangeSelectEvent gridEvt( GetId(),
4340 type,
4341 this,
4342 m_selectedBlockTopLeft,
4343 m_selectedBlockBottomRight,
4344 true,
4345 mouseEv);
4346
4347 claimed = GetEventHandler()->ProcessEvent(gridEvt);
4348 vetoed = !gridEvt.IsAllowed();
4349 }
4350 else if ( type == wxEVT_GRID_LABEL_LEFT_CLICK ||
4351 type == wxEVT_GRID_LABEL_LEFT_DCLICK ||
4352 type == wxEVT_GRID_LABEL_RIGHT_CLICK ||
4353 type == wxEVT_GRID_LABEL_RIGHT_DCLICK )
4354 {
4355 wxPoint pos = mouseEv.GetPosition();
4356
4357 if ( mouseEv.GetEventObject() == GetGridRowLabelWindow() )
4358 pos.y += GetColLabelSize();
4359 if ( mouseEv.GetEventObject() == GetGridColLabelWindow() )
4360 pos.x += GetRowLabelSize();
4361
4362 wxGridEvent gridEvt( GetId(),
4363 type,
4364 this,
4365 row, col,
4366 pos.x,
4367 pos.y,
4368 false,
4369 mouseEv);
4370 claimed = GetEventHandler()->ProcessEvent(gridEvt);
4371 vetoed = !gridEvt.IsAllowed();
4372 }
4373 else
4374 {
4375 wxGridEvent gridEvt( GetId(),
4376 type,
4377 this,
4378 row, col,
4379 mouseEv.GetX() + GetRowLabelSize(),
4380 mouseEv.GetY() + GetColLabelSize(),
4381 false,
4382 mouseEv);
4383 claimed = GetEventHandler()->ProcessEvent(gridEvt);
4384 vetoed = !gridEvt.IsAllowed();
4385 }
4386
4387 // A Veto'd event may not be `claimed' so test this first
4388 if (vetoed)
4389 return -1;
4390
4391 return claimed ? 1 : 0;
4392}
4393
4394// Generate a grid event of specified type, return value same as above
4395//
4396int
4397wxGrid::SendEvent(const wxEventType type, int row, int col, const wxString& s)
4398{
4399 wxGridEvent gridEvt( GetId(), type, this, row, col );
4400 gridEvt.SetString(s);
4401
4402 const bool claimed = GetEventHandler()->ProcessEvent(gridEvt);
4403
4404 // A Veto'd event may not be `claimed' so test this first
4405 if ( !gridEvt.IsAllowed() )
4406 return -1;
4407
4408 return claimed ? 1 : 0;
4409}
4410
4411void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
4412{
4413 // needed to prevent zillions of paint events on MSW
4414 wxPaintDC dc(this);
4415}
4416
4417void wxGrid::Refresh(bool eraseb, const wxRect* rect)
4418{
4419 // Don't do anything if between Begin/EndBatch...
4420 // EndBatch() will do all this on the last nested one anyway.
4421 if ( m_created && !GetBatchCount() )
4422 {
4423 // Refresh to get correct scrolled position:
4424 wxScrolledWindow::Refresh(eraseb, rect);
4425
4426 if (rect)
4427 {
4428 int rect_x, rect_y, rectWidth, rectHeight;
4429 int width_label, width_cell, height_label, height_cell;
4430 int x, y;
4431
4432 // Copy rectangle can get scroll offsets..
4433 rect_x = rect->GetX();
4434 rect_y = rect->GetY();
4435 rectWidth = rect->GetWidth();
4436 rectHeight = rect->GetHeight();
4437
4438 width_label = m_rowLabelWidth - rect_x;
4439 if (width_label > rectWidth)
4440 width_label = rectWidth;
4441
4442 height_label = m_colLabelHeight - rect_y;
4443 if (height_label > rectHeight)
4444 height_label = rectHeight;
4445
4446 if (rect_x > m_rowLabelWidth)
4447 {
4448 x = rect_x - m_rowLabelWidth;
4449 width_cell = rectWidth;
4450 }
4451 else
4452 {
4453 x = 0;
4454 width_cell = rectWidth - (m_rowLabelWidth - rect_x);
4455 }
4456
4457 if (rect_y > m_colLabelHeight)
4458 {
4459 y = rect_y - m_colLabelHeight;
4460 height_cell = rectHeight;
4461 }
4462 else
4463 {
4464 y = 0;
4465 height_cell = rectHeight - (m_colLabelHeight - rect_y);
4466 }
4467
4468 // Paint corner label part intersecting rect.
4469 if ( width_label > 0 && height_label > 0 )
4470 {
4471 wxRect anotherrect(rect_x, rect_y, width_label, height_label);
4472 m_cornerLabelWin->Refresh(eraseb, &anotherrect);
4473 }
4474
4475 // Paint col labels part intersecting rect.
4476 if ( width_cell > 0 && height_label > 0 )
4477 {
4478 wxRect anotherrect(x, rect_y, width_cell, height_label);
4479 m_colWindow->Refresh(eraseb, &anotherrect);
4480 }
4481
4482 // Paint row labels part intersecting rect.
4483 if ( width_label > 0 && height_cell > 0 )
4484 {
4485 wxRect anotherrect(rect_x, y, width_label, height_cell);
4486 m_rowLabelWin->Refresh(eraseb, &anotherrect);
4487 }
4488
4489 // Paint cell area part intersecting rect.
4490 if ( width_cell > 0 && height_cell > 0 )
4491 {
4492 wxRect anotherrect(x, y, width_cell, height_cell);
4493 m_gridWin->Refresh(eraseb, &anotherrect);
4494 }
4495 }
4496 else
4497 {
4498 m_cornerLabelWin->Refresh(eraseb, NULL);
4499 m_colWindow->Refresh(eraseb, NULL);
4500 m_rowLabelWin->Refresh(eraseb, NULL);
4501 m_gridWin->Refresh(eraseb, NULL);
4502 }
4503 }
4504}
4505
4506void wxGrid::OnSize(wxSizeEvent& WXUNUSED(event))
4507{
4508 if (m_targetWindow != this) // check whether initialisation has been done
4509 {
4510 // reposition our children windows
4511 CalcWindowSizes();
4512 }
4513}
4514
4515void wxGrid::OnKeyDown( wxKeyEvent& event )
4516{
4517 if ( m_inOnKeyDown )
4518 {
4519 // shouldn't be here - we are going round in circles...
4520 //
4521 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
4522 }
4523
4524 m_inOnKeyDown = true;
4525
4526 // propagate the event up and see if it gets processed
4527 wxWindow *parent = GetParent();
4528 wxKeyEvent keyEvt( event );
4529 keyEvt.SetEventObject( parent );
4530
4531 if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
4532 {
4533 if (GetLayoutDirection() == wxLayout_RightToLeft)
4534 {
4535 if (event.GetKeyCode() == WXK_RIGHT)
4536 event.m_keyCode = WXK_LEFT;
4537 else if (event.GetKeyCode() == WXK_LEFT)
4538 event.m_keyCode = WXK_RIGHT;
4539 }
4540
4541 // try local handlers
4542 switch ( event.GetKeyCode() )
4543 {
4544 case WXK_UP:
4545 if ( event.ControlDown() )
4546 MoveCursorUpBlock( event.ShiftDown() );
4547 else
4548 MoveCursorUp( event.ShiftDown() );
4549 break;
4550
4551 case WXK_DOWN:
4552 if ( event.ControlDown() )
4553 MoveCursorDownBlock( event.ShiftDown() );
4554 else
4555 MoveCursorDown( event.ShiftDown() );
4556 break;
4557
4558 case WXK_LEFT:
4559 if ( event.ControlDown() )
4560 MoveCursorLeftBlock( event.ShiftDown() );
4561 else
4562 MoveCursorLeft( event.ShiftDown() );
4563 break;
4564
4565 case WXK_RIGHT:
4566 if ( event.ControlDown() )
4567 MoveCursorRightBlock( event.ShiftDown() );
4568 else
4569 MoveCursorRight( event.ShiftDown() );
4570 break;
4571
4572 case WXK_RETURN:
4573 case WXK_NUMPAD_ENTER:
4574 if ( event.ControlDown() )
4575 {
4576 event.Skip(); // to let the edit control have the return
4577 }
4578 else
4579 {
4580 if ( GetGridCursorRow() < GetNumberRows()-1 )
4581 {
4582 MoveCursorDown( event.ShiftDown() );
4583 }
4584 else
4585 {
4586 // at the bottom of a column
4587 DisableCellEditControl();
4588 }
4589 }
4590 break;
4591
4592 case WXK_ESCAPE:
4593 ClearSelection();
4594 break;
4595
4596 case WXK_TAB:
4597 if (event.ShiftDown())
4598 {
4599 if ( GetGridCursorCol() > 0 )
4600 {
4601 MoveCursorLeft( false );
4602 }
4603 else
4604 {
4605 // at left of grid
4606 DisableCellEditControl();
4607 }
4608 }
4609 else
4610 {
4611 if ( GetGridCursorCol() < GetNumberCols() - 1 )
4612 {
4613 MoveCursorRight( false );
4614 }
4615 else
4616 {
4617 // at right of grid
4618 DisableCellEditControl();
4619 }
4620 }
4621 break;
4622
4623 case WXK_HOME:
4624 GoToCell(event.ControlDown() ? 0
4625 : m_currentCellCoords.GetRow(),
4626 0);
4627 break;
4628
4629 case WXK_END:
4630 GoToCell(event.ControlDown() ? m_numRows - 1
4631 : m_currentCellCoords.GetRow(),
4632 m_numCols - 1);
4633 break;
4634
4635 case WXK_PAGEUP:
4636 MovePageUp();
4637 break;
4638
4639 case WXK_PAGEDOWN:
4640 MovePageDown();
4641 break;
4642
4643 case WXK_SPACE:
4644 // Ctrl-Space selects the current column, Shift-Space -- the
4645 // current row and Ctrl-Shift-Space -- everything
4646 switch ( m_selection ? event.GetModifiers() : wxMOD_NONE )
4647 {
4648 case wxMOD_CONTROL:
4649 m_selection->SelectCol(m_currentCellCoords.GetCol());
4650 break;
4651
4652 case wxMOD_SHIFT:
4653 m_selection->SelectRow(m_currentCellCoords.GetRow());
4654 break;
4655
4656 case wxMOD_CONTROL | wxMOD_SHIFT:
4657 m_selection->SelectBlock(0, 0,
4658 m_numRows - 1, m_numCols - 1);
4659 break;
4660
4661 case wxMOD_NONE:
4662 if ( !IsEditable() )
4663 {
4664 MoveCursorRight(false);
4665 break;
4666 }
4667 //else: fall through
4668
4669 default:
4670 event.Skip();
4671 }
4672 break;
4673
4674 default:
4675 event.Skip();
4676 break;
4677 }
4678 }
4679
4680 m_inOnKeyDown = false;
4681}
4682
4683void wxGrid::OnKeyUp( wxKeyEvent& event )
4684{
4685 // try local handlers
4686 //
4687 if ( event.GetKeyCode() == WXK_SHIFT )
4688 {
4689 if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
4690 m_selectedBlockBottomRight != wxGridNoCellCoords )
4691 {
4692 if ( m_selection )
4693 {
4694 m_selection->SelectBlock(
4695 m_selectedBlockTopLeft,
4696 m_selectedBlockBottomRight,
4697 event);
4698 }
4699 }
4700
4701 m_selectedBlockTopLeft = wxGridNoCellCoords;
4702 m_selectedBlockBottomRight = wxGridNoCellCoords;
4703 m_selectedBlockCorner = wxGridNoCellCoords;
4704 }
4705}
4706
4707void wxGrid::OnChar( wxKeyEvent& event )
4708{
4709 // is it possible to edit the current cell at all?
4710 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
4711 {
4712 // yes, now check whether the cells editor accepts the key
4713 int row = m_currentCellCoords.GetRow();
4714 int col = m_currentCellCoords.GetCol();
4715 wxGridCellAttr *attr = GetCellAttr(row, col);
4716 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
4717
4718 // <F2> is special and will always start editing, for
4719 // other keys - ask the editor itself
4720 if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
4721 || editor->IsAcceptedKey(event) )
4722 {
4723 // ensure cell is visble
4724 MakeCellVisible(row, col);
4725 EnableCellEditControl();
4726
4727 // a problem can arise if the cell is not completely
4728 // visible (even after calling MakeCellVisible the
4729 // control is not created and calling StartingKey will
4730 // crash the app
4731 if ( event.GetKeyCode() != WXK_F2 && editor->IsCreated() && m_cellEditCtrlEnabled )
4732 editor->StartingKey(event);
4733 }
4734 else
4735 {
4736 event.Skip();
4737 }
4738
4739 editor->DecRef();
4740 attr->DecRef();
4741 }
4742 else
4743 {
4744 event.Skip();
4745 }
4746}
4747
4748void wxGrid::OnEraseBackground(wxEraseEvent&)
4749{
4750}
4751
4752bool wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
4753{
4754 if ( SendEvent(wxEVT_GRID_SELECT_CELL, coords) == -1 )
4755 {
4756 // the event has been vetoed - do nothing
4757 return false;
4758 }
4759
4760#if !defined(__WXMAC__)
4761 wxClientDC dc( m_gridWin );
4762 PrepareDC( dc );
4763#endif
4764
4765 if ( m_currentCellCoords != wxGridNoCellCoords )
4766 {
4767 DisableCellEditControl();
4768
4769 if ( IsVisible( m_currentCellCoords, false ) )
4770 {
4771 wxRect r;
4772 r = BlockToDeviceRect( m_currentCellCoords, m_currentCellCoords );
4773 if ( !m_gridLinesEnabled )
4774 {
4775 r.x--;
4776 r.y--;
4777 r.width++;
4778 r.height++;
4779 }
4780
4781 wxGridCellCoordsArray cells = CalcCellsExposed( r );
4782
4783 // Otherwise refresh redraws the highlight!
4784 m_currentCellCoords = coords;
4785
4786#if defined(__WXMAC__)
4787 m_gridWin->Refresh(true /*, & r */);
4788#else
4789 DrawGridCellArea( dc, cells );
4790 DrawAllGridLines( dc, r );
4791#endif
4792 }
4793 }
4794
4795 m_currentCellCoords = coords;
4796
4797 wxGridCellAttr *attr = GetCellAttr( coords );
4798#if !defined(__WXMAC__)
4799 DrawCellHighlight( dc, attr );
4800#endif
4801 attr->DecRef();
4802
4803 return true;
4804}
4805
4806void
4807wxGrid::UpdateBlockBeingSelected(int topRow, int leftCol,
4808 int bottomRow, int rightCol)
4809{
4810 MakeCellVisible(m_selectedBlockCorner);
4811 m_selectedBlockCorner = wxGridCellCoords(bottomRow, rightCol);
4812
4813 if ( m_selection )
4814 {
4815 switch ( m_selection->GetSelectionMode() )
4816 {
4817 default:
4818 wxFAIL_MSG( "unknown selection mode" );
4819 // fall through
4820
4821 case wxGridSelectCells:
4822 // arbitrary blocks selection allowed so just use the cell
4823 // coordinates as is
4824 break;
4825
4826 case wxGridSelectRows:
4827 // only full rows selection allowd, ensure that we do select
4828 // full rows
4829 leftCol = 0;
4830 rightCol = GetNumberCols() - 1;
4831 break;
4832
4833 case wxGridSelectColumns:
4834 // same as above but for columns
4835 topRow = 0;
4836 bottomRow = GetNumberRows() - 1;
4837 break;
4838
4839 case wxGridSelectRowsOrColumns:
4840 // in this mode we can select only full rows or full columns so
4841 // it doesn't make sense to select blocks at all (and we can't
4842 // extend the block because there is no preferred direction, we
4843 // could only extend it to cover the entire grid but this is
4844 // not useful)
4845 return;
4846 }
4847 }
4848
4849 EnsureFirstLessThanSecond(topRow, bottomRow);
4850 EnsureFirstLessThanSecond(leftCol, rightCol);
4851
4852 wxGridCellCoords updateTopLeft = wxGridCellCoords(topRow, leftCol),
4853 updateBottomRight = wxGridCellCoords(bottomRow, rightCol);
4854
4855 // First the case that we selected a completely new area
4856 if ( m_selectedBlockTopLeft == wxGridNoCellCoords ||
4857 m_selectedBlockBottomRight == wxGridNoCellCoords )
4858 {
4859 wxRect rect;
4860 rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
4861 wxGridCellCoords ( bottomRow, rightCol ) );
4862 m_gridWin->Refresh( false, &rect );
4863 }
4864
4865 // Now handle changing an existing selection area.
4866 else if ( m_selectedBlockTopLeft != updateTopLeft ||
4867 m_selectedBlockBottomRight != updateBottomRight )
4868 {
4869 // Compute two optimal update rectangles:
4870 // Either one rectangle is a real subset of the
4871 // other, or they are (almost) disjoint!
4872 wxRect rect[4];
4873 bool need_refresh[4];
4874 need_refresh[0] =
4875 need_refresh[1] =
4876 need_refresh[2] =
4877 need_refresh[3] = false;
4878 int i;
4879
4880 // Store intermediate values
4881 wxCoord oldLeft = m_selectedBlockTopLeft.GetCol();
4882 wxCoord oldTop = m_selectedBlockTopLeft.GetRow();
4883 wxCoord oldRight = m_selectedBlockBottomRight.GetCol();
4884 wxCoord oldBottom = m_selectedBlockBottomRight.GetRow();
4885
4886 // Determine the outer/inner coordinates.
4887 EnsureFirstLessThanSecond(oldLeft, leftCol);
4888 EnsureFirstLessThanSecond(oldTop, topRow);
4889 EnsureFirstLessThanSecond(rightCol, oldRight);
4890 EnsureFirstLessThanSecond(bottomRow, oldBottom);
4891
4892 // Now, either the stuff marked old is the outer
4893 // rectangle or we don't have a situation where one
4894 // is contained in the other.
4895
4896 if ( oldLeft < leftCol )
4897 {
4898 // Refresh the newly selected or deselected
4899 // area to the left of the old or new selection.
4900 need_refresh[0] = true;
4901 rect[0] = BlockToDeviceRect(
4902 wxGridCellCoords( oldTop, oldLeft ),
4903 wxGridCellCoords( oldBottom, leftCol - 1 ) );
4904 }
4905
4906 if ( oldTop < topRow )
4907 {
4908 // Refresh the newly selected or deselected
4909 // area above the old or new selection.
4910 need_refresh[1] = true;
4911 rect[1] = BlockToDeviceRect(
4912 wxGridCellCoords( oldTop, leftCol ),
4913 wxGridCellCoords( topRow - 1, rightCol ) );
4914 }
4915
4916 if ( oldRight > rightCol )
4917 {
4918 // Refresh the newly selected or deselected
4919 // area to the right of the old or new selection.
4920 need_refresh[2] = true;
4921 rect[2] = BlockToDeviceRect(
4922 wxGridCellCoords( oldTop, rightCol + 1 ),
4923 wxGridCellCoords( oldBottom, oldRight ) );
4924 }
4925
4926 if ( oldBottom > bottomRow )
4927 {
4928 // Refresh the newly selected or deselected
4929 // area below the old or new selection.
4930 need_refresh[3] = true;
4931 rect[3] = BlockToDeviceRect(
4932 wxGridCellCoords( bottomRow + 1, leftCol ),
4933 wxGridCellCoords( oldBottom, rightCol ) );
4934 }
4935
4936 // various Refresh() calls
4937 for (i = 0; i < 4; i++ )
4938 if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
4939 m_gridWin->Refresh( false, &(rect[i]) );
4940 }
4941
4942 // change selection
4943 m_selectedBlockTopLeft = updateTopLeft;
4944 m_selectedBlockBottomRight = updateBottomRight;
4945}
4946
4947//
4948// ------ functions to get/send data (see also public functions)
4949//
4950
4951bool wxGrid::GetModelValues()
4952{
4953 // Hide the editor, so it won't hide a changed value.
4954 HideCellEditControl();
4955
4956 if ( m_table )
4957 {
4958 // all we need to do is repaint the grid
4959 //
4960 m_gridWin->Refresh();
4961 return true;
4962 }
4963
4964 return false;
4965}
4966
4967bool wxGrid::SetModelValues()
4968{
4969 int row, col;
4970
4971 // Disable the editor, so it won't hide a changed value.
4972 // Do we also want to save the current value of the editor first?
4973 // I think so ...
4974 DisableCellEditControl();
4975
4976 if ( m_table )
4977 {
4978 for ( row = 0; row < m_numRows; row++ )
4979 {
4980 for ( col = 0; col < m_numCols; col++ )
4981 {
4982 m_table->SetValue( row, col, GetCellValue(row, col) );
4983 }
4984 }
4985
4986 return true;
4987 }
4988
4989 return false;
4990}
4991
4992// Note - this function only draws cells that are in the list of
4993// exposed cells (usually set from the update region by
4994// CalcExposedCells)
4995//
4996void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
4997{
4998 if ( !m_numRows || !m_numCols )
4999 return;
5000
5001 int i, numCells = cells.GetCount();
5002 int row, col, cell_rows, cell_cols;
5003 wxGridCellCoordsArray redrawCells;
5004
5005 for ( i = numCells - 1; i >= 0; i-- )
5006 {
5007 row = cells[i].GetRow();
5008 col = cells[i].GetCol();
5009 GetCellSize( row, col, &cell_rows, &cell_cols );
5010
5011 // If this cell is part of a multicell block, find owner for repaint
5012 if ( cell_rows <= 0 || cell_cols <= 0 )
5013 {
5014 wxGridCellCoords cell( row + cell_rows, col + cell_cols );
5015 bool marked = false;
5016 for ( int j = 0; j < numCells; j++ )
5017 {
5018 if ( cell == cells[j] )
5019 {
5020 marked = true;
5021 break;
5022 }
5023 }
5024
5025 if (!marked)
5026 {
5027 int count = redrawCells.GetCount();
5028 for (int j = 0; j < count; j++)
5029 {
5030 if ( cell == redrawCells[j] )
5031 {
5032 marked = true;
5033 break;
5034 }
5035 }
5036
5037 if (!marked)
5038 redrawCells.Add( cell );
5039 }
5040
5041 // don't bother drawing this cell
5042 continue;
5043 }
5044
5045 // If this cell is empty, find cell to left that might want to overflow
5046 if (m_table && m_table->IsEmptyCell(row, col))
5047 {
5048 for ( int l = 0; l < cell_rows; l++ )
5049 {
5050 // find a cell in this row to leave already marked for repaint
5051 int left = col;
5052 for (int k = 0; k < int(redrawCells.GetCount()); k++)
5053 if ((redrawCells[k].GetCol() < left) &&
5054 (redrawCells[k].GetRow() == row))
5055 {
5056 left = redrawCells[k].GetCol();
5057 }
5058
5059 if (left == col)
5060 left = 0; // oh well
5061
5062 for (int j = col - 1; j >= left; j--)
5063 {
5064 if (!m_table->IsEmptyCell(row + l, j))
5065 {
5066 if (GetCellOverflow(row + l, j))
5067 {
5068 wxGridCellCoords cell(row + l, j);
5069 bool marked = false;
5070
5071 for (int k = 0; k < numCells; k++)
5072 {
5073 if ( cell == cells[k] )
5074 {
5075 marked = true;
5076 break;
5077 }
5078 }
5079
5080 if (!marked)
5081 {
5082 int count = redrawCells.GetCount();
5083 for (int k = 0; k < count; k++)
5084 {
5085 if ( cell == redrawCells[k] )
5086 {
5087 marked = true;
5088 break;
5089 }
5090 }
5091 if (!marked)
5092 redrawCells.Add( cell );
5093 }
5094 }
5095 break;
5096 }
5097 }
5098 }
5099 }
5100
5101 DrawCell( dc, cells[i] );
5102 }
5103
5104 numCells = redrawCells.GetCount();
5105
5106 for ( i = numCells - 1; i >= 0; i-- )
5107 {
5108 DrawCell( dc, redrawCells[i] );
5109 }
5110}
5111
5112void wxGrid::DrawGridSpace( wxDC& dc )
5113{
5114 int cw, ch;
5115 m_gridWin->GetClientSize( &cw, &ch );
5116
5117 int right, bottom;
5118 CalcUnscrolledPosition( cw, ch, &right, &bottom );
5119
5120 int rightCol = m_numCols > 0 ? GetColRight(GetColAt( m_numCols - 1 )) : 0;
5121 int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
5122
5123 if ( right > rightCol || bottom > bottomRow )
5124 {
5125 int left, top;
5126 CalcUnscrolledPosition( 0, 0, &left, &top );
5127
5128 dc.SetBrush(GetDefaultCellBackgroundColour());
5129 dc.SetPen( *wxTRANSPARENT_PEN );
5130
5131 if ( right > rightCol )
5132 {
5133 dc.DrawRectangle( rightCol, top, right - rightCol, ch );
5134 }
5135
5136 if ( bottom > bottomRow )
5137 {
5138 dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow );
5139 }
5140 }
5141}
5142
5143void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
5144{
5145 int row = coords.GetRow();
5146 int col = coords.GetCol();
5147
5148 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5149 return;
5150
5151 // we draw the cell border ourselves
5152 wxGridCellAttr* attr = GetCellAttr(row, col);
5153
5154 bool isCurrent = coords == m_currentCellCoords;
5155
5156 wxRect rect = CellToRect( row, col );
5157
5158 // if the editor is shown, we should use it and not the renderer
5159 // Note: However, only if it is really _shown_, i.e. not hidden!
5160 if ( isCurrent && IsCellEditControlShown() )
5161 {
5162 // NB: this "#if..." is temporary and fixes a problem where the
5163 // edit control is erased by this code after being rendered.
5164 // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
5165 // implicitly, causing this out-of order render.
5166#if !defined(__WXMAC__)
5167 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5168 editor->PaintBackground(rect, attr);
5169 editor->DecRef();
5170#endif
5171 }
5172 else
5173 {
5174 // but all the rest is drawn by the cell renderer and hence may be customized
5175 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
5176 renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
5177 renderer->DecRef();
5178 }
5179
5180 attr->DecRef();
5181}
5182
5183void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
5184{
5185 // don't show highlight when the grid doesn't have focus
5186 if ( !HasFocus() )
5187 return;
5188
5189 int row = m_currentCellCoords.GetRow();
5190 int col = m_currentCellCoords.GetCol();
5191
5192 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5193 return;
5194
5195 wxRect rect = CellToRect(row, col);
5196
5197 // hmmm... what could we do here to show that the cell is disabled?
5198 // for now, I just draw a thinner border than for the other ones, but
5199 // it doesn't look really good
5200
5201 int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
5202
5203 if (penWidth > 0)
5204 {
5205 // The center of the drawn line is where the position/width/height of
5206 // the rectangle is actually at (on wxMSW at least), so the
5207 // size of the rectangle is reduced to compensate for the thickness of
5208 // the line. If this is too strange on non-wxMSW platforms then
5209 // please #ifdef this appropriately.
5210 rect.x += penWidth / 2;
5211 rect.y += penWidth / 2;
5212 rect.width -= penWidth - 1;
5213 rect.height -= penWidth - 1;
5214
5215 // Now draw the rectangle
5216 // use the cellHighlightColour if the cell is inside a selection, this
5217 // will ensure the cell is always visible.
5218 dc.SetPen(wxPen(IsInSelection(row,col) ? m_selectionForeground
5219 : m_cellHighlightColour,
5220 penWidth));
5221 dc.SetBrush(*wxTRANSPARENT_BRUSH);
5222 dc.DrawRectangle(rect);
5223 }
5224}
5225
5226wxPen wxGrid::GetDefaultGridLinePen()
5227{
5228 return wxPen(GetGridLineColour());
5229}
5230
5231wxPen wxGrid::GetRowGridLinePen(int WXUNUSED(row))
5232{
5233 return GetDefaultGridLinePen();
5234}
5235
5236wxPen wxGrid::GetColGridLinePen(int WXUNUSED(col))
5237{
5238 return GetDefaultGridLinePen();
5239}
5240
5241void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
5242{
5243 int row = coords.GetRow();
5244 int col = coords.GetCol();
5245 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5246 return;
5247
5248
5249 wxRect rect = CellToRect( row, col );
5250
5251 // right hand border
5252 dc.SetPen( GetColGridLinePen(col) );
5253 dc.DrawLine( rect.x + rect.width, rect.y,
5254 rect.x + rect.width, rect.y + rect.height + 1 );
5255
5256 // bottom border
5257 dc.SetPen( GetRowGridLinePen(row) );
5258 dc.DrawLine( rect.x, rect.y + rect.height,
5259 rect.x + rect.width, rect.y + rect.height);
5260}
5261
5262void wxGrid::DrawHighlight(wxDC& dc, const wxGridCellCoordsArray& cells)
5263{
5264 // This if block was previously in wxGrid::OnPaint but that doesn't
5265 // seem to get called under wxGTK - MB
5266 //
5267 if ( m_currentCellCoords == wxGridNoCellCoords &&
5268 m_numRows && m_numCols )
5269 {
5270 m_currentCellCoords.Set(0, 0);
5271 }
5272
5273 if ( IsCellEditControlShown() )
5274 {
5275 // don't show highlight when the edit control is shown
5276 return;
5277 }
5278
5279 // if the active cell was repainted, repaint its highlight too because it
5280 // might have been damaged by the grid lines
5281 size_t count = cells.GetCount();
5282 for ( size_t n = 0; n < count; n++ )
5283 {
5284 wxGridCellCoords cell = cells[n];
5285
5286 // If we are using attributes, then we may have just exposed another
5287 // cell in a partially-visible merged cluster of cells. If the "anchor"
5288 // (upper left) cell of this merged cluster is the cell indicated by
5289 // m_currentCellCoords, then we need to refresh the cell highlight even
5290 // though the "anchor" itself is not part of our update segment.
5291 if ( CanHaveAttributes() )
5292 {
5293 int rows = 0,
5294 cols = 0;
5295 GetCellSize(cell.GetRow(), cell.GetCol(), &rows, &cols);
5296
5297 if ( rows < 0 )
5298 cell.SetRow(cell.GetRow() + rows);
5299
5300 if ( cols < 0 )
5301 cell.SetCol(cell.GetCol() + cols);
5302 }
5303
5304 if ( cell == m_currentCellCoords )
5305 {
5306 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5307 DrawCellHighlight(dc, attr);
5308 attr->DecRef();
5309
5310 break;
5311 }
5312 }
5313}
5314
5315// This is used to redraw all grid lines e.g. when the grid line colour
5316// has been changed
5317//
5318void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
5319{
5320 if ( !m_gridLinesEnabled )
5321 return;
5322
5323 int top, bottom, left, right;
5324
5325 int cw, ch;
5326 m_gridWin->GetClientSize(&cw, &ch);
5327 CalcUnscrolledPosition( 0, 0, &left, &top );
5328 CalcUnscrolledPosition( cw, ch, &right, &bottom );
5329
5330 // avoid drawing grid lines past the last row and col
5331 if ( m_gridLinesClipHorz )
5332 {
5333 if ( !m_numCols )
5334 return;
5335
5336 const int lastColRight = GetColRight(GetColAt(m_numCols - 1));
5337 if ( right > lastColRight )
5338 right = lastColRight;
5339 }
5340
5341 if ( m_gridLinesClipVert )
5342 {
5343 if ( !m_numRows )
5344 return;
5345
5346 const int lastRowBottom = GetRowBottom(m_numRows - 1);
5347 if ( bottom > lastRowBottom )
5348 bottom = lastRowBottom;
5349 }
5350
5351 // no gridlines inside multicells, clip them out
5352 int leftCol = GetColPos( internalXToCol(left) );
5353 int topRow = internalYToRow(top);
5354 int rightCol = GetColPos( internalXToCol(right) );
5355 int bottomRow = internalYToRow(bottom);
5356
5357 wxRegion clippedcells(0, 0, cw, ch);
5358
5359 int cell_rows, cell_cols;
5360 wxRect rect;
5361
5362 for ( int j = topRow; j <= bottomRow; j++ )
5363 {
5364 for ( int colPos = leftCol; colPos <= rightCol; colPos++ )
5365 {
5366 int i = GetColAt( colPos );
5367
5368 GetCellSize( j, i, &cell_rows, &cell_cols );
5369 if ((cell_rows > 1) || (cell_cols > 1))
5370 {
5371 rect = CellToRect(j,i);
5372 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5373 clippedcells.Subtract(rect);
5374 }
5375 else if ((cell_rows < 0) || (cell_cols < 0))
5376 {
5377 rect = CellToRect(j + cell_rows, i + cell_cols);
5378 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5379 clippedcells.Subtract(rect);
5380 }
5381 }
5382 }
5383
5384 dc.SetDeviceClippingRegion( clippedcells );
5385
5386
5387 // horizontal grid lines
5388 for ( int i = internalYToRow(top); i < m_numRows; i++ )
5389 {
5390 int bot = GetRowBottom(i) - 1;
5391
5392 if ( bot > bottom )
5393 break;
5394
5395 if ( bot >= top )
5396 {
5397 dc.SetPen( GetRowGridLinePen(i) );
5398 dc.DrawLine( left, bot, right, bot );
5399 }
5400 }
5401
5402 // vertical grid lines
5403 for ( int colPos = leftCol; colPos < m_numCols; colPos++ )
5404 {
5405 int i = GetColAt( colPos );
5406
5407 int colRight = GetColRight(i);
5408#ifdef __WXGTK__
5409 if (GetLayoutDirection() != wxLayout_RightToLeft)
5410#endif
5411 colRight--;
5412
5413 if ( colRight > right )
5414 break;
5415
5416 if ( colRight >= left )
5417 {
5418 dc.SetPen( GetColGridLinePen(i) );
5419 dc.DrawLine( colRight, top, colRight, bottom );
5420 }
5421 }
5422
5423 dc.DestroyClippingRegion();
5424}
5425
5426void wxGrid::DrawRowLabels( wxDC& dc, const wxArrayInt& rows)
5427{
5428 if ( !m_numRows )
5429 return;
5430
5431 const size_t numLabels = rows.GetCount();
5432 for ( size_t i = 0; i < numLabels; i++ )
5433 {
5434 DrawRowLabel( dc, rows[i] );
5435 }
5436}
5437
5438void wxGrid::DrawRowLabel( wxDC& dc, int row )
5439{
5440 if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
5441 return;
5442
5443 wxGridCellAttrProvider * const
5444 attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5445
5446 // notice that an explicit static_cast is needed to avoid a compilation
5447 // error with VC7.1 which, for some reason, tries to instantiate (abstract)
5448 // wxGridRowHeaderRenderer class without it
5449 const wxGridRowHeaderRenderer&
5450 rend = attrProvider ? attrProvider->GetRowHeaderRenderer(row)
5451 : static_cast<const wxGridRowHeaderRenderer&>
5452 (gs_defaultHeaderRenderers.rowRenderer);
5453
5454 wxRect rect(0, GetRowTop(row), m_rowLabelWidth, GetRowHeight(row));
5455 rend.DrawBorder(*this, dc, rect);
5456
5457 int hAlign, vAlign;
5458 GetRowLabelAlignment(&hAlign, &vAlign);
5459
5460 rend.DrawLabel(*this, dc, GetRowLabelValue(row),
5461 rect, hAlign, vAlign, wxHORIZONTAL);
5462}
5463
5464void wxGrid::UseNativeColHeader(bool native)
5465{
5466 if ( native == m_useNativeHeader )
5467 return;
5468
5469 delete m_colWindow;
5470 m_useNativeHeader = native;
5471
5472 CreateColumnWindow();
5473
5474 if ( m_useNativeHeader )
5475 GetGridColHeader()->SetColumnCount(m_numCols);
5476 CalcWindowSizes();
5477}
5478
5479void wxGrid::SetUseNativeColLabels( bool native )
5480{
5481 wxASSERT_MSG( !m_useNativeHeader,
5482 "doesn't make sense when using native header" );
5483
5484 m_nativeColumnLabels = native;
5485 if (native)
5486 {
5487 int height = wxRendererNative::Get().GetHeaderButtonHeight( this );
5488 SetColLabelSize( height );
5489 }
5490
5491 GetColLabelWindow()->Refresh();
5492 m_cornerLabelWin->Refresh();
5493}
5494
5495void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
5496{
5497 if ( !m_numCols )
5498 return;
5499
5500 const size_t numLabels = cols.GetCount();
5501 for ( size_t i = 0; i < numLabels; i++ )
5502 {
5503 DrawColLabel( dc, cols[i] );
5504 }
5505}
5506
5507void wxGrid::DrawCornerLabel(wxDC& dc)
5508{
5509 wxRect rect(wxSize(m_rowLabelWidth, m_colLabelHeight));
5510
5511 if ( m_nativeColumnLabels )
5512 {
5513 rect.Deflate(1);
5514
5515 wxRendererNative::Get().DrawHeaderButton(m_cornerLabelWin, dc, rect, 0);
5516 }
5517 else
5518 {
5519 rect.width++;
5520 rect.height++;
5521
5522 wxGridCellAttrProvider * const
5523 attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5524 const wxGridCornerHeaderRenderer&
5525 rend = attrProvider ? attrProvider->GetCornerRenderer()
5526 : static_cast<wxGridCornerHeaderRenderer&>
5527 (gs_defaultHeaderRenderers.cornerRenderer);
5528
5529 rend.DrawBorder(*this, dc, rect);
5530 }
5531}
5532
5533void wxGrid::DrawColLabel(wxDC& dc, int col)
5534{
5535 if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
5536 return;
5537
5538 int colLeft = GetColLeft(col);
5539
5540 wxRect rect(colLeft, 0, GetColWidth(col), m_colLabelHeight);
5541 wxGridCellAttrProvider * const
5542 attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5543 const wxGridColumnHeaderRenderer&
5544 rend = attrProvider ? attrProvider->GetColumnHeaderRenderer(col)
5545 : static_cast<wxGridColumnHeaderRenderer&>
5546 (gs_defaultHeaderRenderers.colRenderer);
5547
5548 if ( m_nativeColumnLabels )
5549 {
5550 wxRendererNative::Get().DrawHeaderButton
5551 (
5552 GetColLabelWindow(),
5553 dc,
5554 rect,
5555 0,
5556 IsSortingBy(col)
5557 ? IsSortOrderAscending()
5558 ? wxHDR_SORT_ICON_UP
5559 : wxHDR_SORT_ICON_DOWN
5560 : wxHDR_SORT_ICON_NONE
5561 );
5562 rect.Deflate(2);
5563 }
5564 else
5565 {
5566 // It is reported that we need to erase the background to avoid display
5567 // artefacts, see #12055.
5568 wxDCBrushChanger setBrush(dc, m_colWindow->GetBackgroundColour());
5569 dc.DrawRectangle(rect);
5570
5571 rend.DrawBorder(*this, dc, rect);
5572 }
5573
5574 int hAlign, vAlign;
5575 GetColLabelAlignment(&hAlign, &vAlign);
5576 const int orient = GetColLabelTextOrientation();
5577
5578 rend.DrawLabel(*this, dc, GetColLabelValue(col), rect, hAlign, vAlign, orient);
5579}
5580
5581// TODO: these 2 functions should be replaced with wxDC::DrawLabel() to which
5582// we just have to add textOrientation support
5583void wxGrid::DrawTextRectangle( wxDC& dc,
5584 const wxString& value,
5585 const wxRect& rect,
5586 int horizAlign,
5587 int vertAlign,
5588 int textOrientation ) const
5589{
5590 wxArrayString lines;
5591
5592 StringToLines( value, lines );
5593
5594 DrawTextRectangle(dc, lines, rect, horizAlign, vertAlign, textOrientation);
5595}
5596
5597void wxGrid::DrawTextRectangle(wxDC& dc,
5598 const wxArrayString& lines,
5599 const wxRect& rect,
5600 int horizAlign,
5601 int vertAlign,
5602 int textOrientation) const
5603{
5604 if ( lines.empty() )
5605 return;
5606
5607 wxDCClipper clip(dc, rect);
5608
5609 long textWidth,
5610 textHeight;
5611
5612 if ( textOrientation == wxHORIZONTAL )
5613 GetTextBoxSize( dc, lines, &textWidth, &textHeight );
5614 else
5615 GetTextBoxSize( dc, lines, &textHeight, &textWidth );
5616
5617 int x = 0,
5618 y = 0;
5619 switch ( vertAlign )
5620 {
5621 case wxALIGN_BOTTOM:
5622 if ( textOrientation == wxHORIZONTAL )
5623 y = rect.y + (rect.height - textHeight - 1);
5624 else
5625 x = rect.x + rect.width - textWidth;
5626 break;
5627
5628 case wxALIGN_CENTRE:
5629 if ( textOrientation == wxHORIZONTAL )
5630 y = rect.y + ((rect.height - textHeight) / 2);
5631 else
5632 x = rect.x + ((rect.width - textWidth) / 2);
5633 break;
5634
5635 case wxALIGN_TOP:
5636 default:
5637 if ( textOrientation == wxHORIZONTAL )
5638 y = rect.y + 1;
5639 else
5640 x = rect.x + 1;
5641 break;
5642 }
5643
5644 // Align each line of a multi-line label
5645 size_t nLines = lines.GetCount();
5646 for ( size_t l = 0; l < nLines; l++ )
5647 {
5648 const wxString& line = lines[l];
5649
5650 if ( line.empty() )
5651 {
5652 *(textOrientation == wxHORIZONTAL ? &y : &x) += dc.GetCharHeight();
5653 continue;
5654 }
5655
5656 wxCoord lineWidth = 0,
5657 lineHeight = 0;
5658 dc.GetTextExtent(line, &lineWidth, &lineHeight);
5659
5660 switch ( horizAlign )
5661 {
5662 case wxALIGN_RIGHT:
5663 if ( textOrientation == wxHORIZONTAL )
5664 x = rect.x + (rect.width - lineWidth - 1);
5665 else
5666 y = rect.y + lineWidth + 1;
5667 break;
5668
5669 case wxALIGN_CENTRE:
5670 if ( textOrientation == wxHORIZONTAL )
5671 x = rect.x + ((rect.width - lineWidth) / 2);
5672 else
5673 y = rect.y + rect.height - ((rect.height - lineWidth) / 2);
5674 break;
5675
5676 case wxALIGN_LEFT:
5677 default:
5678 if ( textOrientation == wxHORIZONTAL )
5679 x = rect.x + 1;
5680 else
5681 y = rect.y + rect.height - 1;
5682 break;
5683 }
5684
5685 if ( textOrientation == wxHORIZONTAL )
5686 {
5687 dc.DrawText( line, x, y );
5688 y += lineHeight;
5689 }
5690 else
5691 {
5692 dc.DrawRotatedText( line, x, y, 90.0 );
5693 x += lineHeight;
5694 }
5695 }
5696}
5697
5698// Split multi-line text up into an array of strings.
5699// Any existing contents of the string array are preserved.
5700//
5701// TODO: refactor wxTextFile::Read() and reuse the same code from here
5702void wxGrid::StringToLines( const wxString& value, wxArrayString& lines ) const
5703{
5704 int startPos = 0;
5705 int pos;
5706 wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
5707 wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
5708
5709 while ( startPos < (int)tVal.length() )
5710 {
5711 pos = tVal.Mid(startPos).Find( eol );
5712 if ( pos < 0 )
5713 {
5714 break;
5715 }
5716 else if ( pos == 0 )
5717 {
5718 lines.Add( wxEmptyString );
5719 }
5720 else
5721 {
5722 lines.Add( tVal.Mid(startPos, pos) );
5723 }
5724
5725 startPos += pos + 1;
5726 }
5727
5728 if ( startPos < (int)tVal.length() )
5729 {
5730 lines.Add( tVal.Mid( startPos ) );
5731 }
5732}
5733
5734void wxGrid::GetTextBoxSize( const wxDC& dc,
5735 const wxArrayString& lines,
5736 long *width, long *height ) const
5737{
5738 wxCoord w = 0;
5739 wxCoord h = 0;
5740 wxCoord lineW = 0, lineH = 0;
5741
5742 size_t i;
5743 for ( i = 0; i < lines.GetCount(); i++ )
5744 {
5745 dc.GetTextExtent( lines[i], &lineW, &lineH );
5746 w = wxMax( w, lineW );
5747 h += lineH;
5748 }
5749
5750 *width = w;
5751 *height = h;
5752}
5753
5754//
5755// ------ Batch processing.
5756//
5757void wxGrid::EndBatch()
5758{
5759 if ( m_batchCount > 0 )
5760 {
5761 m_batchCount--;
5762 if ( !m_batchCount )
5763 {
5764 CalcDimensions();
5765 m_rowLabelWin->Refresh();
5766 m_colWindow->Refresh();
5767 m_cornerLabelWin->Refresh();
5768 m_gridWin->Refresh();
5769 }
5770 }
5771}
5772
5773// Use this, rather than wxWindow::Refresh(), to force an immediate
5774// repainting of the grid. Has no effect if you are already inside a
5775// BeginBatch / EndBatch block.
5776//
5777void wxGrid::ForceRefresh()
5778{
5779 BeginBatch();
5780 EndBatch();
5781}
5782
5783bool wxGrid::Enable(bool enable)
5784{
5785 if ( !wxScrolledWindow::Enable(enable) )
5786 return false;
5787
5788 // redraw in the new state
5789 m_gridWin->Refresh();
5790
5791 return true;
5792}
5793
5794//
5795// ------ Edit control functions
5796//
5797
5798void wxGrid::EnableEditing( bool edit )
5799{
5800 if ( edit != m_editable )
5801 {
5802 if (!edit)
5803 EnableCellEditControl(edit);
5804 m_editable = edit;
5805 }
5806}
5807
5808void wxGrid::EnableCellEditControl( bool enable )
5809{
5810 if (! m_editable)
5811 return;
5812
5813 if ( enable != m_cellEditCtrlEnabled )
5814 {
5815 if ( enable )
5816 {
5817 if ( SendEvent(wxEVT_GRID_EDITOR_SHOWN) == -1 )
5818 return;
5819
5820 // this should be checked by the caller!
5821 wxASSERT_MSG( CanEnableCellControl(), wxT("can't enable editing for this cell!") );
5822
5823 // do it before ShowCellEditControl()
5824 m_cellEditCtrlEnabled = enable;
5825
5826 ShowCellEditControl();
5827 }
5828 else
5829 {
5830 SendEvent(wxEVT_GRID_EDITOR_HIDDEN);
5831
5832 HideCellEditControl();
5833 SaveEditControlValue();
5834
5835 // do it after HideCellEditControl()
5836 m_cellEditCtrlEnabled = enable;
5837 }
5838 }
5839}
5840
5841bool wxGrid::IsCurrentCellReadOnly() const
5842{
5843 wxGridCellAttr*
5844 attr = const_cast<wxGrid *>(this)->GetCellAttr(m_currentCellCoords);
5845 bool readonly = attr->IsReadOnly();
5846 attr->DecRef();
5847
5848 return readonly;
5849}
5850
5851bool wxGrid::CanEnableCellControl() const
5852{
5853 return m_editable && (m_currentCellCoords != wxGridNoCellCoords) &&
5854 !IsCurrentCellReadOnly();
5855}
5856
5857bool wxGrid::IsCellEditControlEnabled() const
5858{
5859 // the cell edit control might be disable for all cells or just for the
5860 // current one if it's read only
5861 return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : false;
5862}
5863
5864bool wxGrid::IsCellEditControlShown() const
5865{
5866 bool isShown = false;
5867
5868 if ( m_cellEditCtrlEnabled )
5869 {
5870 int row = m_currentCellCoords.GetRow();
5871 int col = m_currentCellCoords.GetCol();
5872 wxGridCellAttr* attr = GetCellAttr(row, col);
5873 wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
5874 attr->DecRef();
5875
5876 if ( editor )
5877 {
5878 if ( editor->IsCreated() )
5879 {
5880 isShown = editor->GetControl()->IsShown();
5881 }
5882
5883 editor->DecRef();
5884 }
5885 }
5886
5887 return isShown;
5888}
5889
5890void wxGrid::ShowCellEditControl()
5891{
5892 if ( IsCellEditControlEnabled() )
5893 {
5894 if ( !IsVisible( m_currentCellCoords, false ) )
5895 {
5896 m_cellEditCtrlEnabled = false;
5897 return;
5898 }
5899 else
5900 {
5901 wxRect rect = CellToRect( m_currentCellCoords );
5902 int row = m_currentCellCoords.GetRow();
5903 int col = m_currentCellCoords.GetCol();
5904
5905 // if this is part of a multicell, find owner (topleft)
5906 int cell_rows, cell_cols;
5907 GetCellSize( row, col, &cell_rows, &cell_cols );
5908 if ( cell_rows <= 0 || cell_cols <= 0 )
5909 {
5910 row += cell_rows;
5911 col += cell_cols;
5912 m_currentCellCoords.SetRow( row );
5913 m_currentCellCoords.SetCol( col );
5914 }
5915
5916 // erase the highlight and the cell contents because the editor
5917 // might not cover the entire cell
5918 wxClientDC dc( m_gridWin );
5919 PrepareDC( dc );
5920 wxGridCellAttr* attr = GetCellAttr(row, col);
5921 dc.SetBrush(wxBrush(attr->GetBackgroundColour()));
5922 dc.SetPen(*wxTRANSPARENT_PEN);
5923 dc.DrawRectangle(rect);
5924
5925 // convert to scrolled coords
5926 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5927
5928 int nXMove = 0;
5929 if (rect.x < 0)
5930 nXMove = rect.x;
5931
5932 // cell is shifted by one pixel
5933 // However, don't allow x or y to become negative
5934 // since the SetSize() method interprets that as
5935 // "don't change."
5936 if (rect.x > 0)
5937 rect.x--;
5938 if (rect.y > 0)
5939 rect.y--;
5940
5941 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
5942 if ( !editor->IsCreated() )
5943 {
5944 editor->Create(m_gridWin, wxID_ANY,
5945 new wxGridCellEditorEvtHandler(this, editor));
5946
5947 wxGridEditorCreatedEvent evt(GetId(),
5948 wxEVT_GRID_EDITOR_CREATED,
5949 this,
5950 row,
5951 col,
5952 editor->GetControl());
5953 GetEventHandler()->ProcessEvent(evt);
5954 }
5955
5956 // resize editor to overflow into righthand cells if allowed
5957 int maxWidth = rect.width;
5958 wxString value = GetCellValue(row, col);
5959 if ( (value != wxEmptyString) && (attr->GetOverflow()) )
5960 {
5961 int y;
5962 GetTextExtent(value, &maxWidth, &y, NULL, NULL, &attr->GetFont());
5963 if (maxWidth < rect.width)
5964 maxWidth = rect.width;
5965 }
5966
5967 int client_right = m_gridWin->GetClientSize().GetWidth();
5968 if (rect.x + maxWidth > client_right)
5969 maxWidth = client_right - rect.x;
5970
5971 if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
5972 {
5973 GetCellSize( row, col, &cell_rows, &cell_cols );
5974 // may have changed earlier
5975 for (int i = col + cell_cols; i < m_numCols; i++)
5976 {
5977 int c_rows, c_cols;
5978 GetCellSize( row, i, &c_rows, &c_cols );
5979
5980 // looks weird going over a multicell
5981 if (m_table->IsEmptyCell( row, i ) &&
5982 (rect.width < maxWidth) && (c_rows == 1))
5983 {
5984 rect.width += GetColWidth( i );
5985 }
5986 else
5987 break;
5988 }
5989
5990 if (rect.GetRight() > client_right)
5991 rect.SetRight( client_right - 1 );
5992 }
5993
5994 editor->SetCellAttr( attr );
5995 editor->SetSize( rect );
5996 if (nXMove != 0)
5997 editor->GetControl()->Move(
5998 editor->GetControl()->GetPosition().x + nXMove,
5999 editor->GetControl()->GetPosition().y );
6000 editor->Show( true, attr );
6001
6002 // recalc dimensions in case we need to
6003 // expand the scrolled window to account for editor
6004 CalcDimensions();
6005
6006 editor->BeginEdit(row, col, this);
6007 editor->SetCellAttr(NULL);
6008
6009 editor->DecRef();
6010 attr->DecRef();
6011 }
6012 }
6013}
6014
6015void wxGrid::HideCellEditControl()
6016{
6017 if ( IsCellEditControlEnabled() )
6018 {
6019 int row = m_currentCellCoords.GetRow();
6020 int col = m_currentCellCoords.GetCol();
6021
6022 wxGridCellAttr *attr = GetCellAttr(row, col);
6023 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6024 const bool editorHadFocus = editor->GetControl()->HasFocus();
6025 editor->Show( false );
6026 editor->DecRef();
6027 attr->DecRef();
6028
6029 // return the focus to the grid itself if the editor had it
6030 //
6031 // note that we must not do this unconditionally to avoid stealing
6032 // focus from the window which just received it if we are hiding the
6033 // editor precisely because we lost focus
6034 if ( editorHadFocus )
6035 m_gridWin->SetFocus();
6036
6037 // refresh whole row to the right
6038 wxRect rect( CellToRect(row, col) );
6039 CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
6040 rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
6041
6042#ifdef __WXMAC__
6043 // ensure that the pixels under the focus ring get refreshed as well
6044 rect.Inflate(10, 10);
6045#endif
6046
6047 m_gridWin->Refresh( false, &rect );
6048 }
6049}
6050
6051void wxGrid::SaveEditControlValue()
6052{
6053 if ( IsCellEditControlEnabled() )
6054 {
6055 int row = m_currentCellCoords.GetRow();
6056 int col = m_currentCellCoords.GetCol();
6057
6058 wxString oldval = GetCellValue(row, col);
6059
6060 wxGridCellAttr* attr = GetCellAttr(row, col);
6061 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6062
6063 wxString newval;
6064 bool changed = editor->EndEdit(row, col, this, oldval, &newval);
6065
6066 if ( changed && SendEvent(wxEVT_GRID_CELL_CHANGING, newval) != -1 )
6067 {
6068 editor->ApplyEdit(row, col, this);
6069
6070 // for compatibility reasons dating back to wx 2.8 when this event
6071 // was called wxEVT_GRID_CELL_CHANGE and wxEVT_GRID_CELL_CHANGING
6072 // didn't exist we allow vetoing this one too
6073 if ( SendEvent(wxEVT_GRID_CELL_CHANGED, oldval) == -1 )
6074 {
6075 // Event has been vetoed, set the data back.
6076 SetCellValue(row, col, oldval);
6077 }
6078 }
6079
6080 editor->DecRef();
6081 attr->DecRef();
6082 }
6083}
6084
6085//
6086// ------ Grid location functions
6087// Note that all of these functions work with the logical coordinates of
6088// grid cells and labels so you will need to convert from device
6089// coordinates for mouse events etc.
6090//
6091
6092wxGridCellCoords wxGrid::XYToCell(int x, int y) const
6093{
6094 int row = YToRow(y);
6095 int col = XToCol(x);
6096
6097 return row == -1 || col == -1 ? wxGridNoCellCoords
6098 : wxGridCellCoords(row, col);
6099}
6100
6101// compute row or column from some (unscrolled) coordinate value, using either
6102// m_defaultRowHeight/m_defaultColWidth or binary search on array of
6103// m_rowBottoms/m_colRights to do it quickly (linear search shouldn't be used
6104// for large grids)
6105int wxGrid::PosToLinePos(int coord,
6106 bool clipToMinMax,
6107 const wxGridOperations& oper) const
6108{
6109 const int numLines = oper.GetNumberOfLines(this);
6110
6111 if ( coord < 0 )
6112 return clipToMinMax && numLines > 0 ? 0 : wxNOT_FOUND;
6113
6114 const int defaultLineSize = oper.GetDefaultLineSize(this);
6115 wxCHECK_MSG( defaultLineSize, -1, "can't have 0 default line size" );
6116
6117 int maxPos = coord / defaultLineSize,
6118 minPos = 0;
6119
6120 // check for the simplest case: if we have no explicit line sizes
6121 // configured, then we already know the line this position falls in
6122 const wxArrayInt& lineEnds = oper.GetLineEnds(this);
6123 if ( lineEnds.empty() )
6124 {
6125 if ( maxPos < numLines )
6126 return maxPos;
6127
6128 return clipToMinMax ? numLines - 1 : -1;
6129 }
6130
6131
6132 // adjust maxPos before starting the binary search
6133 if ( maxPos >= numLines )
6134 {
6135 maxPos = numLines - 1;
6136 }
6137 else
6138 {
6139 if ( coord >= lineEnds[oper.GetLineAt(this, maxPos)])
6140 {
6141 minPos = maxPos;
6142 const int minDist = oper.GetMinimalAcceptableLineSize(this);
6143 if ( minDist )
6144 maxPos = coord / minDist;
6145 else
6146 maxPos = numLines - 1;
6147 }
6148
6149 if ( maxPos >= numLines )
6150 maxPos = numLines - 1;
6151 }
6152
6153 // check if the position is beyond the last column
6154 const int lineAtMaxPos = oper.GetLineAt(this, maxPos);
6155 if ( coord >= lineEnds[lineAtMaxPos] )
6156 return clipToMinMax ? maxPos : -1;
6157
6158 // or before the first one
6159 const int lineAt0 = oper.GetLineAt(this, 0);
6160 if ( coord < lineEnds[lineAt0] )
6161 return 0;
6162
6163
6164 // finally do perform the binary search
6165 while ( minPos < maxPos )
6166 {
6167 wxCHECK_MSG( lineEnds[oper.GetLineAt(this, minPos)] <= coord &&
6168 coord < lineEnds[oper.GetLineAt(this, maxPos)],
6169 -1,
6170 "wxGrid: internal error in PosToLinePos()" );
6171
6172 if ( coord >= lineEnds[oper.GetLineAt(this, maxPos - 1)] )
6173 return maxPos;
6174 else
6175 maxPos--;
6176
6177 const int median = minPos + (maxPos - minPos + 1) / 2;
6178 if ( coord < lineEnds[oper.GetLineAt(this, median)] )
6179 maxPos = median;
6180 else
6181 minPos = median;
6182 }
6183
6184 return maxPos;
6185}
6186
6187int
6188wxGrid::PosToLine(int coord,
6189 bool clipToMinMax,
6190 const wxGridOperations& oper) const
6191{
6192 int pos = PosToLinePos(coord, clipToMinMax, oper);
6193
6194 return pos == wxNOT_FOUND ? wxNOT_FOUND : oper.GetLineAt(this, pos);
6195}
6196
6197int wxGrid::YToRow(int y, bool clipToMinMax) const
6198{
6199 return PosToLine(y, clipToMinMax, wxGridRowOperations());
6200}
6201
6202int wxGrid::XToCol(int x, bool clipToMinMax) const
6203{
6204 return PosToLine(x, clipToMinMax, wxGridColumnOperations());
6205}
6206
6207int wxGrid::XToPos(int x) const
6208{
6209 return PosToLinePos(x, true /* clip */, wxGridColumnOperations());
6210}
6211
6212// return the row number such that the y coord is near the edge of, or -1 if
6213// not near an edge.
6214//
6215// notice that position can only possibly be near an edge if the row/column is
6216// large enough to still allow for an "inner" area that is _not_ near the edge
6217// (i.e., if the height/width is smaller than WXGRID_LABEL_EDGE_ZONE, pos will
6218// _never_ be considered to be near the edge).
6219int wxGrid::PosToEdgeOfLine(int pos, const wxGridOperations& oper) const
6220{
6221 const int line = oper.PosToLine(this, pos, true);
6222
6223 if ( oper.GetLineSize(this, line) > WXGRID_LABEL_EDGE_ZONE )
6224 {
6225 // We know that we are in this line, test whether we are close enough
6226 // to start or end border, respectively.
6227 if ( abs(oper.GetLineEndPos(this, line) - pos) < WXGRID_LABEL_EDGE_ZONE )
6228 return line;
6229 else if ( line > 0 &&
6230 pos - oper.GetLineStartPos(this,
6231 line) < WXGRID_LABEL_EDGE_ZONE )
6232 {
6233 return oper.GetLineBefore(this, line);
6234 }
6235 }
6236
6237 return -1;
6238}
6239
6240int wxGrid::YToEdgeOfRow(int y) const
6241{
6242 return PosToEdgeOfLine(y, wxGridRowOperations());
6243}
6244
6245int wxGrid::XToEdgeOfCol(int x) const
6246{
6247 return PosToEdgeOfLine(x, wxGridColumnOperations());
6248}
6249
6250wxRect wxGrid::CellToRect( int row, int col ) const
6251{
6252 wxRect rect( -1, -1, -1, -1 );
6253
6254 if ( row >= 0 && row < m_numRows &&
6255 col >= 0 && col < m_numCols )
6256 {
6257 int i, cell_rows, cell_cols;
6258 rect.width = rect.height = 0;
6259 GetCellSize( row, col, &cell_rows, &cell_cols );
6260 // if negative then find multicell owner
6261 if (cell_rows < 0)
6262 row += cell_rows;
6263 if (cell_cols < 0)
6264 col += cell_cols;
6265 GetCellSize( row, col, &cell_rows, &cell_cols );
6266
6267 rect.x = GetColLeft(col);
6268 rect.y = GetRowTop(row);
6269 for (i=col; i < col + cell_cols; i++)
6270 rect.width += GetColWidth(i);
6271 for (i=row; i < row + cell_rows; i++)
6272 rect.height += GetRowHeight(i);
6273
6274 // if grid lines are enabled, then the area of the cell is a bit smaller
6275 if (m_gridLinesEnabled)
6276 {
6277 rect.width -= 1;
6278 rect.height -= 1;
6279 }
6280 }
6281
6282 return rect;
6283}
6284
6285bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible ) const
6286{
6287 // get the cell rectangle in logical coords
6288 //
6289 wxRect r( CellToRect( row, col ) );
6290
6291 // convert to device coords
6292 //
6293 int left, top, right, bottom;
6294 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6295 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6296
6297 // check against the client area of the grid window
6298 int cw, ch;
6299 m_gridWin->GetClientSize( &cw, &ch );
6300
6301 if ( wholeCellVisible )
6302 {
6303 // is the cell wholly visible ?
6304 return ( left >= 0 && right <= cw &&
6305 top >= 0 && bottom <= ch );
6306 }
6307 else
6308 {
6309 // is the cell partly visible ?
6310 //
6311 return ( ((left >= 0 && left < cw) || (right > 0 && right <= cw)) &&
6312 ((top >= 0 && top < ch) || (bottom > 0 && bottom <= ch)) );
6313 }
6314}
6315
6316// make the specified cell location visible by doing a minimal amount
6317// of scrolling
6318//
6319void wxGrid::MakeCellVisible( int row, int col )
6320{
6321 int i;
6322 int xpos = -1, ypos = -1;
6323
6324 if ( row >= 0 && row < m_numRows &&
6325 col >= 0 && col < m_numCols )
6326 {
6327 // get the cell rectangle in logical coords
6328 wxRect r( CellToRect( row, col ) );
6329
6330 // convert to device coords
6331 int left, top, right, bottom;
6332 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6333 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6334
6335 int cw, ch;
6336 m_gridWin->GetClientSize( &cw, &ch );
6337
6338 if ( top < 0 )
6339 {
6340 ypos = r.GetTop();
6341 }
6342 else if ( bottom > ch )
6343 {
6344 int h = r.GetHeight();
6345 ypos = r.GetTop();
6346 for ( i = row - 1; i >= 0; i-- )
6347 {
6348 int rowHeight = GetRowHeight(i);
6349 if ( h + rowHeight > ch )
6350 break;
6351
6352 h += rowHeight;
6353 ypos -= rowHeight;
6354 }
6355
6356 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
6357 // have rounding errors (this is important, because if we do,
6358 // we might not scroll at all and some cells won't be redrawn)
6359 //
6360 // Sometimes GRID_SCROLL_LINE / 2 is not enough,
6361 // so just add a full scroll unit...
6362 ypos += m_yScrollPixelsPerLine;
6363 }
6364
6365 // special handling for wide cells - show always left part of the cell!
6366 // Otherwise, e.g. when stepping from row to row, it would jump between
6367 // left and right part of the cell on every step!
6368// if ( left < 0 )
6369 if ( left < 0 || (right - left) >= cw )
6370 {
6371 xpos = r.GetLeft();
6372 }
6373 else if ( right > cw )
6374 {
6375 // position the view so that the cell is on the right
6376 int x0, y0;
6377 CalcUnscrolledPosition(0, 0, &x0, &y0);
6378 xpos = x0 + (right - cw);
6379
6380 // see comment for ypos above
6381 xpos += m_xScrollPixelsPerLine;
6382 }
6383
6384 if ( xpos != -1 || ypos != -1 )
6385 {
6386 if ( xpos != -1 )
6387 xpos /= m_xScrollPixelsPerLine;
6388 if ( ypos != -1 )
6389 ypos /= m_yScrollPixelsPerLine;
6390 Scroll( xpos, ypos );
6391 AdjustScrollbars();
6392 }
6393 }
6394}
6395
6396//
6397// ------ Grid cursor movement functions
6398//
6399
6400bool
6401wxGrid::DoMoveCursor(bool expandSelection,
6402 const wxGridDirectionOperations& diroper)
6403{
6404 if ( m_currentCellCoords == wxGridNoCellCoords )
6405 return false;
6406
6407 if ( expandSelection )
6408 {
6409 wxGridCellCoords coords = m_selectedBlockCorner;
6410 if ( coords == wxGridNoCellCoords )
6411 coords = m_currentCellCoords;
6412
6413 if ( diroper.IsAtBoundary(coords) )
6414 return false;
6415
6416 diroper.Advance(coords);
6417
6418 UpdateBlockBeingSelected(m_currentCellCoords, coords);
6419 }
6420 else // don't expand selection
6421 {
6422 ClearSelection();
6423
6424 if ( diroper.IsAtBoundary(m_currentCellCoords) )
6425 return false;
6426
6427 wxGridCellCoords coords = m_currentCellCoords;
6428 diroper.Advance(coords);
6429
6430 GoToCell(coords);
6431 }
6432
6433 return true;
6434}
6435
6436bool wxGrid::MoveCursorUp(bool expandSelection)
6437{
6438 return DoMoveCursor(expandSelection,
6439 wxGridBackwardOperations(this, wxGridRowOperations()));
6440}
6441
6442bool wxGrid::MoveCursorDown(bool expandSelection)
6443{
6444 return DoMoveCursor(expandSelection,
6445 wxGridForwardOperations(this, wxGridRowOperations()));
6446}
6447
6448bool wxGrid::MoveCursorLeft(bool expandSelection)
6449{
6450 return DoMoveCursor(expandSelection,
6451 wxGridBackwardOperations(this, wxGridColumnOperations()));
6452}
6453
6454bool wxGrid::MoveCursorRight(bool expandSelection)
6455{
6456 return DoMoveCursor(expandSelection,
6457 wxGridForwardOperations(this, wxGridColumnOperations()));
6458}
6459
6460bool wxGrid::DoMoveCursorByPage(const wxGridDirectionOperations& diroper)
6461{
6462 if ( m_currentCellCoords == wxGridNoCellCoords )
6463 return false;
6464
6465 if ( diroper.IsAtBoundary(m_currentCellCoords) )
6466 return false;
6467
6468 const int oldRow = m_currentCellCoords.GetRow();
6469 int newRow = diroper.MoveByPixelDistance(oldRow, m_gridWin->GetClientSize().y);
6470 if ( newRow == oldRow )
6471 {
6472 wxGridCellCoords coords(m_currentCellCoords);
6473 diroper.Advance(coords);
6474 newRow = coords.GetRow();
6475 }
6476
6477 GoToCell(newRow, m_currentCellCoords.GetCol());
6478
6479 return true;
6480}
6481
6482bool wxGrid::MovePageUp()
6483{
6484 return DoMoveCursorByPage(
6485 wxGridBackwardOperations(this, wxGridRowOperations()));
6486}
6487
6488bool wxGrid::MovePageDown()
6489{
6490 return DoMoveCursorByPage(
6491 wxGridForwardOperations(this, wxGridRowOperations()));
6492}
6493
6494// helper of DoMoveCursorByBlock(): advance the cell coordinates using diroper
6495// until we find a non-empty cell or reach the grid end
6496void
6497wxGrid::AdvanceToNextNonEmpty(wxGridCellCoords& coords,
6498 const wxGridDirectionOperations& diroper)
6499{
6500 while ( !diroper.IsAtBoundary(coords) )
6501 {
6502 diroper.Advance(coords);
6503 if ( !m_table->IsEmpty(coords) )
6504 break;
6505 }
6506}
6507
6508bool
6509wxGrid::DoMoveCursorByBlock(bool expandSelection,
6510 const wxGridDirectionOperations& diroper)
6511{
6512 if ( !m_table || m_currentCellCoords == wxGridNoCellCoords )
6513 return false;
6514
6515 if ( diroper.IsAtBoundary(m_currentCellCoords) )
6516 return false;
6517
6518 wxGridCellCoords coords(m_currentCellCoords);
6519 if ( m_table->IsEmpty(coords) )
6520 {
6521 // we are in an empty cell: find the next block of non-empty cells
6522 AdvanceToNextNonEmpty(coords, diroper);
6523 }
6524 else // current cell is not empty
6525 {
6526 diroper.Advance(coords);
6527 if ( m_table->IsEmpty(coords) )
6528 {
6529 // we started at the end of a block, find the next one
6530 AdvanceToNextNonEmpty(coords, diroper);
6531 }
6532 else // we're in a middle of a block
6533 {
6534 // go to the end of it, i.e. find the last cell before the next
6535 // empty one
6536 while ( !diroper.IsAtBoundary(coords) )
6537 {
6538 wxGridCellCoords coordsNext(coords);
6539 diroper.Advance(coordsNext);
6540 if ( m_table->IsEmpty(coordsNext) )
6541 break;
6542
6543 coords = coordsNext;
6544 }
6545 }
6546 }
6547
6548 if ( expandSelection )
6549 {
6550 UpdateBlockBeingSelected(m_currentCellCoords, coords);
6551 }
6552 else
6553 {
6554 ClearSelection();
6555 GoToCell(coords);
6556 }
6557
6558 return true;
6559}
6560
6561bool wxGrid::MoveCursorUpBlock(bool expandSelection)
6562{
6563 return DoMoveCursorByBlock(
6564 expandSelection,
6565 wxGridBackwardOperations(this, wxGridRowOperations())
6566 );
6567}
6568
6569bool wxGrid::MoveCursorDownBlock( bool expandSelection )
6570{
6571 return DoMoveCursorByBlock(
6572 expandSelection,
6573 wxGridForwardOperations(this, wxGridRowOperations())
6574 );
6575}
6576
6577bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
6578{
6579 return DoMoveCursorByBlock(
6580 expandSelection,
6581 wxGridBackwardOperations(this, wxGridColumnOperations())
6582 );
6583}
6584
6585bool wxGrid::MoveCursorRightBlock( bool expandSelection )
6586{
6587 return DoMoveCursorByBlock(
6588 expandSelection,
6589 wxGridForwardOperations(this, wxGridColumnOperations())
6590 );
6591}
6592
6593//
6594// ------ Label values and formatting
6595//
6596
6597void wxGrid::GetRowLabelAlignment( int *horiz, int *vert ) const
6598{
6599 if ( horiz )
6600 *horiz = m_rowLabelHorizAlign;
6601 if ( vert )
6602 *vert = m_rowLabelVertAlign;
6603}
6604
6605void wxGrid::GetColLabelAlignment( int *horiz, int *vert ) const
6606{
6607 if ( horiz )
6608 *horiz = m_colLabelHorizAlign;
6609 if ( vert )
6610 *vert = m_colLabelVertAlign;
6611}
6612
6613int wxGrid::GetColLabelTextOrientation() const
6614{
6615 return m_colLabelTextOrientation;
6616}
6617
6618wxString wxGrid::GetRowLabelValue( int row ) const
6619{
6620 if ( m_table )
6621 {
6622 return m_table->GetRowLabelValue( row );
6623 }
6624 else
6625 {
6626 wxString s;
6627 s << row;
6628 return s;
6629 }
6630}
6631
6632wxString wxGrid::GetColLabelValue( int col ) const
6633{
6634 if ( m_table )
6635 {
6636 return m_table->GetColLabelValue( col );
6637 }
6638 else
6639 {
6640 wxString s;
6641 s << col;
6642 return s;
6643 }
6644}
6645
6646void wxGrid::SetRowLabelSize( int width )
6647{
6648 wxASSERT( width >= 0 || width == wxGRID_AUTOSIZE );
6649
6650 if ( width == wxGRID_AUTOSIZE )
6651 {
6652 width = CalcColOrRowLabelAreaMinSize(wxGRID_ROW);
6653 }
6654
6655 if ( width != m_rowLabelWidth )
6656 {
6657 if ( width == 0 )
6658 {
6659 m_rowLabelWin->Show( false );
6660 m_cornerLabelWin->Show( false );
6661 }
6662 else if ( m_rowLabelWidth == 0 )
6663 {
6664 m_rowLabelWin->Show( true );
6665 if ( m_colLabelHeight > 0 )
6666 m_cornerLabelWin->Show( true );
6667 }
6668
6669 m_rowLabelWidth = width;
6670 CalcWindowSizes();
6671 wxScrolledWindow::Refresh( true );
6672 }
6673}
6674
6675void wxGrid::SetColLabelSize( int height )
6676{
6677 wxASSERT( height >=0 || height == wxGRID_AUTOSIZE );
6678
6679 if ( height == wxGRID_AUTOSIZE )
6680 {
6681 height = CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN);
6682 }
6683
6684 if ( height != m_colLabelHeight )
6685 {
6686 if ( height == 0 )
6687 {
6688 m_colWindow->Show( false );
6689 m_cornerLabelWin->Show( false );
6690 }
6691 else if ( m_colLabelHeight == 0 )
6692 {
6693 m_colWindow->Show( true );
6694 if ( m_rowLabelWidth > 0 )
6695 m_cornerLabelWin->Show( true );
6696 }
6697
6698 m_colLabelHeight = height;
6699 CalcWindowSizes();
6700 wxScrolledWindow::Refresh( true );
6701 }
6702}
6703
6704void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
6705{
6706 if ( m_labelBackgroundColour != colour )
6707 {
6708 m_labelBackgroundColour = colour;
6709 m_rowLabelWin->SetBackgroundColour( colour );
6710 m_colWindow->SetBackgroundColour( colour );
6711 m_cornerLabelWin->SetBackgroundColour( colour );
6712
6713 if ( !GetBatchCount() )
6714 {
6715 m_rowLabelWin->Refresh();
6716 m_colWindow->Refresh();
6717 m_cornerLabelWin->Refresh();
6718 }
6719 }
6720}
6721
6722void wxGrid::SetLabelTextColour( const wxColour& colour )
6723{
6724 if ( m_labelTextColour != colour )
6725 {
6726 m_labelTextColour = colour;
6727 if ( !GetBatchCount() )
6728 {
6729 m_rowLabelWin->Refresh();
6730 m_colWindow->Refresh();
6731 }
6732 }
6733}
6734
6735void wxGrid::SetLabelFont( const wxFont& font )
6736{
6737 m_labelFont = font;
6738 if ( !GetBatchCount() )
6739 {
6740 m_rowLabelWin->Refresh();
6741 m_colWindow->Refresh();
6742 }
6743}
6744
6745void wxGrid::SetRowLabelAlignment( int horiz, int vert )
6746{
6747 // allow old (incorrect) defs to be used
6748 switch ( horiz )
6749 {
6750 case wxLEFT: horiz = wxALIGN_LEFT; break;
6751 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
6752 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
6753 }
6754
6755 switch ( vert )
6756 {
6757 case wxTOP: vert = wxALIGN_TOP; break;
6758 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
6759 case wxCENTRE: vert = wxALIGN_CENTRE; break;
6760 }
6761
6762 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
6763 {
6764 m_rowLabelHorizAlign = horiz;
6765 }
6766
6767 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
6768 {
6769 m_rowLabelVertAlign = vert;
6770 }
6771
6772 if ( !GetBatchCount() )
6773 {
6774 m_rowLabelWin->Refresh();
6775 }
6776}
6777
6778void wxGrid::SetColLabelAlignment( int horiz, int vert )
6779{
6780 // allow old (incorrect) defs to be used
6781 switch ( horiz )
6782 {
6783 case wxLEFT: horiz = wxALIGN_LEFT; break;
6784 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
6785 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
6786 }
6787
6788 switch ( vert )
6789 {
6790 case wxTOP: vert = wxALIGN_TOP; break;
6791 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
6792 case wxCENTRE: vert = wxALIGN_CENTRE; break;
6793 }
6794
6795 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
6796 {
6797 m_colLabelHorizAlign = horiz;
6798 }
6799
6800 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
6801 {
6802 m_colLabelVertAlign = vert;
6803 }
6804
6805 if ( !GetBatchCount() )
6806 {
6807 m_colWindow->Refresh();
6808 }
6809}
6810
6811// Note: under MSW, the default column label font must be changed because it
6812// does not support vertical printing
6813//
6814// Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
6815// pGrid->SetLabelFont(font);
6816// pGrid->SetColLabelTextOrientation(wxVERTICAL);
6817//
6818void wxGrid::SetColLabelTextOrientation( int textOrientation )
6819{
6820 if ( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
6821 m_colLabelTextOrientation = textOrientation;
6822
6823 if ( !GetBatchCount() )
6824 m_colWindow->Refresh();
6825}
6826
6827void wxGrid::SetRowLabelValue( int row, const wxString& s )
6828{
6829 if ( m_table )
6830 {
6831 m_table->SetRowLabelValue( row, s );
6832 if ( !GetBatchCount() )
6833 {
6834 wxRect rect = CellToRect( row, 0 );
6835 if ( rect.height > 0 )
6836 {
6837 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
6838 rect.x = 0;
6839 rect.width = m_rowLabelWidth;
6840 m_rowLabelWin->Refresh( true, &rect );
6841 }
6842 }
6843 }
6844}
6845
6846void wxGrid::SetColLabelValue( int col, const wxString& s )
6847{
6848 if ( m_table )
6849 {
6850 m_table->SetColLabelValue( col, s );
6851 if ( !GetBatchCount() )
6852 {
6853 if ( m_useNativeHeader )
6854 {
6855 GetGridColHeader()->UpdateColumn(col);
6856 }
6857 else
6858 {
6859 wxRect rect = CellToRect( 0, col );
6860 if ( rect.width > 0 )
6861 {
6862 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
6863 rect.y = 0;
6864 rect.height = m_colLabelHeight;
6865 GetColLabelWindow()->Refresh( true, &rect );
6866 }
6867 }
6868 }
6869 }
6870}
6871
6872void wxGrid::SetGridLineColour( const wxColour& colour )
6873{
6874 if ( m_gridLineColour != colour )
6875 {
6876 m_gridLineColour = colour;
6877
6878 if ( GridLinesEnabled() )
6879 RedrawGridLines();
6880 }
6881}
6882
6883void wxGrid::SetCellHighlightColour( const wxColour& colour )
6884{
6885 if ( m_cellHighlightColour != colour )
6886 {
6887 m_cellHighlightColour = colour;
6888
6889 wxClientDC dc( m_gridWin );
6890 PrepareDC( dc );
6891 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6892 DrawCellHighlight(dc, attr);
6893 attr->DecRef();
6894 }
6895}
6896
6897void wxGrid::SetCellHighlightPenWidth(int width)
6898{
6899 if (m_cellHighlightPenWidth != width)
6900 {
6901 m_cellHighlightPenWidth = width;
6902
6903 // Just redrawing the cell highlight is not enough since that won't
6904 // make any visible change if the the thickness is getting smaller.
6905 int row = m_currentCellCoords.GetRow();
6906 int col = m_currentCellCoords.GetCol();
6907 if ( row == -1 || col == -1 || GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6908 return;
6909
6910 wxRect rect = CellToRect(row, col);
6911 m_gridWin->Refresh(true, &rect);
6912 }
6913}
6914
6915void wxGrid::SetCellHighlightROPenWidth(int width)
6916{
6917 if (m_cellHighlightROPenWidth != width)
6918 {
6919 m_cellHighlightROPenWidth = width;
6920
6921 // Just redrawing the cell highlight is not enough since that won't
6922 // make any visible change if the the thickness is getting smaller.
6923 int row = m_currentCellCoords.GetRow();
6924 int col = m_currentCellCoords.GetCol();
6925 if ( row == -1 || col == -1 ||
6926 GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6927 return;
6928
6929 wxRect rect = CellToRect(row, col);
6930 m_gridWin->Refresh(true, &rect);
6931 }
6932}
6933
6934void wxGrid::RedrawGridLines()
6935{
6936 // the lines will be redrawn when the window is thawn
6937 if ( GetBatchCount() )
6938 return;
6939
6940 if ( GridLinesEnabled() )
6941 {
6942 wxClientDC dc( m_gridWin );
6943 PrepareDC( dc );
6944 DrawAllGridLines( dc, wxRegion() );
6945 }
6946 else // remove the grid lines
6947 {
6948 m_gridWin->Refresh();
6949 }
6950}
6951
6952void wxGrid::EnableGridLines( bool enable )
6953{
6954 if ( enable != m_gridLinesEnabled )
6955 {
6956 m_gridLinesEnabled = enable;
6957
6958 RedrawGridLines();
6959 }
6960}
6961
6962void wxGrid::DoClipGridLines(bool& var, bool clip)
6963{
6964 if ( clip != var )
6965 {
6966 var = clip;
6967
6968 if ( GridLinesEnabled() )
6969 RedrawGridLines();
6970 }
6971}
6972
6973int wxGrid::GetDefaultRowSize() const
6974{
6975 return m_defaultRowHeight;
6976}
6977
6978int wxGrid::GetRowSize( int row ) const
6979{
6980 wxCHECK_MSG( row >= 0 && row < m_numRows, 0, wxT("invalid row index") );
6981
6982 return GetRowHeight(row);
6983}
6984
6985int wxGrid::GetDefaultColSize() const
6986{
6987 return m_defaultColWidth;
6988}
6989
6990int wxGrid::GetColSize( int col ) const
6991{
6992 wxCHECK_MSG( col >= 0 && col < m_numCols, 0, wxT("invalid column index") );
6993
6994 return GetColWidth(col);
6995}
6996
6997// ============================================================================
6998// access to the grid attributes: each of them has a default value in the grid
6999// itself and may be overidden on a per-cell basis
7000// ============================================================================
7001
7002// ----------------------------------------------------------------------------
7003// setting default attributes
7004// ----------------------------------------------------------------------------
7005
7006void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
7007{
7008 m_defaultCellAttr->SetBackgroundColour(col);
7009#ifdef __WXGTK__
7010 m_gridWin->SetBackgroundColour(col);
7011#endif
7012}
7013
7014void wxGrid::SetDefaultCellTextColour( const wxColour& col )
7015{
7016 m_defaultCellAttr->SetTextColour(col);
7017}
7018
7019void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
7020{
7021 m_defaultCellAttr->SetAlignment(horiz, vert);
7022}
7023
7024void wxGrid::SetDefaultCellOverflow( bool allow )
7025{
7026 m_defaultCellAttr->SetOverflow(allow);
7027}
7028
7029void wxGrid::SetDefaultCellFont( const wxFont& font )
7030{
7031 m_defaultCellAttr->SetFont(font);
7032}
7033
7034// For editors and renderers the type registry takes precedence over the
7035// default attr, so we need to register the new editor/renderer for the string
7036// data type in order to make setting a default editor/renderer appear to
7037// work correctly.
7038
7039void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
7040{
7041 RegisterDataType(wxGRID_VALUE_STRING,
7042 renderer,
7043 GetDefaultEditorForType(wxGRID_VALUE_STRING));
7044}
7045
7046void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
7047{
7048 RegisterDataType(wxGRID_VALUE_STRING,
7049 GetDefaultRendererForType(wxGRID_VALUE_STRING),
7050 editor);
7051}
7052
7053// ----------------------------------------------------------------------------
7054// access to the default attributes
7055// ----------------------------------------------------------------------------
7056
7057wxColour wxGrid::GetDefaultCellBackgroundColour() const
7058{
7059 return m_defaultCellAttr->GetBackgroundColour();
7060}
7061
7062wxColour wxGrid::GetDefaultCellTextColour() const
7063{
7064 return m_defaultCellAttr->GetTextColour();
7065}
7066
7067wxFont wxGrid::GetDefaultCellFont() const
7068{
7069 return m_defaultCellAttr->GetFont();
7070}
7071
7072void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert ) const
7073{
7074 m_defaultCellAttr->GetAlignment(horiz, vert);
7075}
7076
7077bool wxGrid::GetDefaultCellOverflow() const
7078{
7079 return m_defaultCellAttr->GetOverflow();
7080}
7081
7082wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
7083{
7084 return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
7085}
7086
7087wxGridCellEditor *wxGrid::GetDefaultEditor() const
7088{
7089 return m_defaultCellAttr->GetEditor(NULL, 0, 0);
7090}
7091
7092// ----------------------------------------------------------------------------
7093// access to cell attributes
7094// ----------------------------------------------------------------------------
7095
7096wxColour wxGrid::GetCellBackgroundColour(int row, int col) const
7097{
7098 wxGridCellAttr *attr = GetCellAttr(row, col);
7099 wxColour colour = attr->GetBackgroundColour();
7100 attr->DecRef();
7101
7102 return colour;
7103}
7104
7105wxColour wxGrid::GetCellTextColour( int row, int col ) const
7106{
7107 wxGridCellAttr *attr = GetCellAttr(row, col);
7108 wxColour colour = attr->GetTextColour();
7109 attr->DecRef();
7110
7111 return colour;
7112}
7113
7114wxFont wxGrid::GetCellFont( int row, int col ) const
7115{
7116 wxGridCellAttr *attr = GetCellAttr(row, col);
7117 wxFont font = attr->GetFont();
7118 attr->DecRef();
7119
7120 return font;
7121}
7122
7123void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert ) const
7124{
7125 wxGridCellAttr *attr = GetCellAttr(row, col);
7126 attr->GetAlignment(horiz, vert);
7127 attr->DecRef();
7128}
7129
7130bool wxGrid::GetCellOverflow( int row, int col ) const
7131{
7132 wxGridCellAttr *attr = GetCellAttr(row, col);
7133 bool allow = attr->GetOverflow();
7134 attr->DecRef();
7135
7136 return allow;
7137}
7138
7139wxGrid::CellSpan
7140wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
7141{
7142 wxGridCellAttr *attr = GetCellAttr(row, col);
7143 attr->GetSize( num_rows, num_cols );
7144 attr->DecRef();
7145
7146 if ( *num_rows == 1 && *num_cols == 1 )
7147 return CellSpan_None; // just a normal cell
7148
7149 if ( *num_rows < 0 || *num_cols < 0 )
7150 return CellSpan_Inside; // covered by a multi-span cell
7151
7152 // this cell spans multiple cells to its right/bottom
7153 return CellSpan_Main;
7154}
7155
7156wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const
7157{
7158 wxGridCellAttr* attr = GetCellAttr(row, col);
7159 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
7160 attr->DecRef();
7161
7162 return renderer;
7163}
7164
7165wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const
7166{
7167 wxGridCellAttr* attr = GetCellAttr(row, col);
7168 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7169 attr->DecRef();
7170
7171 return editor;
7172}
7173
7174bool wxGrid::IsReadOnly(int row, int col) const
7175{
7176 wxGridCellAttr* attr = GetCellAttr(row, col);
7177 bool isReadOnly = attr->IsReadOnly();
7178 attr->DecRef();
7179
7180 return isReadOnly;
7181}
7182
7183// ----------------------------------------------------------------------------
7184// attribute support: cache, automatic provider creation, ...
7185// ----------------------------------------------------------------------------
7186
7187bool wxGrid::CanHaveAttributes() const
7188{
7189 if ( !m_table )
7190 {
7191 return false;
7192 }
7193
7194 return m_table->CanHaveAttributes();
7195}
7196
7197void wxGrid::ClearAttrCache()
7198{
7199 if ( m_attrCache.row != -1 )
7200 {
7201 wxGridCellAttr *oldAttr = m_attrCache.attr;
7202 m_attrCache.attr = NULL;
7203 m_attrCache.row = -1;
7204 // wxSafeDecRec(...) might cause event processing that accesses
7205 // the cached attribute, if one exists (e.g. by deleting the
7206 // editor stored within the attribute). Therefore it is important
7207 // to invalidate the cache before calling wxSafeDecRef!
7208 wxSafeDecRef(oldAttr);
7209 }
7210}
7211
7212void wxGrid::RefreshAttr(int row, int col)
7213{
7214 if ( m_attrCache.row == row && m_attrCache.col == col )
7215 ClearAttrCache();
7216}
7217
7218
7219void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
7220{
7221 if ( attr != NULL )
7222 {
7223 wxGrid * const self = const_cast<wxGrid *>(this);
7224
7225 self->ClearAttrCache();
7226 self->m_attrCache.row = row;
7227 self->m_attrCache.col = col;
7228 self->m_attrCache.attr = attr;
7229 wxSafeIncRef(attr);
7230 }
7231}
7232
7233bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
7234{
7235 if ( row == m_attrCache.row && col == m_attrCache.col )
7236 {
7237 *attr = m_attrCache.attr;
7238 wxSafeIncRef(m_attrCache.attr);
7239
7240#ifdef DEBUG_ATTR_CACHE
7241 gs_nAttrCacheHits++;
7242#endif
7243
7244 return true;
7245 }
7246 else
7247 {
7248#ifdef DEBUG_ATTR_CACHE
7249 gs_nAttrCacheMisses++;
7250#endif
7251
7252 return false;
7253 }
7254}
7255
7256wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
7257{
7258 wxGridCellAttr *attr = NULL;
7259 // Additional test to avoid looking at the cache e.g. for
7260 // wxNoCellCoords, as this will confuse memory management.
7261 if ( row >= 0 )
7262 {
7263 if ( !LookupAttr(row, col, &attr) )
7264 {
7265 attr = m_table ? m_table->GetAttr(row, col, wxGridCellAttr::Any)
7266 : NULL;
7267 CacheAttr(row, col, attr);
7268 }
7269 }
7270
7271 if (attr)
7272 {
7273 attr->SetDefAttr(m_defaultCellAttr);
7274 }
7275 else
7276 {
7277 attr = m_defaultCellAttr;
7278 attr->IncRef();
7279 }
7280
7281 return attr;
7282}
7283
7284wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
7285{
7286 wxGridCellAttr *attr = NULL;
7287 bool canHave = ((wxGrid*)this)->CanHaveAttributes();
7288
7289 wxCHECK_MSG( canHave, attr, wxT("Cell attributes not allowed"));
7290 wxCHECK_MSG( m_table, attr, wxT("must have a table") );
7291
7292 attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
7293 if ( !attr )
7294 {
7295 attr = new wxGridCellAttr(m_defaultCellAttr);
7296
7297 // artificially inc the ref count to match DecRef() in caller
7298 attr->IncRef();
7299 m_table->SetAttr(attr, row, col);
7300 }
7301
7302 return attr;
7303}
7304
7305// ----------------------------------------------------------------------------
7306// setting column attributes (wrappers around SetColAttr)
7307// ----------------------------------------------------------------------------
7308
7309void wxGrid::SetColFormatBool(int col)
7310{
7311 SetColFormatCustom(col, wxGRID_VALUE_BOOL);
7312}
7313
7314void wxGrid::SetColFormatNumber(int col)
7315{
7316 SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
7317}
7318
7319void wxGrid::SetColFormatFloat(int col, int width, int precision)
7320{
7321 wxString typeName = wxGRID_VALUE_FLOAT;
7322 if ( (width != -1) || (precision != -1) )
7323 {
7324 typeName << wxT(':') << width << wxT(',') << precision;
7325 }
7326
7327 SetColFormatCustom(col, typeName);
7328}
7329
7330void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
7331{
7332 wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
7333 if (!attr)
7334 attr = new wxGridCellAttr;
7335 wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
7336 attr->SetRenderer(renderer);
7337 wxGridCellEditor *editor = GetDefaultEditorForType(typeName);
7338 attr->SetEditor(editor);
7339
7340 SetColAttr(col, attr);
7341
7342}
7343
7344// ----------------------------------------------------------------------------
7345// setting cell attributes: this is forwarded to the table
7346// ----------------------------------------------------------------------------
7347
7348void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
7349{
7350 if ( CanHaveAttributes() )
7351 {
7352 m_table->SetAttr(attr, row, col);
7353 ClearAttrCache();
7354 }
7355 else
7356 {
7357 wxSafeDecRef(attr);
7358 }
7359}
7360
7361void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
7362{
7363 if ( CanHaveAttributes() )
7364 {
7365 m_table->SetRowAttr(attr, row);
7366 ClearAttrCache();
7367 }
7368 else
7369 {
7370 wxSafeDecRef(attr);
7371 }
7372}
7373
7374void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
7375{
7376 if ( CanHaveAttributes() )
7377 {
7378 m_table->SetColAttr(attr, col);
7379 ClearAttrCache();
7380 }
7381 else
7382 {
7383 wxSafeDecRef(attr);
7384 }
7385}
7386
7387void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
7388{
7389 if ( CanHaveAttributes() )
7390 {
7391 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7392 attr->SetBackgroundColour(colour);
7393 attr->DecRef();
7394 }
7395}
7396
7397void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
7398{
7399 if ( CanHaveAttributes() )
7400 {
7401 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7402 attr->SetTextColour(colour);
7403 attr->DecRef();
7404 }
7405}
7406
7407void wxGrid::SetCellFont( int row, int col, const wxFont& font )
7408{
7409 if ( CanHaveAttributes() )
7410 {
7411 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7412 attr->SetFont(font);
7413 attr->DecRef();
7414 }
7415}
7416
7417void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
7418{
7419 if ( CanHaveAttributes() )
7420 {
7421 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7422 attr->SetAlignment(horiz, vert);
7423 attr->DecRef();
7424 }
7425}
7426
7427void wxGrid::SetCellOverflow( int row, int col, bool allow )
7428{
7429 if ( CanHaveAttributes() )
7430 {
7431 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7432 attr->SetOverflow(allow);
7433 attr->DecRef();
7434 }
7435}
7436
7437void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
7438{
7439 if ( CanHaveAttributes() )
7440 {
7441 int cell_rows, cell_cols;
7442
7443 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7444 attr->GetSize(&cell_rows, &cell_cols);
7445 attr->SetSize(num_rows, num_cols);
7446 attr->DecRef();
7447
7448 // Cannot set the size of a cell to 0 or negative values
7449 // While it is perfectly legal to do that, this function cannot
7450 // handle all the possibilies, do it by hand by getting the CellAttr.
7451 // You can only set the size of a cell to 1,1 or greater with this fn
7452 wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
7453 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
7454 wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
7455 wxT("wxGrid::SetCellSize setting cell size to < 1"));
7456
7457 // if this was already a multicell then "turn off" the other cells first
7458 if ((cell_rows > 1) || (cell_cols > 1))
7459 {
7460 int i, j;
7461 for (j=row; j < row + cell_rows; j++)
7462 {
7463 for (i=col; i < col + cell_cols; i++)
7464 {
7465 if ((i != col) || (j != row))
7466 {
7467 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
7468 attr_stub->SetSize( 1, 1 );
7469 attr_stub->DecRef();
7470 }
7471 }
7472 }
7473 }
7474
7475 // mark the cells that will be covered by this cell to
7476 // negative or zero values to point back at this cell
7477 if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
7478 {
7479 int i, j;
7480 for (j=row; j < row + num_rows; j++)
7481 {
7482 for (i=col; i < col + num_cols; i++)
7483 {
7484 if ((i != col) || (j != row))
7485 {
7486 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
7487 attr_stub->SetSize( row - j, col - i );
7488 attr_stub->DecRef();
7489 }
7490 }
7491 }
7492 }
7493 }
7494}
7495
7496void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
7497{
7498 if ( CanHaveAttributes() )
7499 {
7500 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7501 attr->SetRenderer(renderer);
7502 attr->DecRef();
7503 }
7504}
7505
7506void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
7507{
7508 if ( CanHaveAttributes() )
7509 {
7510 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7511 attr->SetEditor(editor);
7512 attr->DecRef();
7513 }
7514}
7515
7516void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
7517{
7518 if ( CanHaveAttributes() )
7519 {
7520 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7521 attr->SetReadOnly(isReadOnly);
7522 attr->DecRef();
7523 }
7524}
7525
7526// ----------------------------------------------------------------------------
7527// Data type registration
7528// ----------------------------------------------------------------------------
7529
7530void wxGrid::RegisterDataType(const wxString& typeName,
7531 wxGridCellRenderer* renderer,
7532 wxGridCellEditor* editor)
7533{
7534 m_typeRegistry->RegisterDataType(typeName, renderer, editor);
7535}
7536
7537
7538wxGridCellEditor * wxGrid::GetDefaultEditorForCell(int row, int col) const
7539{
7540 wxString typeName = m_table->GetTypeName(row, col);
7541 return GetDefaultEditorForType(typeName);
7542}
7543
7544wxGridCellRenderer * wxGrid::GetDefaultRendererForCell(int row, int col) const
7545{
7546 wxString typeName = m_table->GetTypeName(row, col);
7547 return GetDefaultRendererForType(typeName);
7548}
7549
7550wxGridCellEditor * wxGrid::GetDefaultEditorForType(const wxString& typeName) const
7551{
7552 int index = m_typeRegistry->FindOrCloneDataType(typeName);
7553 if ( index == wxNOT_FOUND )
7554 {
7555 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
7556
7557 return NULL;
7558 }
7559
7560 return m_typeRegistry->GetEditor(index);
7561}
7562
7563wxGridCellRenderer * wxGrid::GetDefaultRendererForType(const wxString& typeName) const
7564{
7565 int index = m_typeRegistry->FindOrCloneDataType(typeName);
7566 if ( index == wxNOT_FOUND )
7567 {
7568 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
7569
7570 return NULL;
7571 }
7572
7573 return m_typeRegistry->GetRenderer(index);
7574}
7575
7576// ----------------------------------------------------------------------------
7577// row/col size
7578// ----------------------------------------------------------------------------
7579
7580void wxGrid::DoDisableLineResize(int line, wxGridFixedIndicesSet *& setFixed)
7581{
7582 if ( !setFixed )
7583 {
7584 setFixed = new wxGridFixedIndicesSet;
7585 }
7586
7587 setFixed->insert(line);
7588}
7589
7590bool
7591wxGrid::DoCanResizeLine(int line, const wxGridFixedIndicesSet *setFixed) const
7592{
7593 return !setFixed || !setFixed->count(line);
7594}
7595
7596void wxGrid::EnableDragRowSize( bool enable )
7597{
7598 m_canDragRowSize = enable;
7599}
7600
7601void wxGrid::EnableDragColSize( bool enable )
7602{
7603 m_canDragColSize = enable;
7604}
7605
7606void wxGrid::EnableDragGridSize( bool enable )
7607{
7608 m_canDragGridSize = enable;
7609}
7610
7611void wxGrid::EnableDragCell( bool enable )
7612{
7613 m_canDragCell = enable;
7614}
7615
7616void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
7617{
7618 m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
7619
7620 if ( resizeExistingRows )
7621 {
7622 // since we are resizing all rows to the default row size,
7623 // we can simply clear the row heights and row bottoms
7624 // arrays (which also allows us to take advantage of
7625 // some speed optimisations)
7626 m_rowHeights.Empty();
7627 m_rowBottoms.Empty();
7628 if ( !GetBatchCount() )
7629 CalcDimensions();
7630 }
7631}
7632
7633void wxGrid::SetRowSize( int row, int height )
7634{
7635 wxCHECK_RET( row >= 0 && row < m_numRows, wxT("invalid row index") );
7636
7637 // if < 0 then calculate new height from label
7638 if ( height < 0 )
7639 {
7640 long w, h;
7641 wxArrayString lines;
7642 wxClientDC dc(m_rowLabelWin);
7643 dc.SetFont(GetLabelFont());
7644 StringToLines(GetRowLabelValue( row ), lines);
7645 GetTextBoxSize( dc, lines, &w, &h );
7646 //check that it is not less than the minimal height
7647 height = wxMax(h, GetRowMinimalAcceptableHeight());
7648 }
7649
7650 // See comment in SetColSize
7651 if ( height < GetRowMinimalAcceptableHeight())
7652 return;
7653
7654 if ( m_rowHeights.IsEmpty() )
7655 {
7656 // need to really create the array
7657 InitRowHeights();
7658 }
7659
7660 int h = wxMax( 0, height );
7661 int diff = h - m_rowHeights[row];
7662
7663 m_rowHeights[row] = h;
7664 for ( int i = row; i < m_numRows; i++ )
7665 {
7666 m_rowBottoms[i] += diff;
7667 }
7668
7669 if ( !GetBatchCount() )
7670 CalcDimensions();
7671}
7672
7673void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
7674{
7675 // we dont allow zero default column width
7676 m_defaultColWidth = wxMax( wxMax( width, m_minAcceptableColWidth ), 1 );
7677
7678 if ( resizeExistingCols )
7679 {
7680 // since we are resizing all columns to the default column size,
7681 // we can simply clear the col widths and col rights
7682 // arrays (which also allows us to take advantage of
7683 // some speed optimisations)
7684 m_colWidths.Empty();
7685 m_colRights.Empty();
7686 if ( !GetBatchCount() )
7687 CalcDimensions();
7688 }
7689}
7690
7691void wxGrid::SetColSize( int col, int width )
7692{
7693 wxCHECK_RET( col >= 0 && col < m_numCols, wxT("invalid column index") );
7694
7695 // if < 0 then calculate new width from label
7696 if ( width < 0 )
7697 {
7698 long w, h;
7699 wxArrayString lines;
7700 wxClientDC dc(m_colWindow);
7701 dc.SetFont(GetLabelFont());
7702 StringToLines(GetColLabelValue(col), lines);
7703 if ( GetColLabelTextOrientation() == wxHORIZONTAL )
7704 GetTextBoxSize( dc, lines, &w, &h );
7705 else
7706 GetTextBoxSize( dc, lines, &h, &w );
7707 width = w + 6;
7708 //check that it is not less than the minimal width
7709 width = wxMax(width, GetColMinimalAcceptableWidth());
7710 }
7711
7712 // we intentionally don't test whether the width is less than
7713 // GetColMinimalWidth() here but we do compare it with
7714 // GetColMinimalAcceptableWidth() as otherwise things currently break (see
7715 // #651) -- and we also always allow the width of 0 as it has the special
7716 // sense of hiding the column
7717 if ( width > 0 && width < GetColMinimalAcceptableWidth() )
7718 return;
7719
7720 if ( m_colWidths.IsEmpty() )
7721 {
7722 // need to really create the array
7723 InitColWidths();
7724 }
7725
7726 const int diff = width - m_colWidths[col];
7727 m_colWidths[col] = width;
7728 if ( m_useNativeHeader )
7729 GetGridColHeader()->UpdateColumn(col);
7730 //else: will be refreshed when the header is redrawn
7731
7732 for ( int colPos = GetColPos(col); colPos < m_numCols; colPos++ )
7733 {
7734 m_colRights[GetColAt(colPos)] += diff;
7735 }
7736
7737 if ( !GetBatchCount() )
7738 {
7739 CalcDimensions();
7740 Refresh();
7741 }
7742}
7743
7744void wxGrid::SetColMinimalWidth( int col, int width )
7745{
7746 if (width > GetColMinimalAcceptableWidth())
7747 {
7748 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
7749 m_colMinWidths[key] = width;
7750 }
7751}
7752
7753void wxGrid::SetRowMinimalHeight( int row, int width )
7754{
7755 if (width > GetRowMinimalAcceptableHeight())
7756 {
7757 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
7758 m_rowMinHeights[key] = width;
7759 }
7760}
7761
7762int wxGrid::GetColMinimalWidth(int col) const
7763{
7764 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
7765 wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
7766
7767 return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
7768}
7769
7770int wxGrid::GetRowMinimalHeight(int row) const
7771{
7772 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
7773 wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
7774
7775 return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
7776}
7777
7778void wxGrid::SetColMinimalAcceptableWidth( int width )
7779{
7780 // We do allow a width of 0 since this gives us
7781 // an easy way to temporarily hiding columns.
7782 if ( width >= 0 )
7783 m_minAcceptableColWidth = width;
7784}
7785
7786void wxGrid::SetRowMinimalAcceptableHeight( int height )
7787{
7788 // We do allow a height of 0 since this gives us
7789 // an easy way to temporarily hiding rows.
7790 if ( height >= 0 )
7791 m_minAcceptableRowHeight = height;
7792}
7793
7794int wxGrid::GetColMinimalAcceptableWidth() const
7795{
7796 return m_minAcceptableColWidth;
7797}
7798
7799int wxGrid::GetRowMinimalAcceptableHeight() const
7800{
7801 return m_minAcceptableRowHeight;
7802}
7803
7804// ----------------------------------------------------------------------------
7805// auto sizing
7806// ----------------------------------------------------------------------------
7807
7808void
7809wxGrid::AutoSizeColOrRow(int colOrRow, bool setAsMin, wxGridDirection direction)
7810{
7811 const bool column = direction == wxGRID_COLUMN;
7812
7813 wxClientDC dc(m_gridWin);
7814
7815 // cancel editing of cell
7816 HideCellEditControl();
7817 SaveEditControlValue();
7818
7819 // initialize both of them just to avoid compiler warnings even if only
7820 // really needs to be initialized here
7821 int row,
7822 col;
7823 if ( column )
7824 {
7825 row = -1;
7826 col = colOrRow;
7827 }
7828 else
7829 {
7830 row = colOrRow;
7831 col = -1;
7832 }
7833
7834 wxCoord extent, extentMax = 0;
7835 int max = column ? m_numRows : m_numCols;
7836 for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
7837 {
7838 if ( column )
7839 row = rowOrCol;
7840 else
7841 col = rowOrCol;
7842
7843 // we need to account for the cells spanning multiple columns/rows:
7844 // while they may need a lot of space, they don't need all of it in
7845 // this column/row
7846 int numRows, numCols;
7847 const CellSpan span = GetCellSize(row, col, &numRows, &numCols);
7848 if ( span == CellSpan_Inside )
7849 {
7850 // we need to get the size of the main cell, not of a cell hidden
7851 // by it
7852 row += numRows;
7853 col += numCols;
7854
7855 // get the size of the main cell too
7856 GetCellSize(row, col, &numRows, &numCols);
7857 }
7858
7859 wxGridCellAttr *attr = GetCellAttr(row, col);
7860 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
7861 if ( renderer )
7862 {
7863 wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
7864 extent = column ? size.x : size.y;
7865
7866 if ( span != CellSpan_None )
7867 {
7868 // we spread the size of a spanning cell over all the cells it
7869 // covers evenly -- this is probably not ideal but we can't
7870 // really do much better here
7871 //
7872 // notice that numCols and numRows are never 0 as they
7873 // correspond to the size of the main cell of the span and not
7874 // of the cell inside it
7875 extent /= column ? numCols : numRows;
7876 }
7877
7878 if ( extent > extentMax )
7879 extentMax = extent;
7880
7881 renderer->DecRef();
7882 }
7883
7884 attr->DecRef();
7885 }
7886
7887 // now also compare with the column label extent
7888 wxCoord w, h;
7889 dc.SetFont( GetLabelFont() );
7890
7891 if ( column )
7892 {
7893 dc.GetMultiLineTextExtent( GetColLabelValue(col), &w, &h );
7894 if ( GetColLabelTextOrientation() == wxVERTICAL )
7895 w = h;
7896 }
7897 else
7898 dc.GetMultiLineTextExtent( GetRowLabelValue(row), &w, &h );
7899
7900 extent = column ? w : h;
7901 if ( extent > extentMax )
7902 extentMax = extent;
7903
7904 if ( !extentMax )
7905 {
7906 // empty column - give default extent (notice that if extentMax is less
7907 // than default extent but != 0, it's OK)
7908 extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
7909 }
7910 else
7911 {
7912 if ( column )
7913 // leave some space around text
7914 extentMax += 10;
7915 else
7916 extentMax += 6;
7917 }
7918
7919 if ( column )
7920 {
7921 // Ensure automatic width is not less than minimal width. See the
7922 // comment in SetColSize() for explanation of why this isn't done
7923 // in SetColSize().
7924 if ( !setAsMin )
7925 extentMax = wxMax(extentMax, GetColMinimalWidth(col));
7926
7927 SetColSize( col, extentMax );
7928 if ( !GetBatchCount() )
7929 {
7930 if ( m_useNativeHeader )
7931 {
7932 GetGridColHeader()->UpdateColumn(col);
7933 }
7934 else
7935 {
7936 int cw, ch, dummy;
7937 m_gridWin->GetClientSize( &cw, &ch );
7938 wxRect rect ( CellToRect( 0, col ) );
7939 rect.y = 0;
7940 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
7941 rect.width = cw - rect.x;
7942 rect.height = m_colLabelHeight;
7943 GetColLabelWindow()->Refresh( true, &rect );
7944 }
7945 }
7946 }
7947 else
7948 {
7949 // Ensure automatic width is not less than minimal height. See the
7950 // comment in SetColSize() for explanation of why this isn't done
7951 // in SetRowSize().
7952 if ( !setAsMin )
7953 extentMax = wxMax(extentMax, GetRowMinimalHeight(row));
7954
7955 SetRowSize(row, extentMax);
7956 if ( !GetBatchCount() )
7957 {
7958 int cw, ch, dummy;
7959 m_gridWin->GetClientSize( &cw, &ch );
7960 wxRect rect( CellToRect( row, 0 ) );
7961 rect.x = 0;
7962 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
7963 rect.width = m_rowLabelWidth;
7964 rect.height = ch - rect.y;
7965 m_rowLabelWin->Refresh( true, &rect );
7966 }
7967 }
7968
7969 if ( setAsMin )
7970 {
7971 if ( column )
7972 SetColMinimalWidth(col, extentMax);
7973 else
7974 SetRowMinimalHeight(row, extentMax);
7975 }
7976}
7977
7978wxCoord wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction)
7979{
7980 // calculate size for the rows or columns?
7981 const bool calcRows = direction == wxGRID_ROW;
7982
7983 wxClientDC dc(calcRows ? GetGridRowLabelWindow()
7984 : GetGridColLabelWindow());
7985 dc.SetFont(GetLabelFont());
7986
7987 // which dimension should we take into account for calculations?
7988 //
7989 // for columns, the text can be only horizontal so it's easy but for rows
7990 // we also have to take into account the text orientation
7991 const bool
7992 useWidth = calcRows || (GetColLabelTextOrientation() == wxVERTICAL);
7993
7994 wxArrayString lines;
7995 wxCoord extentMax = 0;
7996
7997 const int numRowsOrCols = calcRows ? m_numRows : m_numCols;
7998 for ( int rowOrCol = 0; rowOrCol < numRowsOrCols; rowOrCol++ )
7999 {
8000 lines.Clear();
8001
8002 wxString label = calcRows ? GetRowLabelValue(rowOrCol)
8003 : GetColLabelValue(rowOrCol);
8004 StringToLines(label, lines);
8005
8006 long w, h;
8007 GetTextBoxSize(dc, lines, &w, &h);
8008
8009 const wxCoord extent = useWidth ? w : h;
8010 if ( extent > extentMax )
8011 extentMax = extent;
8012 }
8013
8014 if ( !extentMax )
8015 {
8016 // empty column - give default extent (notice that if extentMax is less
8017 // than default extent but != 0, it's OK)
8018 extentMax = calcRows ? GetDefaultRowLabelSize()
8019 : GetDefaultColLabelSize();
8020 }
8021
8022 // leave some space around text (taken from AutoSizeColOrRow)
8023 if ( calcRows )
8024 extentMax += 10;
8025 else
8026 extentMax += 6;
8027
8028 return extentMax;
8029}
8030
8031int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
8032{
8033 int width = m_rowLabelWidth;
8034
8035 wxGridUpdateLocker locker;
8036 if(!calcOnly)
8037 locker.Create(this);
8038
8039 for ( int col = 0; col < m_numCols; col++ )
8040 {
8041 if ( !calcOnly )
8042 AutoSizeColumn(col, setAsMin);
8043
8044 width += GetColWidth(col);
8045 }
8046
8047 return width;
8048}
8049
8050int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
8051{
8052 int height = m_colLabelHeight;
8053
8054 wxGridUpdateLocker locker;
8055 if(!calcOnly)
8056 locker.Create(this);
8057
8058 for ( int row = 0; row < m_numRows; row++ )
8059 {
8060 if ( !calcOnly )
8061 AutoSizeRow(row, setAsMin);
8062
8063 height += GetRowHeight(row);
8064 }
8065
8066 return height;
8067}
8068
8069void wxGrid::AutoSize()
8070{
8071 wxGridUpdateLocker locker(this);
8072
8073 wxSize size(SetOrCalcColumnSizes(false) - m_rowLabelWidth + m_extraWidth,
8074 SetOrCalcRowSizes(false) - m_colLabelHeight + m_extraHeight);
8075
8076 // we know that we're not going to have scrollbars so disable them now to
8077 // avoid trouble in SetClientSize() which can otherwise set the correct
8078 // client size but also leave space for (not needed any more) scrollbars
8079 SetScrollbars(m_xScrollPixelsPerLine, m_yScrollPixelsPerLine,
8080 0, 0, 0, 0, true);
8081
8082 SetClientSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight);
8083}
8084
8085void wxGrid::AutoSizeRowLabelSize( int row )
8086{
8087 // Hide the edit control, so it
8088 // won't interfere with drag-shrinking.
8089 if ( IsCellEditControlShown() )
8090 {
8091 HideCellEditControl();
8092 SaveEditControlValue();
8093 }
8094
8095 // autosize row height depending on label text
8096 SetRowSize(row, -1);
8097 ForceRefresh();
8098}
8099
8100void wxGrid::AutoSizeColLabelSize( int col )
8101{
8102 // Hide the edit control, so it
8103 // won't interfere with drag-shrinking.
8104 if ( IsCellEditControlShown() )
8105 {
8106 HideCellEditControl();
8107 SaveEditControlValue();
8108 }
8109
8110 // autosize column width depending on label text
8111 SetColSize(col, -1);
8112 ForceRefresh();
8113}
8114
8115wxSize wxGrid::DoGetBestSize() const
8116{
8117 wxGrid * const self = const_cast<wxGrid *>(this);
8118
8119 // we do the same as in AutoSize() here with the exception that we don't
8120 // change the column/row sizes, only calculate them
8121 wxSize size(self->SetOrCalcColumnSizes(true) - m_rowLabelWidth + m_extraWidth,
8122 self->SetOrCalcRowSizes(true) - m_colLabelHeight + m_extraHeight);
8123
8124 // NOTE: This size should be cached, but first we need to add calls to
8125 // InvalidateBestSize everywhere that could change the results of this
8126 // calculation.
8127 // CacheBestSize(size);
8128
8129 return wxSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight)
8130 + GetWindowBorderSize();
8131}
8132
8133void wxGrid::Fit()
8134{
8135 AutoSize();
8136}
8137
8138wxPen& wxGrid::GetDividerPen() const
8139{
8140 return wxNullPen;
8141}
8142
8143// ----------------------------------------------------------------------------
8144// cell value accessor functions
8145// ----------------------------------------------------------------------------
8146
8147void wxGrid::SetCellValue( int row, int col, const wxString& s )
8148{
8149 if ( m_table )
8150 {
8151 m_table->SetValue( row, col, s );
8152 if ( !GetBatchCount() )
8153 {
8154 int dummy;
8155 wxRect rect( CellToRect( row, col ) );
8156 rect.x = 0;
8157 rect.width = m_gridWin->GetClientSize().GetWidth();
8158 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
8159 m_gridWin->Refresh( false, &rect );
8160 }
8161
8162 if ( m_currentCellCoords.GetRow() == row &&
8163 m_currentCellCoords.GetCol() == col &&
8164 IsCellEditControlShown())
8165 // Note: If we are using IsCellEditControlEnabled,
8166 // this interacts badly with calling SetCellValue from
8167 // an EVT_GRID_CELL_CHANGE handler.
8168 {
8169 HideCellEditControl();
8170 ShowCellEditControl(); // will reread data from table
8171 }
8172 }
8173}
8174
8175// ----------------------------------------------------------------------------
8176// block, row and column selection
8177// ----------------------------------------------------------------------------
8178
8179void wxGrid::SelectRow( int row, bool addToSelected )
8180{
8181 if ( !m_selection )
8182 return;
8183
8184 if ( !addToSelected )
8185 ClearSelection();
8186
8187 m_selection->SelectRow(row);
8188}
8189
8190void wxGrid::SelectCol( int col, bool addToSelected )
8191{
8192 if ( !m_selection )
8193 return;
8194
8195 if ( !addToSelected )
8196 ClearSelection();
8197
8198 m_selection->SelectCol(col);
8199}
8200
8201void wxGrid::SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
8202 bool addToSelected)
8203{
8204 if ( !m_selection )
8205 return;
8206
8207 if ( !addToSelected )
8208 ClearSelection();
8209
8210 m_selection->SelectBlock(topRow, leftCol, bottomRow, rightCol);
8211}
8212
8213void wxGrid::SelectAll()
8214{
8215 if ( m_numRows > 0 && m_numCols > 0 )
8216 {
8217 if ( m_selection )
8218 m_selection->SelectBlock( 0, 0, m_numRows - 1, m_numCols - 1 );
8219 }
8220}
8221
8222// ----------------------------------------------------------------------------
8223// cell, row and col deselection
8224// ----------------------------------------------------------------------------
8225
8226void wxGrid::DeselectLine(int line, const wxGridOperations& oper)
8227{
8228 if ( !m_selection )
8229 return;
8230
8231 const wxGridSelectionModes mode = m_selection->GetSelectionMode();
8232 if ( mode == oper.GetSelectionMode() ||
8233 mode == wxGrid::wxGridSelectRowsOrColumns )
8234 {
8235 const wxGridCellCoords c(oper.MakeCoords(line, 0));
8236 if ( m_selection->IsInSelection(c) )
8237 m_selection->ToggleCellSelection(c);
8238 }
8239 else if ( mode != oper.Dual().GetSelectionMode() )
8240 {
8241 const int nOther = oper.Dual().GetNumberOfLines(this);
8242 for ( int i = 0; i < nOther; i++ )
8243 {
8244 const wxGridCellCoords c(oper.MakeCoords(line, i));
8245 if ( m_selection->IsInSelection(c) )
8246 m_selection->ToggleCellSelection(c);
8247 }
8248 }
8249 //else: can only select orthogonal lines so no lines in this direction
8250 // could have been selected anyhow
8251}
8252
8253void wxGrid::DeselectRow(int row)
8254{
8255 DeselectLine(row, wxGridRowOperations());
8256}
8257
8258void wxGrid::DeselectCol(int col)
8259{
8260 DeselectLine(col, wxGridColumnOperations());
8261}
8262
8263void wxGrid::DeselectCell( int row, int col )
8264{
8265 if ( m_selection && m_selection->IsInSelection(row, col) )
8266 m_selection->ToggleCellSelection(row, col);
8267}
8268
8269bool wxGrid::IsSelection() const
8270{
8271 return ( m_selection && (m_selection->IsSelection() ||
8272 ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
8273 m_selectedBlockBottomRight != wxGridNoCellCoords) ) );
8274}
8275
8276bool wxGrid::IsInSelection( int row, int col ) const
8277{
8278 return ( m_selection && (m_selection->IsInSelection( row, col ) ||
8279 ( row >= m_selectedBlockTopLeft.GetRow() &&
8280 col >= m_selectedBlockTopLeft.GetCol() &&
8281 row <= m_selectedBlockBottomRight.GetRow() &&
8282 col <= m_selectedBlockBottomRight.GetCol() )) );
8283}
8284
8285wxGridCellCoordsArray wxGrid::GetSelectedCells() const
8286{
8287 if (!m_selection)
8288 {
8289 wxGridCellCoordsArray a;
8290 return a;
8291 }
8292
8293 return m_selection->m_cellSelection;
8294}
8295
8296wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
8297{
8298 if (!m_selection)
8299 {
8300 wxGridCellCoordsArray a;
8301 return a;
8302 }
8303
8304 return m_selection->m_blockSelectionTopLeft;
8305}
8306
8307wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
8308{
8309 if (!m_selection)
8310 {
8311 wxGridCellCoordsArray a;
8312 return a;
8313 }
8314
8315 return m_selection->m_blockSelectionBottomRight;
8316}
8317
8318wxArrayInt wxGrid::GetSelectedRows() const
8319{
8320 if (!m_selection)
8321 {
8322 wxArrayInt a;
8323 return a;
8324 }
8325
8326 return m_selection->m_rowSelection;
8327}
8328
8329wxArrayInt wxGrid::GetSelectedCols() const
8330{
8331 if (!m_selection)
8332 {
8333 wxArrayInt a;
8334 return a;
8335 }
8336
8337 return m_selection->m_colSelection;
8338}
8339
8340void wxGrid::ClearSelection()
8341{
8342 wxRect r1 = BlockToDeviceRect(m_selectedBlockTopLeft,
8343 m_selectedBlockBottomRight);
8344 wxRect r2 = BlockToDeviceRect(m_currentCellCoords,
8345 m_selectedBlockCorner);
8346
8347 m_selectedBlockTopLeft =
8348 m_selectedBlockBottomRight =
8349 m_selectedBlockCorner = wxGridNoCellCoords;
8350
8351 if ( !r1.IsEmpty() )
8352 RefreshRect(r1, false);
8353 if ( !r2.IsEmpty() )
8354 RefreshRect(r2, false);
8355
8356 if ( m_selection )
8357 m_selection->ClearSelection();
8358}
8359
8360// This function returns the rectangle that encloses the given block
8361// in device coords clipped to the client size of the grid window.
8362//
8363wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords& topLeft,
8364 const wxGridCellCoords& bottomRight ) const
8365{
8366 wxRect resultRect;
8367 wxRect tempCellRect = CellToRect(topLeft);
8368 if ( tempCellRect != wxGridNoCellRect )
8369 {
8370 resultRect = tempCellRect;
8371 }
8372 else
8373 {
8374 resultRect = wxRect(0, 0, 0, 0);
8375 }
8376
8377 tempCellRect = CellToRect(bottomRight);
8378 if ( tempCellRect != wxGridNoCellRect )
8379 {
8380 resultRect += tempCellRect;
8381 }
8382 else
8383 {
8384 // If both inputs were "wxGridNoCellRect," then there's nothing to do.
8385 return wxGridNoCellRect;
8386 }
8387
8388 // Ensure that left/right and top/bottom pairs are in order.
8389 int left = resultRect.GetLeft();
8390 int top = resultRect.GetTop();
8391 int right = resultRect.GetRight();
8392 int bottom = resultRect.GetBottom();
8393
8394 int leftCol = topLeft.GetCol();
8395 int topRow = topLeft.GetRow();
8396 int rightCol = bottomRight.GetCol();
8397 int bottomRow = bottomRight.GetRow();
8398
8399 if (left > right)
8400 {
8401 int tmp = left;
8402 left = right;
8403 right = tmp;
8404
8405 tmp = leftCol;
8406 leftCol = rightCol;
8407 rightCol = tmp;
8408 }
8409
8410 if (top > bottom)
8411 {
8412 int tmp = top;
8413 top = bottom;
8414 bottom = tmp;
8415
8416 tmp = topRow;
8417 topRow = bottomRow;
8418 bottomRow = tmp;
8419 }
8420
8421 // The following loop is ONLY necessary to detect and handle merged cells.
8422 int cw, ch;
8423 m_gridWin->GetClientSize( &cw, &ch );
8424
8425 // Get the origin coordinates: notice that they will be negative if the
8426 // grid is scrolled downwards/to the right.
8427 int gridOriginX = 0;
8428 int gridOriginY = 0;
8429 CalcScrolledPosition(gridOriginX, gridOriginY, &gridOriginX, &gridOriginY);
8430
8431 int onScreenLeftmostCol = internalXToCol(-gridOriginX);
8432 int onScreenUppermostRow = internalYToRow(-gridOriginY);
8433
8434 int onScreenRightmostCol = internalXToCol(-gridOriginX + cw);
8435 int onScreenBottommostRow = internalYToRow(-gridOriginY + ch);
8436
8437 // Bound our loop so that we only examine the portion of the selected block
8438 // that is shown on screen. Therefore, we compare the Top-Left block values
8439 // to the Top-Left screen values, and the Bottom-Right block values to the
8440 // Bottom-Right screen values, choosing appropriately.
8441 const int visibleTopRow = wxMax(topRow, onScreenUppermostRow);
8442 const int visibleBottomRow = wxMin(bottomRow, onScreenBottommostRow);
8443 const int visibleLeftCol = wxMax(leftCol, onScreenLeftmostCol);
8444 const int visibleRightCol = wxMin(rightCol, onScreenRightmostCol);
8445
8446 for ( int j = visibleTopRow; j <= visibleBottomRow; j++ )
8447 {
8448 for ( int i = visibleLeftCol; i <= visibleRightCol; i++ )
8449 {
8450 if ( (j == visibleTopRow) || (j == visibleBottomRow) ||
8451 (i == visibleLeftCol) || (i == visibleRightCol) )
8452 {
8453 tempCellRect = CellToRect( j, i );
8454
8455 if (tempCellRect.x < left)
8456 left = tempCellRect.x;
8457 if (tempCellRect.y < top)
8458 top = tempCellRect.y;
8459 if (tempCellRect.x + tempCellRect.width > right)
8460 right = tempCellRect.x + tempCellRect.width;
8461 if (tempCellRect.y + tempCellRect.height > bottom)
8462 bottom = tempCellRect.y + tempCellRect.height;
8463 }
8464 else
8465 {
8466 i = visibleRightCol; // jump over inner cells.
8467 }
8468 }
8469 }
8470
8471 // Convert to scrolled coords
8472 CalcScrolledPosition( left, top, &left, &top );
8473 CalcScrolledPosition( right, bottom, &right, &bottom );
8474
8475 if (right < 0 || bottom < 0 || left > cw || top > ch)
8476 return wxRect(0,0,0,0);
8477
8478 resultRect.SetLeft( wxMax(0, left) );
8479 resultRect.SetTop( wxMax(0, top) );
8480 resultRect.SetRight( wxMin(cw, right) );
8481 resultRect.SetBottom( wxMin(ch, bottom) );
8482
8483 return resultRect;
8484}
8485
8486void wxGrid::DoSetSizes(const wxGridSizesInfo& sizeInfo,
8487 const wxGridOperations& oper)
8488{
8489 BeginBatch();
8490 oper.SetDefaultLineSize(this, sizeInfo.m_sizeDefault, true);
8491 const int numLines = oper.GetNumberOfLines(this);
8492 for ( int i = 0; i < numLines; i++ )
8493 {
8494 int size = sizeInfo.GetSize(i);
8495 if ( size != sizeInfo.m_sizeDefault)
8496 oper.SetLineSize(this, i, size);
8497 }
8498 EndBatch();
8499}
8500
8501void wxGrid::SetColSizes(const wxGridSizesInfo& sizeInfo)
8502{
8503 DoSetSizes(sizeInfo, wxGridColumnOperations());
8504}
8505
8506void wxGrid::SetRowSizes(const wxGridSizesInfo& sizeInfo)
8507{
8508 DoSetSizes(sizeInfo, wxGridRowOperations());
8509}
8510
8511wxGridSizesInfo::wxGridSizesInfo(int defSize, const wxArrayInt& allSizes)
8512{
8513 m_sizeDefault = defSize;
8514 for ( size_t i = 0; i < allSizes.size(); i++ )
8515 {
8516 if ( allSizes[i] != defSize )
8517 m_customSizes[i] = allSizes[i];
8518 }
8519}
8520
8521int wxGridSizesInfo::GetSize(unsigned pos) const
8522{
8523 wxUnsignedToIntHashMap::const_iterator it = m_customSizes.find(pos);
8524
8525 return it == m_customSizes.end() ? m_sizeDefault : it->second;
8526}
8527
8528// ----------------------------------------------------------------------------
8529// drop target
8530// ----------------------------------------------------------------------------
8531
8532#if wxUSE_DRAG_AND_DROP
8533
8534// this allow setting drop target directly on wxGrid
8535void wxGrid::SetDropTarget(wxDropTarget *dropTarget)
8536{
8537 GetGridWindow()->SetDropTarget(dropTarget);
8538}
8539
8540#endif // wxUSE_DRAG_AND_DROP
8541
8542// ----------------------------------------------------------------------------
8543// grid event classes
8544// ----------------------------------------------------------------------------
8545
8546IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
8547
8548wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
8549 int row, int col, int x, int y, bool sel,
8550 bool control, bool shift, bool alt, bool meta )
8551 : wxNotifyEvent( type, id ),
8552 wxKeyboardState(control, shift, alt, meta)
8553{
8554 Init(row, col, x, y, sel);
8555
8556 SetEventObject(obj);
8557}
8558
8559IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
8560
8561wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
8562 int rowOrCol, int x, int y,
8563 bool control, bool shift, bool alt, bool meta )
8564 : wxNotifyEvent( type, id ),
8565 wxKeyboardState(control, shift, alt, meta)
8566{
8567 Init(rowOrCol, x, y);
8568
8569 SetEventObject(obj);
8570}
8571
8572
8573IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
8574
8575wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8576 const wxGridCellCoords& topLeft,
8577 const wxGridCellCoords& bottomRight,
8578 bool sel, bool control,
8579 bool shift, bool alt, bool meta )
8580 : wxNotifyEvent( type, id ),
8581 wxKeyboardState(control, shift, alt, meta)
8582{
8583 Init(topLeft, bottomRight, sel);
8584
8585 SetEventObject(obj);
8586}
8587
8588
8589IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
8590
8591wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
8592 wxObject* obj, int row,
8593 int col, wxControl* ctrl)
8594 : wxCommandEvent(type, id)
8595{
8596 SetEventObject(obj);
8597 m_row = row;
8598 m_col = col;
8599 m_ctrl = ctrl;
8600}
8601
8602
8603// ----------------------------------------------------------------------------
8604// wxGridTypeRegistry
8605// ----------------------------------------------------------------------------
8606
8607wxGridTypeRegistry::~wxGridTypeRegistry()
8608{
8609 size_t count = m_typeinfo.GetCount();
8610 for ( size_t i = 0; i < count; i++ )
8611 delete m_typeinfo[i];
8612}
8613
8614void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
8615 wxGridCellRenderer* renderer,
8616 wxGridCellEditor* editor)
8617{
8618 wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
8619
8620 // is it already registered?
8621 int loc = FindRegisteredDataType(typeName);
8622 if ( loc != wxNOT_FOUND )
8623 {
8624 delete m_typeinfo[loc];
8625 m_typeinfo[loc] = info;
8626 }
8627 else
8628 {
8629 m_typeinfo.Add(info);
8630 }
8631}
8632
8633int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
8634{
8635 size_t count = m_typeinfo.GetCount();
8636 for ( size_t i = 0; i < count; i++ )
8637 {
8638 if ( typeName == m_typeinfo[i]->m_typeName )
8639 {
8640 return i;
8641 }
8642 }
8643
8644 return wxNOT_FOUND;
8645}
8646
8647int wxGridTypeRegistry::FindDataType(const wxString& typeName)
8648{
8649 int index = FindRegisteredDataType(typeName);
8650 if ( index == wxNOT_FOUND )
8651 {
8652 // check whether this is one of the standard ones, in which case
8653 // register it "on the fly"
8654#if wxUSE_TEXTCTRL
8655 if ( typeName == wxGRID_VALUE_STRING )
8656 {
8657 RegisterDataType(wxGRID_VALUE_STRING,
8658 new wxGridCellStringRenderer,
8659 new wxGridCellTextEditor);
8660 }
8661 else
8662#endif // wxUSE_TEXTCTRL
8663#if wxUSE_CHECKBOX
8664 if ( typeName == wxGRID_VALUE_BOOL )
8665 {
8666 RegisterDataType(wxGRID_VALUE_BOOL,
8667 new wxGridCellBoolRenderer,
8668 new wxGridCellBoolEditor);
8669 }
8670 else
8671#endif // wxUSE_CHECKBOX
8672#if wxUSE_TEXTCTRL
8673 if ( typeName == wxGRID_VALUE_NUMBER )
8674 {
8675 RegisterDataType(wxGRID_VALUE_NUMBER,
8676 new wxGridCellNumberRenderer,
8677 new wxGridCellNumberEditor);
8678 }
8679 else if ( typeName == wxGRID_VALUE_FLOAT )
8680 {
8681 RegisterDataType(wxGRID_VALUE_FLOAT,
8682 new wxGridCellFloatRenderer,
8683 new wxGridCellFloatEditor);
8684 }
8685 else
8686#endif // wxUSE_TEXTCTRL
8687#if wxUSE_COMBOBOX
8688 if ( typeName == wxGRID_VALUE_CHOICE )
8689 {
8690 RegisterDataType(wxGRID_VALUE_CHOICE,
8691 new wxGridCellStringRenderer,
8692 new wxGridCellChoiceEditor);
8693 }
8694 else
8695#endif // wxUSE_COMBOBOX
8696 {
8697 return wxNOT_FOUND;
8698 }
8699
8700 // we get here only if just added the entry for this type, so return
8701 // the last index
8702 index = m_typeinfo.GetCount() - 1;
8703 }
8704
8705 return index;
8706}
8707
8708int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
8709{
8710 int index = FindDataType(typeName);
8711 if ( index == wxNOT_FOUND )
8712 {
8713 // the first part of the typename is the "real" type, anything after ':'
8714 // are the parameters for the renderer
8715 index = FindDataType(typeName.BeforeFirst(wxT(':')));
8716 if ( index == wxNOT_FOUND )
8717 {
8718 return wxNOT_FOUND;
8719 }
8720
8721 wxGridCellRenderer *renderer = GetRenderer(index);
8722 wxGridCellRenderer *rendererOld = renderer;
8723 renderer = renderer->Clone();
8724 rendererOld->DecRef();
8725
8726 wxGridCellEditor *editor = GetEditor(index);
8727 wxGridCellEditor *editorOld = editor;
8728 editor = editor->Clone();
8729 editorOld->DecRef();
8730
8731 // do it even if there are no parameters to reset them to defaults
8732 wxString params = typeName.AfterFirst(wxT(':'));
8733 renderer->SetParameters(params);
8734 editor->SetParameters(params);
8735
8736 // register the new typename
8737 RegisterDataType(typeName, renderer, editor);
8738
8739 // we just registered it, it's the last one
8740 index = m_typeinfo.GetCount() - 1;
8741 }
8742
8743 return index;
8744}
8745
8746wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
8747{
8748 wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
8749 if (renderer)
8750 renderer->IncRef();
8751
8752 return renderer;
8753}
8754
8755wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
8756{
8757 wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
8758 if (editor)
8759 editor->IncRef();
8760
8761 return editor;
8762}
8763
8764#endif // wxUSE_GRID