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