]> 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
Update the text part of combobox when changing text of selected item in wxGTK.
[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_PTR(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 positive 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 bool
3651 wxGrid::DoGridCellDrag(wxMouseEvent& event,
3652 const wxGridCellCoords& coords,
3653 bool isFirstDrag)
3654 {
3655 bool performDefault = true ;
3656
3657 if ( coords == wxGridNoCellCoords )
3658 return performDefault; // we're outside any valid cell
3659
3660 // Hide the edit control, so it won't interfere with drag-shrinking.
3661 if ( IsCellEditControlShown() )
3662 {
3663 HideCellEditControl();
3664 SaveEditControlValue();
3665 }
3666
3667 switch ( event.GetModifiers() )
3668 {
3669 case wxMOD_CONTROL:
3670 if ( m_selectedBlockCorner == wxGridNoCellCoords)
3671 m_selectedBlockCorner = coords;
3672 UpdateBlockBeingSelected(m_selectedBlockCorner, coords);
3673 break;
3674
3675 case wxMOD_NONE:
3676 if ( CanDragCell() )
3677 {
3678 if ( isFirstDrag )
3679 {
3680 if ( m_selectedBlockCorner == wxGridNoCellCoords)
3681 m_selectedBlockCorner = coords;
3682
3683 // if event is handled by user code, no further processing
3684 if ( SendEvent(wxEVT_GRID_CELL_BEGIN_DRAG, coords, event) != 0 )
3685 performDefault = false;
3686
3687 return performDefault;
3688 }
3689 }
3690
3691 UpdateBlockBeingSelected(m_currentCellCoords, coords);
3692 break;
3693
3694 default:
3695 // we don't handle the other key modifiers
3696 event.Skip();
3697 }
3698
3699 return performDefault;
3700 }
3701
3702 void wxGrid::DoGridLineDrag(wxMouseEvent& event, const wxGridOperations& oper)
3703 {
3704 wxClientDC dc(m_gridWin);
3705 PrepareDC(dc);
3706 dc.SetLogicalFunction(wxINVERT);
3707
3708 const wxRect rectWin(CalcUnscrolledPosition(wxPoint(0, 0)),
3709 m_gridWin->GetClientSize());
3710
3711 // erase the previously drawn line, if any
3712 if ( m_dragLastPos >= 0 )
3713 oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
3714
3715 // we need the vertical position for rows and horizontal for columns here
3716 m_dragLastPos = oper.Dual().Select(CalcUnscrolledPosition(event.GetPosition()));
3717
3718 // don't allow resizing beneath the minimal size
3719 const int posMin = oper.GetLineStartPos(this, m_dragRowOrCol) +
3720 oper.GetMinimalLineSize(this, m_dragRowOrCol);
3721 if ( m_dragLastPos < posMin )
3722 m_dragLastPos = posMin;
3723
3724 // and draw it at the new position
3725 oper.DrawParallelLineInRect(dc, rectWin, m_dragLastPos);
3726 }
3727
3728 void wxGrid::DoGridDragEvent(wxMouseEvent& event, const wxGridCellCoords& coords)
3729 {
3730 if ( !m_isDragging )
3731 {
3732 // Don't start doing anything until the mouse has been dragged far
3733 // enough
3734 const wxPoint& pt = event.GetPosition();
3735 if ( m_startDragPos == wxDefaultPosition )
3736 {
3737 m_startDragPos = pt;
3738 return;
3739 }
3740
3741 if ( abs(m_startDragPos.x - pt.x) <= DRAG_SENSITIVITY &&
3742 abs(m_startDragPos.y - pt.y) <= DRAG_SENSITIVITY )
3743 return;
3744 }
3745
3746 const bool isFirstDrag = !m_isDragging;
3747 m_isDragging = true;
3748
3749 switch ( m_cursorMode )
3750 {
3751 case WXGRID_CURSOR_SELECT_CELL:
3752 // no further handling if handled by user
3753 if ( DoGridCellDrag(event, coords, isFirstDrag) == false )
3754 return;
3755 break;
3756
3757 case WXGRID_CURSOR_RESIZE_ROW:
3758 DoGridLineDrag(event, wxGridRowOperations());
3759 break;
3760
3761 case WXGRID_CURSOR_RESIZE_COL:
3762 DoGridLineDrag(event, wxGridColumnOperations());
3763 break;
3764
3765 default:
3766 event.Skip();
3767 }
3768
3769 if ( isFirstDrag )
3770 {
3771 wxASSERT_MSG( !m_winCapture, "shouldn't capture the mouse twice" );
3772
3773 m_winCapture = m_gridWin;
3774 m_winCapture->CaptureMouse();
3775 }
3776 }
3777
3778 void
3779 wxGrid::DoGridCellLeftDown(wxMouseEvent& event,
3780 const wxGridCellCoords& coords,
3781 const wxPoint& pos)
3782 {
3783 if ( SendEvent(wxEVT_GRID_CELL_LEFT_CLICK, coords, event) )
3784 {
3785 // event handled by user code, no need to do anything here
3786 return;
3787 }
3788
3789 if ( !event.CmdDown() )
3790 ClearSelection();
3791
3792 if ( event.ShiftDown() )
3793 {
3794 if ( m_selection )
3795 {
3796 m_selection->SelectBlock(m_currentCellCoords, coords, event);
3797 m_selectedBlockCorner = coords;
3798 }
3799 }
3800 else if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
3801 {
3802 DisableCellEditControl();
3803 MakeCellVisible( coords );
3804
3805 if ( event.CmdDown() )
3806 {
3807 if ( m_selection )
3808 {
3809 m_selection->ToggleCellSelection(coords, event);
3810 }
3811
3812 m_selectedBlockTopLeft = wxGridNoCellCoords;
3813 m_selectedBlockBottomRight = wxGridNoCellCoords;
3814 m_selectedBlockCorner = coords;
3815 }
3816 else
3817 {
3818 if ( m_selection )
3819 {
3820 // In row or column selection mode just clicking on the cell
3821 // should select the row or column containing it: this is more
3822 // convenient for the kinds of controls that use such selection
3823 // mode and is compatible with 2.8 behaviour (see #12062).
3824 switch ( m_selection->GetSelectionMode() )
3825 {
3826 case wxGridSelectCells:
3827 case wxGridSelectRowsOrColumns:
3828 // nothing to do in these cases
3829 break;
3830
3831 case wxGridSelectRows:
3832 m_selection->SelectRow(coords.GetRow());
3833 break;
3834
3835 case wxGridSelectColumns:
3836 m_selection->SelectCol(coords.GetCol());
3837 break;
3838 }
3839 }
3840
3841 m_waitForSlowClick = m_currentCellCoords == coords &&
3842 coords != wxGridNoCellCoords;
3843 SetCurrentCell( coords );
3844 }
3845 }
3846 }
3847
3848 void
3849 wxGrid::DoGridCellLeftDClick(wxMouseEvent& event,
3850 const wxGridCellCoords& coords,
3851 const wxPoint& pos)
3852 {
3853 if ( XToEdgeOfCol(pos.x) < 0 && YToEdgeOfRow(pos.y) < 0 )
3854 {
3855 if ( !SendEvent(wxEVT_GRID_CELL_LEFT_DCLICK, coords, event) )
3856 {
3857 // we want double click to select a cell and start editing
3858 // (i.e. to behave in same way as sequence of two slow clicks):
3859 m_waitForSlowClick = true;
3860 }
3861 }
3862 }
3863
3864 void
3865 wxGrid::DoGridCellLeftUp(wxMouseEvent& event, const wxGridCellCoords& coords)
3866 {
3867 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3868 {
3869 if (m_winCapture)
3870 {
3871 m_winCapture->ReleaseMouse();
3872 m_winCapture = NULL;
3873 }
3874
3875 if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl() )
3876 {
3877 ClearSelection();
3878 EnableCellEditControl();
3879
3880 wxGridCellAttr *attr = GetCellAttr(coords);
3881 wxGridCellEditor *editor = attr->GetEditor(this, coords.GetRow(), coords.GetCol());
3882 editor->StartingClick();
3883 editor->DecRef();
3884 attr->DecRef();
3885
3886 m_waitForSlowClick = false;
3887 }
3888 else if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
3889 m_selectedBlockBottomRight != wxGridNoCellCoords )
3890 {
3891 if ( m_selection )
3892 {
3893 m_selection->SelectBlock( m_selectedBlockTopLeft,
3894 m_selectedBlockBottomRight,
3895 event );
3896 }
3897
3898 m_selectedBlockTopLeft = wxGridNoCellCoords;
3899 m_selectedBlockBottomRight = wxGridNoCellCoords;
3900
3901 // Show the edit control, if it has been hidden for
3902 // drag-shrinking.
3903 ShowCellEditControl();
3904 }
3905 }
3906 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
3907 {
3908 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3909 DoEndDragResizeRow(event);
3910 }
3911 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
3912 {
3913 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3914 DoEndDragResizeCol(event);
3915 }
3916
3917 m_dragLastPos = -1;
3918 }
3919
3920 void
3921 wxGrid::DoGridMouseMoveEvent(wxMouseEvent& WXUNUSED(event),
3922 const wxGridCellCoords& coords,
3923 const wxPoint& pos)
3924 {
3925 if ( coords.GetRow() < 0 || coords.GetCol() < 0 )
3926 {
3927 // out of grid cell area
3928 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3929 return;
3930 }
3931
3932 int dragRow = YToEdgeOfRow( pos.y );
3933 int dragCol = XToEdgeOfCol( pos.x );
3934
3935 // Dragging on the corner of a cell to resize in both
3936 // directions is not implemented yet...
3937 //
3938 if ( dragRow >= 0 && dragCol >= 0 )
3939 {
3940 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3941 return;
3942 }
3943
3944 if ( dragRow >= 0 && CanDragGridSize() && CanDragRowSize(dragRow) )
3945 {
3946 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3947 {
3948 m_dragRowOrCol = dragRow;
3949 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, NULL, false);
3950 }
3951 }
3952 // When using the native header window we can only resize the columns by
3953 // dragging the dividers in it because we can't make it enter into the
3954 // column resizing mode programmatically
3955 else if ( dragCol >= 0 && !m_useNativeHeader &&
3956 CanDragGridSize() && CanDragColSize(dragCol) )
3957 {
3958 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
3959 {
3960 m_dragRowOrCol = dragCol;
3961 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, NULL, false);
3962 }
3963 }
3964 else // Neither on a row or col edge
3965 {
3966 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
3967 {
3968 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
3969 }
3970 }
3971 }
3972
3973 void wxGrid::ProcessGridCellMouseEvent(wxMouseEvent& event)
3974 {
3975 if ( event.Entering() || event.Leaving() )
3976 {
3977 // we don't care about these events but we must not reset m_isDragging
3978 // if they happen so return before anything else is done
3979 event.Skip();
3980 return;
3981 }
3982
3983 const wxPoint pos = CalcUnscrolledPosition(event.GetPosition());
3984
3985 // coordinates of the cell under mouse
3986 wxGridCellCoords coords = XYToCell(pos);
3987
3988 int cell_rows, cell_cols;
3989 GetCellSize( coords.GetRow(), coords.GetCol(), &cell_rows, &cell_cols );
3990 if ( (cell_rows < 0) || (cell_cols < 0) )
3991 {
3992 coords.SetRow(coords.GetRow() + cell_rows);
3993 coords.SetCol(coords.GetCol() + cell_cols);
3994 }
3995
3996 if ( event.Dragging() )
3997 {
3998 if ( event.LeftIsDown() )
3999 DoGridDragEvent(event, coords);
4000 else
4001 event.Skip();
4002 return;
4003 }
4004
4005 m_isDragging = false;
4006 m_startDragPos = wxDefaultPosition;
4007
4008 // deal with various button presses
4009 if ( event.IsButton() )
4010 {
4011 if ( coords != wxGridNoCellCoords )
4012 {
4013 DisableCellEditControl();
4014
4015 if ( event.LeftDown() )
4016 DoGridCellLeftDown(event, coords, pos);
4017 else if ( event.LeftDClick() )
4018 DoGridCellLeftDClick(event, coords, pos);
4019 else if ( event.RightDown() )
4020 SendEvent(wxEVT_GRID_CELL_RIGHT_CLICK, coords, event);
4021 else if ( event.RightDClick() )
4022 SendEvent(wxEVT_GRID_CELL_RIGHT_DCLICK, coords, event);
4023 }
4024
4025 // this one should be called even if we're not over any cell
4026 if ( event.LeftUp() )
4027 {
4028 DoGridCellLeftUp(event, coords);
4029 }
4030 }
4031 else if ( event.Moving() )
4032 {
4033 DoGridMouseMoveEvent(event, coords, pos);
4034 }
4035 else // unknown mouse event?
4036 {
4037 event.Skip();
4038 }
4039 }
4040
4041 // this function returns true only if the size really changed
4042 bool wxGrid::DoEndDragResizeLine(const wxGridOperations& oper)
4043 {
4044 if ( m_dragLastPos == -1 )
4045 return false;
4046
4047 const wxGridOperations& doper = oper.Dual();
4048
4049 const wxSize size = m_gridWin->GetClientSize();
4050
4051 const wxPoint ptOrigin = CalcUnscrolledPosition(wxPoint(0, 0));
4052
4053 // erase the last line we drew
4054 wxClientDC dc(m_gridWin);
4055 PrepareDC(dc);
4056 dc.SetLogicalFunction(wxINVERT);
4057
4058 const int posLineStart = oper.Select(ptOrigin);
4059 const int posLineEnd = oper.Select(ptOrigin) + oper.Select(size);
4060
4061 oper.DrawParallelLine(dc, posLineStart, posLineEnd, m_dragLastPos);
4062
4063 // temporarily hide the edit control before resizing
4064 HideCellEditControl();
4065 SaveEditControlValue();
4066
4067 // do resize the line
4068 const int lineStart = oper.GetLineStartPos(this, m_dragRowOrCol);
4069 const int lineSizeOld = oper.GetLineSize(this, m_dragRowOrCol);
4070 oper.SetLineSize(this, m_dragRowOrCol,
4071 wxMax(m_dragLastPos - lineStart,
4072 oper.GetMinimalLineSize(this, m_dragRowOrCol)));
4073 const bool
4074 sizeChanged = oper.GetLineSize(this, m_dragRowOrCol) != lineSizeOld;
4075
4076 m_dragLastPos = -1;
4077
4078 // refresh now if we're not frozen
4079 if ( !GetBatchCount() )
4080 {
4081 // we need to refresh everything beyond the resized line in the header
4082 // window
4083
4084 // get the position from which to refresh in the other direction
4085 wxRect rect(CellToRect(oper.MakeCoords(m_dragRowOrCol, 0)));
4086 rect.SetPosition(CalcScrolledPosition(rect.GetPosition()));
4087
4088 // we only need the ordinate (for rows) or abscissa (for columns) here,
4089 // and need to cover the entire window in the other direction
4090 oper.Select(rect) = 0;
4091
4092 wxRect rectHeader(rect.GetPosition(),
4093 oper.MakeSize
4094 (
4095 oper.GetHeaderWindowSize(this),
4096 doper.Select(size) - doper.Select(rect)
4097 ));
4098
4099 oper.GetHeaderWindow(this)->Refresh(true, &rectHeader);
4100
4101
4102 // also refresh the grid window: extend the rectangle
4103 if ( m_table )
4104 {
4105 oper.SelectSize(rect) = oper.Select(size);
4106
4107 int subtractLines = 0;
4108 const int lineStart = doper.PosToLine(this, posLineStart);
4109 if ( lineStart >= 0 )
4110 {
4111 // ensure that if we have a multi-cell block we redraw all of
4112 // it by increasing the refresh area to cover it entirely if a
4113 // part of it is affected
4114 const int lineEnd = doper.PosToLine(this, posLineEnd, true);
4115 for ( int line = lineStart; line < lineEnd; line++ )
4116 {
4117 int cellLines = oper.Select(
4118 GetCellSize(oper.MakeCoords(m_dragRowOrCol, line)));
4119 if ( cellLines < subtractLines )
4120 subtractLines = cellLines;
4121 }
4122 }
4123
4124 int startPos =
4125 oper.GetLineStartPos(this, m_dragRowOrCol + subtractLines);
4126 startPos = doper.CalcScrolledPosition(this, startPos);
4127
4128 doper.Select(rect) = startPos;
4129 doper.SelectSize(rect) = doper.Select(size) - startPos;
4130
4131 m_gridWin->Refresh(false, &rect);
4132 }
4133 }
4134
4135 // show the edit control back again
4136 ShowCellEditControl();
4137
4138 return sizeChanged;
4139 }
4140
4141 void wxGrid::DoEndDragResizeRow(const wxMouseEvent& event)
4142 {
4143 // TODO: generate RESIZING event, see #10754
4144
4145 if ( DoEndDragResizeLine(wxGridRowOperations()) )
4146 SendGridSizeEvent(wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event);
4147 }
4148
4149 void wxGrid::DoEndDragResizeCol(const wxMouseEvent& event)
4150 {
4151 // TODO: generate RESIZING event, see #10754
4152
4153 if ( DoEndDragResizeLine(wxGridColumnOperations()) )
4154 SendGridSizeEvent(wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event);
4155 }
4156
4157 void wxGrid::DoStartMoveCol(int col)
4158 {
4159 m_dragRowOrCol = col;
4160 }
4161
4162 void wxGrid::DoEndMoveCol(int pos)
4163 {
4164 wxASSERT_MSG( m_dragRowOrCol != -1, "no matching DoStartMoveCol?" );
4165
4166 if ( SendEvent(wxEVT_GRID_COL_MOVE, -1, m_dragRowOrCol) != -1 )
4167 SetColPos(m_dragRowOrCol, pos);
4168 //else: vetoed by user
4169
4170 m_dragRowOrCol = -1;
4171 }
4172
4173 void wxGrid::RefreshAfterColPosChange()
4174 {
4175 // recalculate the column rights as the column positions have changed,
4176 // unless we calculate them dynamically because all columns widths are the
4177 // same and it's easy to do
4178 if ( !m_colWidths.empty() )
4179 {
4180 int colRight = 0;
4181 for ( int colPos = 0; colPos < m_numCols; colPos++ )
4182 {
4183 int colID = GetColAt( colPos );
4184
4185 colRight += m_colWidths[colID];
4186 m_colRights[colID] = colRight;
4187 }
4188 }
4189
4190 // and make the changes visible
4191 if ( m_useNativeHeader )
4192 {
4193 if ( m_colAt.empty() )
4194 GetGridColHeader()->ResetColumnsOrder();
4195 else
4196 GetGridColHeader()->SetColumnsOrder(m_colAt);
4197 }
4198 else
4199 {
4200 m_colWindow->Refresh();
4201 }
4202 m_gridWin->Refresh();
4203 }
4204
4205 void wxGrid::SetColumnsOrder(const wxArrayInt& order)
4206 {
4207 m_colAt = order;
4208
4209 RefreshAfterColPosChange();
4210 }
4211
4212 void wxGrid::SetColPos(int idx, int pos)
4213 {
4214 // we're going to need m_colAt now, initialize it if needed
4215 if ( m_colAt.empty() )
4216 {
4217 m_colAt.reserve(m_numCols);
4218 for ( int i = 0; i < m_numCols; i++ )
4219 m_colAt.push_back(i);
4220 }
4221
4222 wxHeaderCtrl::MoveColumnInOrderArray(m_colAt, idx, pos);
4223
4224 RefreshAfterColPosChange();
4225 }
4226
4227 void wxGrid::ResetColPos()
4228 {
4229 m_colAt.clear();
4230
4231 RefreshAfterColPosChange();
4232 }
4233
4234 void wxGrid::EnableDragColMove( bool enable )
4235 {
4236 if ( m_canDragColMove == enable )
4237 return;
4238
4239 if ( m_useNativeHeader )
4240 {
4241 // update all columns to make them [not] reorderable
4242 GetGridColHeader()->SetColumnCount(m_numCols);
4243 }
4244
4245 m_canDragColMove = enable;
4246
4247 // we use to call ResetColPos() from here if !enable but this doesn't seem
4248 // right as it would mean there would be no way to "freeze" the current
4249 // columns order by disabling moving them after putting them in the desired
4250 // order, whereas now you can always call ResetColPos() manually if needed
4251 }
4252
4253
4254 //
4255 // ------ interaction with data model
4256 //
4257 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
4258 {
4259 switch ( msg.GetId() )
4260 {
4261 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
4262 return GetModelValues();
4263
4264 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
4265 return SetModelValues();
4266
4267 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4268 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4269 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4270 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4271 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4272 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4273 return Redimension( msg );
4274
4275 default:
4276 return false;
4277 }
4278 }
4279
4280 // The behaviour of this function depends on the grid table class
4281 // Clear() function. For the default wxGridStringTable class the
4282 // behaviour is to replace all cell contents with wxEmptyString but
4283 // not to change the number of rows or cols.
4284 //
4285 void wxGrid::ClearGrid()
4286 {
4287 if ( m_table )
4288 {
4289 if (IsCellEditControlEnabled())
4290 DisableCellEditControl();
4291
4292 m_table->Clear();
4293 if (!GetBatchCount())
4294 m_gridWin->Refresh();
4295 }
4296 }
4297
4298 bool
4299 wxGrid::DoModifyLines(bool (wxGridTableBase::*funcModify)(size_t, size_t),
4300 int pos, int num, bool WXUNUSED(updateLabels) )
4301 {
4302 wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
4303
4304 if ( !m_table )
4305 return false;
4306
4307 if ( IsCellEditControlEnabled() )
4308 DisableCellEditControl();
4309
4310 return (m_table->*funcModify)(pos, num);
4311
4312 // the table will have sent the results of the insert row
4313 // operation to this view object as a grid table message
4314 }
4315
4316 bool
4317 wxGrid::DoAppendLines(bool (wxGridTableBase::*funcAppend)(size_t),
4318 int num, bool WXUNUSED(updateLabels))
4319 {
4320 wxCHECK_MSG( m_created, false, "must finish creating the grid first" );
4321
4322 if ( !m_table )
4323 return false;
4324
4325 return (m_table->*funcAppend)(num);
4326 }
4327
4328 // ----------------------------------------------------------------------------
4329 // event generation helpers
4330 // ----------------------------------------------------------------------------
4331
4332 void
4333 wxGrid::SendGridSizeEvent(wxEventType type,
4334 int row, int col,
4335 const wxMouseEvent& mouseEv)
4336 {
4337 int rowOrCol = row == -1 ? col : row;
4338
4339 wxGridSizeEvent gridEvt( GetId(),
4340 type,
4341 this,
4342 rowOrCol,
4343 mouseEv.GetX() + GetRowLabelSize(),
4344 mouseEv.GetY() + GetColLabelSize(),
4345 mouseEv);
4346
4347 GetEventHandler()->ProcessEvent(gridEvt);
4348 }
4349
4350 // Generate a grid event based on a mouse event and return:
4351 // -1 if the event was vetoed
4352 // +1 if the event was processed (but not vetoed)
4353 // 0 if the event wasn't handled
4354 int
4355 wxGrid::SendEvent(const wxEventType type,
4356 int row, int col,
4357 const wxMouseEvent& mouseEv)
4358 {
4359 bool claimed, vetoed;
4360
4361 if ( type == wxEVT_GRID_RANGE_SELECT )
4362 {
4363 // Right now, it should _never_ end up here!
4364 wxGridRangeSelectEvent gridEvt( GetId(),
4365 type,
4366 this,
4367 m_selectedBlockTopLeft,
4368 m_selectedBlockBottomRight,
4369 true,
4370 mouseEv);
4371
4372 claimed = GetEventHandler()->ProcessEvent(gridEvt);
4373 vetoed = !gridEvt.IsAllowed();
4374 }
4375 else if ( type == wxEVT_GRID_LABEL_LEFT_CLICK ||
4376 type == wxEVT_GRID_LABEL_LEFT_DCLICK ||
4377 type == wxEVT_GRID_LABEL_RIGHT_CLICK ||
4378 type == wxEVT_GRID_LABEL_RIGHT_DCLICK )
4379 {
4380 wxPoint pos = mouseEv.GetPosition();
4381
4382 if ( mouseEv.GetEventObject() == GetGridRowLabelWindow() )
4383 pos.y += GetColLabelSize();
4384 if ( mouseEv.GetEventObject() == GetGridColLabelWindow() )
4385 pos.x += GetRowLabelSize();
4386
4387 wxGridEvent gridEvt( GetId(),
4388 type,
4389 this,
4390 row, col,
4391 pos.x,
4392 pos.y,
4393 false,
4394 mouseEv);
4395 claimed = GetEventHandler()->ProcessEvent(gridEvt);
4396 vetoed = !gridEvt.IsAllowed();
4397 }
4398 else
4399 {
4400 wxGridEvent gridEvt( GetId(),
4401 type,
4402 this,
4403 row, col,
4404 mouseEv.GetX() + GetRowLabelSize(),
4405 mouseEv.GetY() + GetColLabelSize(),
4406 false,
4407 mouseEv);
4408
4409 if ( type == wxEVT_GRID_CELL_BEGIN_DRAG )
4410 {
4411 // by default the dragging is not supported, the user code must
4412 // explicitly allow the event for it to take place
4413 gridEvt.Veto();
4414 }
4415
4416 claimed = GetEventHandler()->ProcessEvent(gridEvt);
4417 vetoed = !gridEvt.IsAllowed();
4418 }
4419
4420 // A Veto'd event may not be `claimed' so test this first
4421 if (vetoed)
4422 return -1;
4423
4424 return claimed ? 1 : 0;
4425 }
4426
4427 // Generate a grid event of specified type, return value same as above
4428 //
4429 int
4430 wxGrid::SendEvent(const wxEventType type, int row, int col, const wxString& s)
4431 {
4432 wxGridEvent gridEvt( GetId(), type, this, row, col );
4433 gridEvt.SetString(s);
4434
4435 const bool claimed = GetEventHandler()->ProcessEvent(gridEvt);
4436
4437 // A Veto'd event may not be `claimed' so test this first
4438 if ( !gridEvt.IsAllowed() )
4439 return -1;
4440
4441 return claimed ? 1 : 0;
4442 }
4443
4444 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
4445 {
4446 // needed to prevent zillions of paint events on MSW
4447 wxPaintDC dc(this);
4448 }
4449
4450 void wxGrid::Refresh(bool eraseb, const wxRect* rect)
4451 {
4452 // Don't do anything if between Begin/EndBatch...
4453 // EndBatch() will do all this on the last nested one anyway.
4454 if ( m_created && !GetBatchCount() )
4455 {
4456 // Refresh to get correct scrolled position:
4457 wxScrolledWindow::Refresh(eraseb, rect);
4458
4459 if (rect)
4460 {
4461 int rect_x, rect_y, rectWidth, rectHeight;
4462 int width_label, width_cell, height_label, height_cell;
4463 int x, y;
4464
4465 // Copy rectangle can get scroll offsets..
4466 rect_x = rect->GetX();
4467 rect_y = rect->GetY();
4468 rectWidth = rect->GetWidth();
4469 rectHeight = rect->GetHeight();
4470
4471 width_label = m_rowLabelWidth - rect_x;
4472 if (width_label > rectWidth)
4473 width_label = rectWidth;
4474
4475 height_label = m_colLabelHeight - rect_y;
4476 if (height_label > rectHeight)
4477 height_label = rectHeight;
4478
4479 if (rect_x > m_rowLabelWidth)
4480 {
4481 x = rect_x - m_rowLabelWidth;
4482 width_cell = rectWidth;
4483 }
4484 else
4485 {
4486 x = 0;
4487 width_cell = rectWidth - (m_rowLabelWidth - rect_x);
4488 }
4489
4490 if (rect_y > m_colLabelHeight)
4491 {
4492 y = rect_y - m_colLabelHeight;
4493 height_cell = rectHeight;
4494 }
4495 else
4496 {
4497 y = 0;
4498 height_cell = rectHeight - (m_colLabelHeight - rect_y);
4499 }
4500
4501 // Paint corner label part intersecting rect.
4502 if ( width_label > 0 && height_label > 0 )
4503 {
4504 wxRect anotherrect(rect_x, rect_y, width_label, height_label);
4505 m_cornerLabelWin->Refresh(eraseb, &anotherrect);
4506 }
4507
4508 // Paint col labels part intersecting rect.
4509 if ( width_cell > 0 && height_label > 0 )
4510 {
4511 wxRect anotherrect(x, rect_y, width_cell, height_label);
4512 m_colWindow->Refresh(eraseb, &anotherrect);
4513 }
4514
4515 // Paint row labels part intersecting rect.
4516 if ( width_label > 0 && height_cell > 0 )
4517 {
4518 wxRect anotherrect(rect_x, y, width_label, height_cell);
4519 m_rowLabelWin->Refresh(eraseb, &anotherrect);
4520 }
4521
4522 // Paint cell area part intersecting rect.
4523 if ( width_cell > 0 && height_cell > 0 )
4524 {
4525 wxRect anotherrect(x, y, width_cell, height_cell);
4526 m_gridWin->Refresh(eraseb, &anotherrect);
4527 }
4528 }
4529 else
4530 {
4531 m_cornerLabelWin->Refresh(eraseb, NULL);
4532 m_colWindow->Refresh(eraseb, NULL);
4533 m_rowLabelWin->Refresh(eraseb, NULL);
4534 m_gridWin->Refresh(eraseb, NULL);
4535 }
4536 }
4537 }
4538
4539 void wxGrid::OnSize(wxSizeEvent& WXUNUSED(event))
4540 {
4541 if (m_targetWindow != this) // check whether initialisation has been done
4542 {
4543 // reposition our children windows
4544 CalcWindowSizes();
4545 }
4546 }
4547
4548 void wxGrid::OnKeyDown( wxKeyEvent& event )
4549 {
4550 if ( m_inOnKeyDown )
4551 {
4552 // shouldn't be here - we are going round in circles...
4553 //
4554 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
4555 }
4556
4557 m_inOnKeyDown = true;
4558
4559 // propagate the event up and see if it gets processed
4560 wxWindow *parent = GetParent();
4561 wxKeyEvent keyEvt( event );
4562 keyEvt.SetEventObject( parent );
4563
4564 if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
4565 {
4566 if (GetLayoutDirection() == wxLayout_RightToLeft)
4567 {
4568 if (event.GetKeyCode() == WXK_RIGHT)
4569 event.m_keyCode = WXK_LEFT;
4570 else if (event.GetKeyCode() == WXK_LEFT)
4571 event.m_keyCode = WXK_RIGHT;
4572 }
4573
4574 // try local handlers
4575 switch ( event.GetKeyCode() )
4576 {
4577 case WXK_UP:
4578 if ( event.ControlDown() )
4579 MoveCursorUpBlock( event.ShiftDown() );
4580 else
4581 MoveCursorUp( event.ShiftDown() );
4582 break;
4583
4584 case WXK_DOWN:
4585 if ( event.ControlDown() )
4586 MoveCursorDownBlock( event.ShiftDown() );
4587 else
4588 MoveCursorDown( event.ShiftDown() );
4589 break;
4590
4591 case WXK_LEFT:
4592 if ( event.ControlDown() )
4593 MoveCursorLeftBlock( event.ShiftDown() );
4594 else
4595 MoveCursorLeft( event.ShiftDown() );
4596 break;
4597
4598 case WXK_RIGHT:
4599 if ( event.ControlDown() )
4600 MoveCursorRightBlock( event.ShiftDown() );
4601 else
4602 MoveCursorRight( event.ShiftDown() );
4603 break;
4604
4605 case WXK_RETURN:
4606 case WXK_NUMPAD_ENTER:
4607 if ( event.ControlDown() )
4608 {
4609 event.Skip(); // to let the edit control have the return
4610 }
4611 else
4612 {
4613 if ( GetGridCursorRow() < GetNumberRows()-1 )
4614 {
4615 MoveCursorDown( event.ShiftDown() );
4616 }
4617 else
4618 {
4619 // at the bottom of a column
4620 DisableCellEditControl();
4621 }
4622 }
4623 break;
4624
4625 case WXK_ESCAPE:
4626 ClearSelection();
4627 break;
4628
4629 case WXK_TAB:
4630 if (event.ShiftDown())
4631 {
4632 if ( GetGridCursorCol() > 0 )
4633 {
4634 MoveCursorLeft( false );
4635 }
4636 else
4637 {
4638 // at left of grid
4639 DisableCellEditControl();
4640 }
4641 }
4642 else
4643 {
4644 if ( GetGridCursorCol() < GetNumberCols() - 1 )
4645 {
4646 MoveCursorRight( false );
4647 }
4648 else
4649 {
4650 // at right of grid
4651 DisableCellEditControl();
4652 }
4653 }
4654 break;
4655
4656 case WXK_HOME:
4657 GoToCell(event.ControlDown() ? 0
4658 : m_currentCellCoords.GetRow(),
4659 0);
4660 break;
4661
4662 case WXK_END:
4663 GoToCell(event.ControlDown() ? m_numRows - 1
4664 : m_currentCellCoords.GetRow(),
4665 m_numCols - 1);
4666 break;
4667
4668 case WXK_PAGEUP:
4669 MovePageUp();
4670 break;
4671
4672 case WXK_PAGEDOWN:
4673 MovePageDown();
4674 break;
4675
4676 case WXK_SPACE:
4677 // Ctrl-Space selects the current column, Shift-Space -- the
4678 // current row and Ctrl-Shift-Space -- everything
4679 switch ( m_selection ? event.GetModifiers() : wxMOD_NONE )
4680 {
4681 case wxMOD_CONTROL:
4682 m_selection->SelectCol(m_currentCellCoords.GetCol());
4683 break;
4684
4685 case wxMOD_SHIFT:
4686 m_selection->SelectRow(m_currentCellCoords.GetRow());
4687 break;
4688
4689 case wxMOD_CONTROL | wxMOD_SHIFT:
4690 m_selection->SelectBlock(0, 0,
4691 m_numRows - 1, m_numCols - 1);
4692 break;
4693
4694 case wxMOD_NONE:
4695 if ( !IsEditable() )
4696 {
4697 MoveCursorRight(false);
4698 break;
4699 }
4700 //else: fall through
4701
4702 default:
4703 event.Skip();
4704 }
4705 break;
4706
4707 default:
4708 event.Skip();
4709 break;
4710 }
4711 }
4712
4713 m_inOnKeyDown = false;
4714 }
4715
4716 void wxGrid::OnKeyUp( wxKeyEvent& event )
4717 {
4718 // try local handlers
4719 //
4720 if ( event.GetKeyCode() == WXK_SHIFT )
4721 {
4722 if ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
4723 m_selectedBlockBottomRight != wxGridNoCellCoords )
4724 {
4725 if ( m_selection )
4726 {
4727 m_selection->SelectBlock(
4728 m_selectedBlockTopLeft,
4729 m_selectedBlockBottomRight,
4730 event);
4731 }
4732 }
4733
4734 m_selectedBlockTopLeft = wxGridNoCellCoords;
4735 m_selectedBlockBottomRight = wxGridNoCellCoords;
4736 m_selectedBlockCorner = wxGridNoCellCoords;
4737 }
4738 }
4739
4740 void wxGrid::OnChar( wxKeyEvent& event )
4741 {
4742 // is it possible to edit the current cell at all?
4743 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
4744 {
4745 // yes, now check whether the cells editor accepts the key
4746 int row = m_currentCellCoords.GetRow();
4747 int col = m_currentCellCoords.GetCol();
4748 wxGridCellAttr *attr = GetCellAttr(row, col);
4749 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
4750
4751 // <F2> is special and will always start editing, for
4752 // other keys - ask the editor itself
4753 if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
4754 || editor->IsAcceptedKey(event) )
4755 {
4756 // ensure cell is visble
4757 MakeCellVisible(row, col);
4758 EnableCellEditControl();
4759
4760 // a problem can arise if the cell is not completely
4761 // visible (even after calling MakeCellVisible the
4762 // control is not created and calling StartingKey will
4763 // crash the app
4764 if ( event.GetKeyCode() != WXK_F2 && editor->IsCreated() && m_cellEditCtrlEnabled )
4765 editor->StartingKey(event);
4766 }
4767 else
4768 {
4769 event.Skip();
4770 }
4771
4772 editor->DecRef();
4773 attr->DecRef();
4774 }
4775 else
4776 {
4777 event.Skip();
4778 }
4779 }
4780
4781 void wxGrid::OnEraseBackground(wxEraseEvent&)
4782 {
4783 }
4784
4785 bool wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
4786 {
4787 if ( SendEvent(wxEVT_GRID_SELECT_CELL, coords) == -1 )
4788 {
4789 // the event has been vetoed - do nothing
4790 return false;
4791 }
4792
4793 #if !defined(__WXMAC__)
4794 wxClientDC dc( m_gridWin );
4795 PrepareDC( dc );
4796 #endif
4797
4798 if ( m_currentCellCoords != wxGridNoCellCoords )
4799 {
4800 DisableCellEditControl();
4801
4802 if ( IsVisible( m_currentCellCoords, false ) )
4803 {
4804 wxRect r;
4805 r = BlockToDeviceRect( m_currentCellCoords, m_currentCellCoords );
4806 if ( !m_gridLinesEnabled )
4807 {
4808 r.x--;
4809 r.y--;
4810 r.width++;
4811 r.height++;
4812 }
4813
4814 wxGridCellCoordsArray cells = CalcCellsExposed( r );
4815
4816 // Otherwise refresh redraws the highlight!
4817 m_currentCellCoords = coords;
4818
4819 #if defined(__WXMAC__)
4820 m_gridWin->Refresh(true /*, & r */);
4821 #else
4822 DrawGridCellArea( dc, cells );
4823 DrawAllGridLines( dc, r );
4824 #endif
4825 }
4826 }
4827
4828 m_currentCellCoords = coords;
4829
4830 wxGridCellAttr *attr = GetCellAttr( coords );
4831 #if !defined(__WXMAC__)
4832 DrawCellHighlight( dc, attr );
4833 #endif
4834 attr->DecRef();
4835
4836 return true;
4837 }
4838
4839 void
4840 wxGrid::UpdateBlockBeingSelected(int topRow, int leftCol,
4841 int bottomRow, int rightCol)
4842 {
4843 MakeCellVisible(m_selectedBlockCorner);
4844 m_selectedBlockCorner = wxGridCellCoords(bottomRow, rightCol);
4845
4846 if ( m_selection )
4847 {
4848 switch ( m_selection->GetSelectionMode() )
4849 {
4850 default:
4851 wxFAIL_MSG( "unknown selection mode" );
4852 // fall through
4853
4854 case wxGridSelectCells:
4855 // arbitrary blocks selection allowed so just use the cell
4856 // coordinates as is
4857 break;
4858
4859 case wxGridSelectRows:
4860 // only full rows selection allowd, ensure that we do select
4861 // full rows
4862 leftCol = 0;
4863 rightCol = GetNumberCols() - 1;
4864 break;
4865
4866 case wxGridSelectColumns:
4867 // same as above but for columns
4868 topRow = 0;
4869 bottomRow = GetNumberRows() - 1;
4870 break;
4871
4872 case wxGridSelectRowsOrColumns:
4873 // in this mode we can select only full rows or full columns so
4874 // it doesn't make sense to select blocks at all (and we can't
4875 // extend the block because there is no preferred direction, we
4876 // could only extend it to cover the entire grid but this is
4877 // not useful)
4878 return;
4879 }
4880 }
4881
4882 EnsureFirstLessThanSecond(topRow, bottomRow);
4883 EnsureFirstLessThanSecond(leftCol, rightCol);
4884
4885 wxGridCellCoords updateTopLeft = wxGridCellCoords(topRow, leftCol),
4886 updateBottomRight = wxGridCellCoords(bottomRow, rightCol);
4887
4888 // First the case that we selected a completely new area
4889 if ( m_selectedBlockTopLeft == wxGridNoCellCoords ||
4890 m_selectedBlockBottomRight == wxGridNoCellCoords )
4891 {
4892 wxRect rect;
4893 rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
4894 wxGridCellCoords ( bottomRow, rightCol ) );
4895 m_gridWin->Refresh( false, &rect );
4896 }
4897
4898 // Now handle changing an existing selection area.
4899 else if ( m_selectedBlockTopLeft != updateTopLeft ||
4900 m_selectedBlockBottomRight != updateBottomRight )
4901 {
4902 // Compute two optimal update rectangles:
4903 // Either one rectangle is a real subset of the
4904 // other, or they are (almost) disjoint!
4905 wxRect rect[4];
4906 bool need_refresh[4];
4907 need_refresh[0] =
4908 need_refresh[1] =
4909 need_refresh[2] =
4910 need_refresh[3] = false;
4911 int i;
4912
4913 // Store intermediate values
4914 wxCoord oldLeft = m_selectedBlockTopLeft.GetCol();
4915 wxCoord oldTop = m_selectedBlockTopLeft.GetRow();
4916 wxCoord oldRight = m_selectedBlockBottomRight.GetCol();
4917 wxCoord oldBottom = m_selectedBlockBottomRight.GetRow();
4918
4919 // Determine the outer/inner coordinates.
4920 EnsureFirstLessThanSecond(oldLeft, leftCol);
4921 EnsureFirstLessThanSecond(oldTop, topRow);
4922 EnsureFirstLessThanSecond(rightCol, oldRight);
4923 EnsureFirstLessThanSecond(bottomRow, oldBottom);
4924
4925 // Now, either the stuff marked old is the outer
4926 // rectangle or we don't have a situation where one
4927 // is contained in the other.
4928
4929 if ( oldLeft < leftCol )
4930 {
4931 // Refresh the newly selected or deselected
4932 // area to the left of the old or new selection.
4933 need_refresh[0] = true;
4934 rect[0] = BlockToDeviceRect(
4935 wxGridCellCoords( oldTop, oldLeft ),
4936 wxGridCellCoords( oldBottom, leftCol - 1 ) );
4937 }
4938
4939 if ( oldTop < topRow )
4940 {
4941 // Refresh the newly selected or deselected
4942 // area above the old or new selection.
4943 need_refresh[1] = true;
4944 rect[1] = BlockToDeviceRect(
4945 wxGridCellCoords( oldTop, leftCol ),
4946 wxGridCellCoords( topRow - 1, rightCol ) );
4947 }
4948
4949 if ( oldRight > rightCol )
4950 {
4951 // Refresh the newly selected or deselected
4952 // area to the right of the old or new selection.
4953 need_refresh[2] = true;
4954 rect[2] = BlockToDeviceRect(
4955 wxGridCellCoords( oldTop, rightCol + 1 ),
4956 wxGridCellCoords( oldBottom, oldRight ) );
4957 }
4958
4959 if ( oldBottom > bottomRow )
4960 {
4961 // Refresh the newly selected or deselected
4962 // area below the old or new selection.
4963 need_refresh[3] = true;
4964 rect[3] = BlockToDeviceRect(
4965 wxGridCellCoords( bottomRow + 1, leftCol ),
4966 wxGridCellCoords( oldBottom, rightCol ) );
4967 }
4968
4969 // various Refresh() calls
4970 for (i = 0; i < 4; i++ )
4971 if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
4972 m_gridWin->Refresh( false, &(rect[i]) );
4973 }
4974
4975 // change selection
4976 m_selectedBlockTopLeft = updateTopLeft;
4977 m_selectedBlockBottomRight = updateBottomRight;
4978 }
4979
4980 //
4981 // ------ functions to get/send data (see also public functions)
4982 //
4983
4984 bool wxGrid::GetModelValues()
4985 {
4986 // Hide the editor, so it won't hide a changed value.
4987 HideCellEditControl();
4988
4989 if ( m_table )
4990 {
4991 // all we need to do is repaint the grid
4992 //
4993 m_gridWin->Refresh();
4994 return true;
4995 }
4996
4997 return false;
4998 }
4999
5000 bool wxGrid::SetModelValues()
5001 {
5002 int row, col;
5003
5004 // Disable the editor, so it won't hide a changed value.
5005 // Do we also want to save the current value of the editor first?
5006 // I think so ...
5007 DisableCellEditControl();
5008
5009 if ( m_table )
5010 {
5011 for ( row = 0; row < m_numRows; row++ )
5012 {
5013 for ( col = 0; col < m_numCols; col++ )
5014 {
5015 m_table->SetValue( row, col, GetCellValue(row, col) );
5016 }
5017 }
5018
5019 return true;
5020 }
5021
5022 return false;
5023 }
5024
5025 // Note - this function only draws cells that are in the list of
5026 // exposed cells (usually set from the update region by
5027 // CalcExposedCells)
5028 //
5029 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
5030 {
5031 if ( !m_numRows || !m_numCols )
5032 return;
5033
5034 int i, numCells = cells.GetCount();
5035 int row, col, cell_rows, cell_cols;
5036 wxGridCellCoordsArray redrawCells;
5037
5038 for ( i = numCells - 1; i >= 0; i-- )
5039 {
5040 row = cells[i].GetRow();
5041 col = cells[i].GetCol();
5042 GetCellSize( row, col, &cell_rows, &cell_cols );
5043
5044 // If this cell is part of a multicell block, find owner for repaint
5045 if ( cell_rows <= 0 || cell_cols <= 0 )
5046 {
5047 wxGridCellCoords cell( row + cell_rows, col + cell_cols );
5048 bool marked = false;
5049 for ( int j = 0; j < numCells; j++ )
5050 {
5051 if ( cell == cells[j] )
5052 {
5053 marked = true;
5054 break;
5055 }
5056 }
5057
5058 if (!marked)
5059 {
5060 int count = redrawCells.GetCount();
5061 for (int j = 0; j < count; j++)
5062 {
5063 if ( cell == redrawCells[j] )
5064 {
5065 marked = true;
5066 break;
5067 }
5068 }
5069
5070 if (!marked)
5071 redrawCells.Add( cell );
5072 }
5073
5074 // don't bother drawing this cell
5075 continue;
5076 }
5077
5078 // If this cell is empty, find cell to left that might want to overflow
5079 if (m_table && m_table->IsEmptyCell(row, col))
5080 {
5081 for ( int l = 0; l < cell_rows; l++ )
5082 {
5083 // find a cell in this row to leave already marked for repaint
5084 int left = col;
5085 for (int k = 0; k < int(redrawCells.GetCount()); k++)
5086 if ((redrawCells[k].GetCol() < left) &&
5087 (redrawCells[k].GetRow() == row))
5088 {
5089 left = redrawCells[k].GetCol();
5090 }
5091
5092 if (left == col)
5093 left = 0; // oh well
5094
5095 for (int j = col - 1; j >= left; j--)
5096 {
5097 if (!m_table->IsEmptyCell(row + l, j))
5098 {
5099 if (GetCellOverflow(row + l, j))
5100 {
5101 wxGridCellCoords cell(row + l, j);
5102 bool marked = false;
5103
5104 for (int k = 0; k < numCells; k++)
5105 {
5106 if ( cell == cells[k] )
5107 {
5108 marked = true;
5109 break;
5110 }
5111 }
5112
5113 if (!marked)
5114 {
5115 int count = redrawCells.GetCount();
5116 for (int k = 0; k < count; k++)
5117 {
5118 if ( cell == redrawCells[k] )
5119 {
5120 marked = true;
5121 break;
5122 }
5123 }
5124 if (!marked)
5125 redrawCells.Add( cell );
5126 }
5127 }
5128 break;
5129 }
5130 }
5131 }
5132 }
5133
5134 DrawCell( dc, cells[i] );
5135 }
5136
5137 numCells = redrawCells.GetCount();
5138
5139 for ( i = numCells - 1; i >= 0; i-- )
5140 {
5141 DrawCell( dc, redrawCells[i] );
5142 }
5143 }
5144
5145 void wxGrid::DrawGridSpace( wxDC& dc )
5146 {
5147 int cw, ch;
5148 m_gridWin->GetClientSize( &cw, &ch );
5149
5150 int right, bottom;
5151 CalcUnscrolledPosition( cw, ch, &right, &bottom );
5152
5153 int rightCol = m_numCols > 0 ? GetColRight(GetColAt( m_numCols - 1 )) : 0;
5154 int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0;
5155
5156 if ( right > rightCol || bottom > bottomRow )
5157 {
5158 int left, top;
5159 CalcUnscrolledPosition( 0, 0, &left, &top );
5160
5161 dc.SetBrush(GetDefaultCellBackgroundColour());
5162 dc.SetPen( *wxTRANSPARENT_PEN );
5163
5164 if ( right > rightCol )
5165 {
5166 dc.DrawRectangle( rightCol, top, right - rightCol, ch );
5167 }
5168
5169 if ( bottom > bottomRow )
5170 {
5171 dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow );
5172 }
5173 }
5174 }
5175
5176 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
5177 {
5178 int row = coords.GetRow();
5179 int col = coords.GetCol();
5180
5181 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5182 return;
5183
5184 // we draw the cell border ourselves
5185 wxGridCellAttr* attr = GetCellAttr(row, col);
5186
5187 bool isCurrent = coords == m_currentCellCoords;
5188
5189 wxRect rect = CellToRect( row, col );
5190
5191 // if the editor is shown, we should use it and not the renderer
5192 // Note: However, only if it is really _shown_, i.e. not hidden!
5193 if ( isCurrent && IsCellEditControlShown() )
5194 {
5195 // NB: this "#if..." is temporary and fixes a problem where the
5196 // edit control is erased by this code after being rendered.
5197 // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
5198 // implicitly, causing this out-of order render.
5199 #if !defined(__WXMAC__)
5200 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
5201 editor->PaintBackground(rect, attr);
5202 editor->DecRef();
5203 #endif
5204 }
5205 else
5206 {
5207 // but all the rest is drawn by the cell renderer and hence may be customized
5208 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
5209 renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
5210 renderer->DecRef();
5211 }
5212
5213 attr->DecRef();
5214 }
5215
5216 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
5217 {
5218 // don't show highlight when the grid doesn't have focus
5219 if ( !HasFocus() )
5220 return;
5221
5222 int row = m_currentCellCoords.GetRow();
5223 int col = m_currentCellCoords.GetCol();
5224
5225 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5226 return;
5227
5228 wxRect rect = CellToRect(row, col);
5229
5230 // hmmm... what could we do here to show that the cell is disabled?
5231 // for now, I just draw a thinner border than for the other ones, but
5232 // it doesn't look really good
5233
5234 int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
5235
5236 if (penWidth > 0)
5237 {
5238 // The center of the drawn line is where the position/width/height of
5239 // the rectangle is actually at (on wxMSW at least), so the
5240 // size of the rectangle is reduced to compensate for the thickness of
5241 // the line. If this is too strange on non-wxMSW platforms then
5242 // please #ifdef this appropriately.
5243 rect.x += penWidth / 2;
5244 rect.y += penWidth / 2;
5245 rect.width -= penWidth - 1;
5246 rect.height -= penWidth - 1;
5247
5248 // Now draw the rectangle
5249 // use the cellHighlightColour if the cell is inside a selection, this
5250 // will ensure the cell is always visible.
5251 dc.SetPen(wxPen(IsInSelection(row,col) ? m_selectionForeground
5252 : m_cellHighlightColour,
5253 penWidth));
5254 dc.SetBrush(*wxTRANSPARENT_BRUSH);
5255 dc.DrawRectangle(rect);
5256 }
5257 }
5258
5259 wxPen wxGrid::GetDefaultGridLinePen()
5260 {
5261 return wxPen(GetGridLineColour());
5262 }
5263
5264 wxPen wxGrid::GetRowGridLinePen(int WXUNUSED(row))
5265 {
5266 return GetDefaultGridLinePen();
5267 }
5268
5269 wxPen wxGrid::GetColGridLinePen(int WXUNUSED(col))
5270 {
5271 return GetDefaultGridLinePen();
5272 }
5273
5274 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
5275 {
5276 int row = coords.GetRow();
5277 int col = coords.GetCol();
5278 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
5279 return;
5280
5281
5282 wxRect rect = CellToRect( row, col );
5283
5284 // right hand border
5285 dc.SetPen( GetColGridLinePen(col) );
5286 dc.DrawLine( rect.x + rect.width, rect.y,
5287 rect.x + rect.width, rect.y + rect.height + 1 );
5288
5289 // bottom border
5290 dc.SetPen( GetRowGridLinePen(row) );
5291 dc.DrawLine( rect.x, rect.y + rect.height,
5292 rect.x + rect.width, rect.y + rect.height);
5293 }
5294
5295 void wxGrid::DrawHighlight(wxDC& dc, const wxGridCellCoordsArray& cells)
5296 {
5297 // This if block was previously in wxGrid::OnPaint but that doesn't
5298 // seem to get called under wxGTK - MB
5299 //
5300 if ( m_currentCellCoords == wxGridNoCellCoords &&
5301 m_numRows && m_numCols )
5302 {
5303 m_currentCellCoords.Set(0, 0);
5304 }
5305
5306 if ( IsCellEditControlShown() )
5307 {
5308 // don't show highlight when the edit control is shown
5309 return;
5310 }
5311
5312 // if the active cell was repainted, repaint its highlight too because it
5313 // might have been damaged by the grid lines
5314 size_t count = cells.GetCount();
5315 for ( size_t n = 0; n < count; n++ )
5316 {
5317 wxGridCellCoords cell = cells[n];
5318
5319 // If we are using attributes, then we may have just exposed another
5320 // cell in a partially-visible merged cluster of cells. If the "anchor"
5321 // (upper left) cell of this merged cluster is the cell indicated by
5322 // m_currentCellCoords, then we need to refresh the cell highlight even
5323 // though the "anchor" itself is not part of our update segment.
5324 if ( CanHaveAttributes() )
5325 {
5326 int rows = 0,
5327 cols = 0;
5328 GetCellSize(cell.GetRow(), cell.GetCol(), &rows, &cols);
5329
5330 if ( rows < 0 )
5331 cell.SetRow(cell.GetRow() + rows);
5332
5333 if ( cols < 0 )
5334 cell.SetCol(cell.GetCol() + cols);
5335 }
5336
5337 if ( cell == m_currentCellCoords )
5338 {
5339 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
5340 DrawCellHighlight(dc, attr);
5341 attr->DecRef();
5342
5343 break;
5344 }
5345 }
5346 }
5347
5348 // This is used to redraw all grid lines e.g. when the grid line colour
5349 // has been changed
5350 //
5351 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
5352 {
5353 if ( !m_gridLinesEnabled )
5354 return;
5355
5356 int top, bottom, left, right;
5357
5358 int cw, ch;
5359 m_gridWin->GetClientSize(&cw, &ch);
5360 CalcUnscrolledPosition( 0, 0, &left, &top );
5361 CalcUnscrolledPosition( cw, ch, &right, &bottom );
5362
5363 // avoid drawing grid lines past the last row and col
5364 if ( m_gridLinesClipHorz )
5365 {
5366 if ( !m_numCols )
5367 return;
5368
5369 const int lastColRight = GetColRight(GetColAt(m_numCols - 1));
5370 if ( right > lastColRight )
5371 right = lastColRight;
5372 }
5373
5374 if ( m_gridLinesClipVert )
5375 {
5376 if ( !m_numRows )
5377 return;
5378
5379 const int lastRowBottom = GetRowBottom(m_numRows - 1);
5380 if ( bottom > lastRowBottom )
5381 bottom = lastRowBottom;
5382 }
5383
5384 // no gridlines inside multicells, clip them out
5385 int leftCol = GetColPos( internalXToCol(left) );
5386 int topRow = internalYToRow(top);
5387 int rightCol = GetColPos( internalXToCol(right) );
5388 int bottomRow = internalYToRow(bottom);
5389
5390 wxRegion clippedcells(0, 0, cw, ch);
5391
5392 int cell_rows, cell_cols;
5393 wxRect rect;
5394
5395 for ( int j = topRow; j <= bottomRow; j++ )
5396 {
5397 for ( int colPos = leftCol; colPos <= rightCol; colPos++ )
5398 {
5399 int i = GetColAt( colPos );
5400
5401 GetCellSize( j, i, &cell_rows, &cell_cols );
5402 if ((cell_rows > 1) || (cell_cols > 1))
5403 {
5404 rect = CellToRect(j,i);
5405 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5406 clippedcells.Subtract(rect);
5407 }
5408 else if ((cell_rows < 0) || (cell_cols < 0))
5409 {
5410 rect = CellToRect(j + cell_rows, i + cell_cols);
5411 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5412 clippedcells.Subtract(rect);
5413 }
5414 }
5415 }
5416
5417 dc.SetDeviceClippingRegion( clippedcells );
5418
5419
5420 // horizontal grid lines
5421 for ( int i = internalYToRow(top); i < m_numRows; i++ )
5422 {
5423 int bot = GetRowBottom(i) - 1;
5424
5425 if ( bot > bottom )
5426 break;
5427
5428 if ( bot >= top )
5429 {
5430 dc.SetPen( GetRowGridLinePen(i) );
5431 dc.DrawLine( left, bot, right, bot );
5432 }
5433 }
5434
5435 // vertical grid lines
5436 for ( int colPos = leftCol; colPos < m_numCols; colPos++ )
5437 {
5438 int i = GetColAt( colPos );
5439
5440 int colRight = GetColRight(i);
5441 #ifdef __WXGTK__
5442 if (GetLayoutDirection() != wxLayout_RightToLeft)
5443 #endif
5444 colRight--;
5445
5446 if ( colRight > right )
5447 break;
5448
5449 if ( colRight >= left )
5450 {
5451 dc.SetPen( GetColGridLinePen(i) );
5452 dc.DrawLine( colRight, top, colRight, bottom );
5453 }
5454 }
5455
5456 dc.DestroyClippingRegion();
5457 }
5458
5459 void wxGrid::DrawRowLabels( wxDC& dc, const wxArrayInt& rows)
5460 {
5461 if ( !m_numRows )
5462 return;
5463
5464 const size_t numLabels = rows.GetCount();
5465 for ( size_t i = 0; i < numLabels; i++ )
5466 {
5467 DrawRowLabel( dc, rows[i] );
5468 }
5469 }
5470
5471 void wxGrid::DrawRowLabel( wxDC& dc, int row )
5472 {
5473 if ( GetRowHeight(row) <= 0 || m_rowLabelWidth <= 0 )
5474 return;
5475
5476 wxGridCellAttrProvider * const
5477 attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5478
5479 // notice that an explicit static_cast is needed to avoid a compilation
5480 // error with VC7.1 which, for some reason, tries to instantiate (abstract)
5481 // wxGridRowHeaderRenderer class without it
5482 const wxGridRowHeaderRenderer&
5483 rend = attrProvider ? attrProvider->GetRowHeaderRenderer(row)
5484 : static_cast<const wxGridRowHeaderRenderer&>
5485 (gs_defaultHeaderRenderers.rowRenderer);
5486
5487 wxRect rect(0, GetRowTop(row), m_rowLabelWidth, GetRowHeight(row));
5488 rend.DrawBorder(*this, dc, rect);
5489
5490 int hAlign, vAlign;
5491 GetRowLabelAlignment(&hAlign, &vAlign);
5492
5493 rend.DrawLabel(*this, dc, GetRowLabelValue(row),
5494 rect, hAlign, vAlign, wxHORIZONTAL);
5495 }
5496
5497 void wxGrid::UseNativeColHeader(bool native)
5498 {
5499 if ( native == m_useNativeHeader )
5500 return;
5501
5502 delete m_colWindow;
5503 m_useNativeHeader = native;
5504
5505 CreateColumnWindow();
5506
5507 if ( m_useNativeHeader )
5508 GetGridColHeader()->SetColumnCount(m_numCols);
5509 CalcWindowSizes();
5510 }
5511
5512 void wxGrid::SetUseNativeColLabels( bool native )
5513 {
5514 wxASSERT_MSG( !m_useNativeHeader,
5515 "doesn't make sense when using native header" );
5516
5517 m_nativeColumnLabels = native;
5518 if (native)
5519 {
5520 int height = wxRendererNative::Get().GetHeaderButtonHeight( this );
5521 SetColLabelSize( height );
5522 }
5523
5524 GetColLabelWindow()->Refresh();
5525 m_cornerLabelWin->Refresh();
5526 }
5527
5528 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
5529 {
5530 if ( !m_numCols )
5531 return;
5532
5533 const size_t numLabels = cols.GetCount();
5534 for ( size_t i = 0; i < numLabels; i++ )
5535 {
5536 DrawColLabel( dc, cols[i] );
5537 }
5538 }
5539
5540 void wxGrid::DrawCornerLabel(wxDC& dc)
5541 {
5542 wxRect rect(wxSize(m_rowLabelWidth, m_colLabelHeight));
5543
5544 if ( m_nativeColumnLabels )
5545 {
5546 rect.Deflate(1);
5547
5548 wxRendererNative::Get().DrawHeaderButton(m_cornerLabelWin, dc, rect, 0);
5549 }
5550 else
5551 {
5552 rect.width++;
5553 rect.height++;
5554
5555 wxGridCellAttrProvider * const
5556 attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5557 const wxGridCornerHeaderRenderer&
5558 rend = attrProvider ? attrProvider->GetCornerRenderer()
5559 : static_cast<wxGridCornerHeaderRenderer&>
5560 (gs_defaultHeaderRenderers.cornerRenderer);
5561
5562 rend.DrawBorder(*this, dc, rect);
5563 }
5564 }
5565
5566 void wxGrid::DrawColLabel(wxDC& dc, int col)
5567 {
5568 if ( GetColWidth(col) <= 0 || m_colLabelHeight <= 0 )
5569 return;
5570
5571 int colLeft = GetColLeft(col);
5572
5573 wxRect rect(colLeft, 0, GetColWidth(col), m_colLabelHeight);
5574 wxGridCellAttrProvider * const
5575 attrProvider = m_table ? m_table->GetAttrProvider() : NULL;
5576 const wxGridColumnHeaderRenderer&
5577 rend = attrProvider ? attrProvider->GetColumnHeaderRenderer(col)
5578 : static_cast<wxGridColumnHeaderRenderer&>
5579 (gs_defaultHeaderRenderers.colRenderer);
5580
5581 if ( m_nativeColumnLabels )
5582 {
5583 wxRendererNative::Get().DrawHeaderButton
5584 (
5585 GetColLabelWindow(),
5586 dc,
5587 rect,
5588 0,
5589 IsSortingBy(col)
5590 ? IsSortOrderAscending()
5591 ? wxHDR_SORT_ICON_UP
5592 : wxHDR_SORT_ICON_DOWN
5593 : wxHDR_SORT_ICON_NONE
5594 );
5595 rect.Deflate(2);
5596 }
5597 else
5598 {
5599 // It is reported that we need to erase the background to avoid display
5600 // artefacts, see #12055.
5601 wxDCBrushChanger setBrush(dc, m_colWindow->GetBackgroundColour());
5602 dc.DrawRectangle(rect);
5603
5604 rend.DrawBorder(*this, dc, rect);
5605 }
5606
5607 int hAlign, vAlign;
5608 GetColLabelAlignment(&hAlign, &vAlign);
5609 const int orient = GetColLabelTextOrientation();
5610
5611 rend.DrawLabel(*this, dc, GetColLabelValue(col), rect, hAlign, vAlign, orient);
5612 }
5613
5614 // TODO: these 2 functions should be replaced with wxDC::DrawLabel() to which
5615 // we just have to add textOrientation support
5616 void wxGrid::DrawTextRectangle( wxDC& dc,
5617 const wxString& value,
5618 const wxRect& rect,
5619 int horizAlign,
5620 int vertAlign,
5621 int textOrientation ) const
5622 {
5623 wxArrayString lines;
5624
5625 StringToLines( value, lines );
5626
5627 DrawTextRectangle(dc, lines, rect, horizAlign, vertAlign, textOrientation);
5628 }
5629
5630 void wxGrid::DrawTextRectangle(wxDC& dc,
5631 const wxArrayString& lines,
5632 const wxRect& rect,
5633 int horizAlign,
5634 int vertAlign,
5635 int textOrientation) const
5636 {
5637 if ( lines.empty() )
5638 return;
5639
5640 wxDCClipper clip(dc, rect);
5641
5642 long textWidth,
5643 textHeight;
5644
5645 if ( textOrientation == wxHORIZONTAL )
5646 GetTextBoxSize( dc, lines, &textWidth, &textHeight );
5647 else
5648 GetTextBoxSize( dc, lines, &textHeight, &textWidth );
5649
5650 int x = 0,
5651 y = 0;
5652 switch ( vertAlign )
5653 {
5654 case wxALIGN_BOTTOM:
5655 if ( textOrientation == wxHORIZONTAL )
5656 y = rect.y + (rect.height - textHeight - 1);
5657 else
5658 x = rect.x + rect.width - textWidth;
5659 break;
5660
5661 case wxALIGN_CENTRE:
5662 if ( textOrientation == wxHORIZONTAL )
5663 y = rect.y + ((rect.height - textHeight) / 2);
5664 else
5665 x = rect.x + ((rect.width - textWidth) / 2);
5666 break;
5667
5668 case wxALIGN_TOP:
5669 default:
5670 if ( textOrientation == wxHORIZONTAL )
5671 y = rect.y + 1;
5672 else
5673 x = rect.x + 1;
5674 break;
5675 }
5676
5677 // Align each line of a multi-line label
5678 size_t nLines = lines.GetCount();
5679 for ( size_t l = 0; l < nLines; l++ )
5680 {
5681 const wxString& line = lines[l];
5682
5683 if ( line.empty() )
5684 {
5685 *(textOrientation == wxHORIZONTAL ? &y : &x) += dc.GetCharHeight();
5686 continue;
5687 }
5688
5689 wxCoord lineWidth = 0,
5690 lineHeight = 0;
5691 dc.GetTextExtent(line, &lineWidth, &lineHeight);
5692
5693 switch ( horizAlign )
5694 {
5695 case wxALIGN_RIGHT:
5696 if ( textOrientation == wxHORIZONTAL )
5697 x = rect.x + (rect.width - lineWidth - 1);
5698 else
5699 y = rect.y + lineWidth + 1;
5700 break;
5701
5702 case wxALIGN_CENTRE:
5703 if ( textOrientation == wxHORIZONTAL )
5704 x = rect.x + ((rect.width - lineWidth) / 2);
5705 else
5706 y = rect.y + rect.height - ((rect.height - lineWidth) / 2);
5707 break;
5708
5709 case wxALIGN_LEFT:
5710 default:
5711 if ( textOrientation == wxHORIZONTAL )
5712 x = rect.x + 1;
5713 else
5714 y = rect.y + rect.height - 1;
5715 break;
5716 }
5717
5718 if ( textOrientation == wxHORIZONTAL )
5719 {
5720 dc.DrawText( line, x, y );
5721 y += lineHeight;
5722 }
5723 else
5724 {
5725 dc.DrawRotatedText( line, x, y, 90.0 );
5726 x += lineHeight;
5727 }
5728 }
5729 }
5730
5731 // Split multi-line text up into an array of strings.
5732 // Any existing contents of the string array are preserved.
5733 //
5734 // TODO: refactor wxTextFile::Read() and reuse the same code from here
5735 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines ) const
5736 {
5737 int startPos = 0;
5738 int pos;
5739 wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
5740 wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
5741
5742 while ( startPos < (int)tVal.length() )
5743 {
5744 pos = tVal.Mid(startPos).Find( eol );
5745 if ( pos < 0 )
5746 {
5747 break;
5748 }
5749 else if ( pos == 0 )
5750 {
5751 lines.Add( wxEmptyString );
5752 }
5753 else
5754 {
5755 lines.Add( tVal.Mid(startPos, pos) );
5756 }
5757
5758 startPos += pos + 1;
5759 }
5760
5761 if ( startPos < (int)tVal.length() )
5762 {
5763 lines.Add( tVal.Mid( startPos ) );
5764 }
5765 }
5766
5767 void wxGrid::GetTextBoxSize( const wxDC& dc,
5768 const wxArrayString& lines,
5769 long *width, long *height ) const
5770 {
5771 wxCoord w = 0;
5772 wxCoord h = 0;
5773 wxCoord lineW = 0, lineH = 0;
5774
5775 size_t i;
5776 for ( i = 0; i < lines.GetCount(); i++ )
5777 {
5778 dc.GetTextExtent( lines[i], &lineW, &lineH );
5779 w = wxMax( w, lineW );
5780 h += lineH;
5781 }
5782
5783 *width = w;
5784 *height = h;
5785 }
5786
5787 //
5788 // ------ Batch processing.
5789 //
5790 void wxGrid::EndBatch()
5791 {
5792 if ( m_batchCount > 0 )
5793 {
5794 m_batchCount--;
5795 if ( !m_batchCount )
5796 {
5797 CalcDimensions();
5798 m_rowLabelWin->Refresh();
5799 m_colWindow->Refresh();
5800 m_cornerLabelWin->Refresh();
5801 m_gridWin->Refresh();
5802 }
5803 }
5804 }
5805
5806 // Use this, rather than wxWindow::Refresh(), to force an immediate
5807 // repainting of the grid. Has no effect if you are already inside a
5808 // BeginBatch / EndBatch block.
5809 //
5810 void wxGrid::ForceRefresh()
5811 {
5812 BeginBatch();
5813 EndBatch();
5814 }
5815
5816 bool wxGrid::Enable(bool enable)
5817 {
5818 if ( !wxScrolledWindow::Enable(enable) )
5819 return false;
5820
5821 // redraw in the new state
5822 m_gridWin->Refresh();
5823
5824 return true;
5825 }
5826
5827 //
5828 // ------ Edit control functions
5829 //
5830
5831 void wxGrid::EnableEditing( bool edit )
5832 {
5833 if ( edit != m_editable )
5834 {
5835 if (!edit)
5836 EnableCellEditControl(edit);
5837 m_editable = edit;
5838 }
5839 }
5840
5841 void wxGrid::EnableCellEditControl( bool enable )
5842 {
5843 if (! m_editable)
5844 return;
5845
5846 if ( enable != m_cellEditCtrlEnabled )
5847 {
5848 if ( enable )
5849 {
5850 if ( SendEvent(wxEVT_GRID_EDITOR_SHOWN) == -1 )
5851 return;
5852
5853 // this should be checked by the caller!
5854 wxASSERT_MSG( CanEnableCellControl(), wxT("can't enable editing for this cell!") );
5855
5856 // do it before ShowCellEditControl()
5857 m_cellEditCtrlEnabled = enable;
5858
5859 ShowCellEditControl();
5860 }
5861 else
5862 {
5863 SendEvent(wxEVT_GRID_EDITOR_HIDDEN);
5864
5865 HideCellEditControl();
5866 SaveEditControlValue();
5867
5868 // do it after HideCellEditControl()
5869 m_cellEditCtrlEnabled = enable;
5870 }
5871 }
5872 }
5873
5874 bool wxGrid::IsCurrentCellReadOnly() const
5875 {
5876 wxGridCellAttr*
5877 attr = const_cast<wxGrid *>(this)->GetCellAttr(m_currentCellCoords);
5878 bool readonly = attr->IsReadOnly();
5879 attr->DecRef();
5880
5881 return readonly;
5882 }
5883
5884 bool wxGrid::CanEnableCellControl() const
5885 {
5886 return m_editable && (m_currentCellCoords != wxGridNoCellCoords) &&
5887 !IsCurrentCellReadOnly();
5888 }
5889
5890 bool wxGrid::IsCellEditControlEnabled() const
5891 {
5892 // the cell edit control might be disable for all cells or just for the
5893 // current one if it's read only
5894 return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : false;
5895 }
5896
5897 bool wxGrid::IsCellEditControlShown() const
5898 {
5899 bool isShown = false;
5900
5901 if ( m_cellEditCtrlEnabled )
5902 {
5903 int row = m_currentCellCoords.GetRow();
5904 int col = m_currentCellCoords.GetCol();
5905 wxGridCellAttr* attr = GetCellAttr(row, col);
5906 wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
5907 attr->DecRef();
5908
5909 if ( editor )
5910 {
5911 if ( editor->IsCreated() )
5912 {
5913 isShown = editor->GetControl()->IsShown();
5914 }
5915
5916 editor->DecRef();
5917 }
5918 }
5919
5920 return isShown;
5921 }
5922
5923 void wxGrid::ShowCellEditControl()
5924 {
5925 if ( IsCellEditControlEnabled() )
5926 {
5927 if ( !IsVisible( m_currentCellCoords, false ) )
5928 {
5929 m_cellEditCtrlEnabled = false;
5930 return;
5931 }
5932 else
5933 {
5934 wxRect rect = CellToRect( m_currentCellCoords );
5935 int row = m_currentCellCoords.GetRow();
5936 int col = m_currentCellCoords.GetCol();
5937
5938 // if this is part of a multicell, find owner (topleft)
5939 int cell_rows, cell_cols;
5940 GetCellSize( row, col, &cell_rows, &cell_cols );
5941 if ( cell_rows <= 0 || cell_cols <= 0 )
5942 {
5943 row += cell_rows;
5944 col += cell_cols;
5945 m_currentCellCoords.SetRow( row );
5946 m_currentCellCoords.SetCol( col );
5947 }
5948
5949 // erase the highlight and the cell contents because the editor
5950 // might not cover the entire cell
5951 wxClientDC dc( m_gridWin );
5952 PrepareDC( dc );
5953 wxGridCellAttr* attr = GetCellAttr(row, col);
5954 dc.SetBrush(wxBrush(attr->GetBackgroundColour()));
5955 dc.SetPen(*wxTRANSPARENT_PEN);
5956 dc.DrawRectangle(rect);
5957
5958 // convert to scrolled coords
5959 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
5960
5961 int nXMove = 0;
5962 if (rect.x < 0)
5963 nXMove = rect.x;
5964
5965 // cell is shifted by one pixel
5966 // However, don't allow x or y to become negative
5967 // since the SetSize() method interprets that as
5968 // "don't change."
5969 if (rect.x > 0)
5970 rect.x--;
5971 if (rect.y > 0)
5972 rect.y--;
5973
5974 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
5975 if ( !editor->IsCreated() )
5976 {
5977 editor->Create(m_gridWin, wxID_ANY,
5978 new wxGridCellEditorEvtHandler(this, editor));
5979
5980 wxGridEditorCreatedEvent evt(GetId(),
5981 wxEVT_GRID_EDITOR_CREATED,
5982 this,
5983 row,
5984 col,
5985 editor->GetControl());
5986 GetEventHandler()->ProcessEvent(evt);
5987 }
5988
5989 // resize editor to overflow into righthand cells if allowed
5990 int maxWidth = rect.width;
5991 wxString value = GetCellValue(row, col);
5992 if ( (value != wxEmptyString) && (attr->GetOverflow()) )
5993 {
5994 int y;
5995 GetTextExtent(value, &maxWidth, &y, NULL, NULL, &attr->GetFont());
5996 if (maxWidth < rect.width)
5997 maxWidth = rect.width;
5998 }
5999
6000 int client_right = m_gridWin->GetClientSize().GetWidth();
6001 if (rect.x + maxWidth > client_right)
6002 maxWidth = client_right - rect.x;
6003
6004 if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
6005 {
6006 GetCellSize( row, col, &cell_rows, &cell_cols );
6007 // may have changed earlier
6008 for (int i = col + cell_cols; i < m_numCols; i++)
6009 {
6010 int c_rows, c_cols;
6011 GetCellSize( row, i, &c_rows, &c_cols );
6012
6013 // looks weird going over a multicell
6014 if (m_table->IsEmptyCell( row, i ) &&
6015 (rect.width < maxWidth) && (c_rows == 1))
6016 {
6017 rect.width += GetColWidth( i );
6018 }
6019 else
6020 break;
6021 }
6022
6023 if (rect.GetRight() > client_right)
6024 rect.SetRight( client_right - 1 );
6025 }
6026
6027 editor->SetCellAttr( attr );
6028 editor->SetSize( rect );
6029 if (nXMove != 0)
6030 editor->GetControl()->Move(
6031 editor->GetControl()->GetPosition().x + nXMove,
6032 editor->GetControl()->GetPosition().y );
6033 editor->Show( true, attr );
6034
6035 // recalc dimensions in case we need to
6036 // expand the scrolled window to account for editor
6037 CalcDimensions();
6038
6039 editor->BeginEdit(row, col, this);
6040 editor->SetCellAttr(NULL);
6041
6042 editor->DecRef();
6043 attr->DecRef();
6044 }
6045 }
6046 }
6047
6048 void wxGrid::HideCellEditControl()
6049 {
6050 if ( IsCellEditControlEnabled() )
6051 {
6052 int row = m_currentCellCoords.GetRow();
6053 int col = m_currentCellCoords.GetCol();
6054
6055 wxGridCellAttr *attr = GetCellAttr(row, col);
6056 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6057 const bool editorHadFocus = editor->GetControl()->HasFocus();
6058 editor->Show( false );
6059 editor->DecRef();
6060 attr->DecRef();
6061
6062 // return the focus to the grid itself if the editor had it
6063 //
6064 // note that we must not do this unconditionally to avoid stealing
6065 // focus from the window which just received it if we are hiding the
6066 // editor precisely because we lost focus
6067 if ( editorHadFocus )
6068 m_gridWin->SetFocus();
6069
6070 // refresh whole row to the right
6071 wxRect rect( CellToRect(row, col) );
6072 CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
6073 rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
6074
6075 #ifdef __WXMAC__
6076 // ensure that the pixels under the focus ring get refreshed as well
6077 rect.Inflate(10, 10);
6078 #endif
6079
6080 m_gridWin->Refresh( false, &rect );
6081 }
6082 }
6083
6084 void wxGrid::SaveEditControlValue()
6085 {
6086 if ( IsCellEditControlEnabled() )
6087 {
6088 int row = m_currentCellCoords.GetRow();
6089 int col = m_currentCellCoords.GetCol();
6090
6091 wxString oldval = GetCellValue(row, col);
6092
6093 wxGridCellAttr* attr = GetCellAttr(row, col);
6094 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
6095
6096 wxString newval;
6097 bool changed = editor->EndEdit(row, col, this, oldval, &newval);
6098
6099 if ( changed && SendEvent(wxEVT_GRID_CELL_CHANGING, newval) != -1 )
6100 {
6101 editor->ApplyEdit(row, col, this);
6102
6103 // for compatibility reasons dating back to wx 2.8 when this event
6104 // was called wxEVT_GRID_CELL_CHANGE and wxEVT_GRID_CELL_CHANGING
6105 // didn't exist we allow vetoing this one too
6106 if ( SendEvent(wxEVT_GRID_CELL_CHANGED, oldval) == -1 )
6107 {
6108 // Event has been vetoed, set the data back.
6109 SetCellValue(row, col, oldval);
6110 }
6111 }
6112
6113 editor->DecRef();
6114 attr->DecRef();
6115 }
6116 }
6117
6118 //
6119 // ------ Grid location functions
6120 // Note that all of these functions work with the logical coordinates of
6121 // grid cells and labels so you will need to convert from device
6122 // coordinates for mouse events etc.
6123 //
6124
6125 wxGridCellCoords wxGrid::XYToCell(int x, int y) const
6126 {
6127 int row = YToRow(y);
6128 int col = XToCol(x);
6129
6130 return row == -1 || col == -1 ? wxGridNoCellCoords
6131 : wxGridCellCoords(row, col);
6132 }
6133
6134 // compute row or column from some (unscrolled) coordinate value, using either
6135 // m_defaultRowHeight/m_defaultColWidth or binary search on array of
6136 // m_rowBottoms/m_colRights to do it quickly (linear search shouldn't be used
6137 // for large grids)
6138 int wxGrid::PosToLinePos(int coord,
6139 bool clipToMinMax,
6140 const wxGridOperations& oper) const
6141 {
6142 const int numLines = oper.GetNumberOfLines(this);
6143
6144 if ( coord < 0 )
6145 return clipToMinMax && numLines > 0 ? 0 : wxNOT_FOUND;
6146
6147 const int defaultLineSize = oper.GetDefaultLineSize(this);
6148 wxCHECK_MSG( defaultLineSize, -1, "can't have 0 default line size" );
6149
6150 int maxPos = coord / defaultLineSize,
6151 minPos = 0;
6152
6153 // check for the simplest case: if we have no explicit line sizes
6154 // configured, then we already know the line this position falls in
6155 const wxArrayInt& lineEnds = oper.GetLineEnds(this);
6156 if ( lineEnds.empty() )
6157 {
6158 if ( maxPos < numLines )
6159 return maxPos;
6160
6161 return clipToMinMax ? numLines - 1 : -1;
6162 }
6163
6164
6165 // adjust maxPos before starting the binary search
6166 if ( maxPos >= numLines )
6167 {
6168 maxPos = numLines - 1;
6169 }
6170 else
6171 {
6172 if ( coord >= lineEnds[oper.GetLineAt(this, maxPos)])
6173 {
6174 minPos = maxPos;
6175 const int minDist = oper.GetMinimalAcceptableLineSize(this);
6176 if ( minDist )
6177 maxPos = coord / minDist;
6178 else
6179 maxPos = numLines - 1;
6180 }
6181
6182 if ( maxPos >= numLines )
6183 maxPos = numLines - 1;
6184 }
6185
6186 // check if the position is beyond the last column
6187 const int lineAtMaxPos = oper.GetLineAt(this, maxPos);
6188 if ( coord >= lineEnds[lineAtMaxPos] )
6189 return clipToMinMax ? maxPos : -1;
6190
6191 // or before the first one
6192 const int lineAt0 = oper.GetLineAt(this, 0);
6193 if ( coord < lineEnds[lineAt0] )
6194 return 0;
6195
6196
6197 // finally do perform the binary search
6198 while ( minPos < maxPos )
6199 {
6200 wxCHECK_MSG( lineEnds[oper.GetLineAt(this, minPos)] <= coord &&
6201 coord < lineEnds[oper.GetLineAt(this, maxPos)],
6202 -1,
6203 "wxGrid: internal error in PosToLinePos()" );
6204
6205 if ( coord >= lineEnds[oper.GetLineAt(this, maxPos - 1)] )
6206 return maxPos;
6207 else
6208 maxPos--;
6209
6210 const int median = minPos + (maxPos - minPos + 1) / 2;
6211 if ( coord < lineEnds[oper.GetLineAt(this, median)] )
6212 maxPos = median;
6213 else
6214 minPos = median;
6215 }
6216
6217 return maxPos;
6218 }
6219
6220 int
6221 wxGrid::PosToLine(int coord,
6222 bool clipToMinMax,
6223 const wxGridOperations& oper) const
6224 {
6225 int pos = PosToLinePos(coord, clipToMinMax, oper);
6226
6227 return pos == wxNOT_FOUND ? wxNOT_FOUND : oper.GetLineAt(this, pos);
6228 }
6229
6230 int wxGrid::YToRow(int y, bool clipToMinMax) const
6231 {
6232 return PosToLine(y, clipToMinMax, wxGridRowOperations());
6233 }
6234
6235 int wxGrid::XToCol(int x, bool clipToMinMax) const
6236 {
6237 return PosToLine(x, clipToMinMax, wxGridColumnOperations());
6238 }
6239
6240 int wxGrid::XToPos(int x) const
6241 {
6242 return PosToLinePos(x, true /* clip */, wxGridColumnOperations());
6243 }
6244
6245 // return the row number such that the y coord is near the edge of, or -1 if
6246 // not near an edge.
6247 //
6248 // notice that position can only possibly be near an edge if the row/column is
6249 // large enough to still allow for an "inner" area that is _not_ near the edge
6250 // (i.e., if the height/width is smaller than WXGRID_LABEL_EDGE_ZONE, pos will
6251 // _never_ be considered to be near the edge).
6252 int wxGrid::PosToEdgeOfLine(int pos, const wxGridOperations& oper) const
6253 {
6254 const int line = oper.PosToLine(this, pos, true);
6255
6256 if ( oper.GetLineSize(this, line) > WXGRID_LABEL_EDGE_ZONE )
6257 {
6258 // We know that we are in this line, test whether we are close enough
6259 // to start or end border, respectively.
6260 if ( abs(oper.GetLineEndPos(this, line) - pos) < WXGRID_LABEL_EDGE_ZONE )
6261 return line;
6262 else if ( line > 0 &&
6263 pos - oper.GetLineStartPos(this,
6264 line) < WXGRID_LABEL_EDGE_ZONE )
6265 {
6266 return oper.GetLineBefore(this, line);
6267 }
6268 }
6269
6270 return -1;
6271 }
6272
6273 int wxGrid::YToEdgeOfRow(int y) const
6274 {
6275 return PosToEdgeOfLine(y, wxGridRowOperations());
6276 }
6277
6278 int wxGrid::XToEdgeOfCol(int x) const
6279 {
6280 return PosToEdgeOfLine(x, wxGridColumnOperations());
6281 }
6282
6283 wxRect wxGrid::CellToRect( int row, int col ) const
6284 {
6285 wxRect rect( -1, -1, -1, -1 );
6286
6287 if ( row >= 0 && row < m_numRows &&
6288 col >= 0 && col < m_numCols )
6289 {
6290 int i, cell_rows, cell_cols;
6291 rect.width = rect.height = 0;
6292 GetCellSize( row, col, &cell_rows, &cell_cols );
6293 // if negative then find multicell owner
6294 if (cell_rows < 0)
6295 row += cell_rows;
6296 if (cell_cols < 0)
6297 col += cell_cols;
6298 GetCellSize( row, col, &cell_rows, &cell_cols );
6299
6300 rect.x = GetColLeft(col);
6301 rect.y = GetRowTop(row);
6302 for (i=col; i < col + cell_cols; i++)
6303 rect.width += GetColWidth(i);
6304 for (i=row; i < row + cell_rows; i++)
6305 rect.height += GetRowHeight(i);
6306
6307 // if grid lines are enabled, then the area of the cell is a bit smaller
6308 if (m_gridLinesEnabled)
6309 {
6310 rect.width -= 1;
6311 rect.height -= 1;
6312 }
6313 }
6314
6315 return rect;
6316 }
6317
6318 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible ) const
6319 {
6320 // get the cell rectangle in logical coords
6321 //
6322 wxRect r( CellToRect( row, col ) );
6323
6324 // convert to device coords
6325 //
6326 int left, top, right, bottom;
6327 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6328 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6329
6330 // check against the client area of the grid window
6331 int cw, ch;
6332 m_gridWin->GetClientSize( &cw, &ch );
6333
6334 if ( wholeCellVisible )
6335 {
6336 // is the cell wholly visible ?
6337 return ( left >= 0 && right <= cw &&
6338 top >= 0 && bottom <= ch );
6339 }
6340 else
6341 {
6342 // is the cell partly visible ?
6343 //
6344 return ( ((left >= 0 && left < cw) || (right > 0 && right <= cw)) &&
6345 ((top >= 0 && top < ch) || (bottom > 0 && bottom <= ch)) );
6346 }
6347 }
6348
6349 // make the specified cell location visible by doing a minimal amount
6350 // of scrolling
6351 //
6352 void wxGrid::MakeCellVisible( int row, int col )
6353 {
6354 int i;
6355 int xpos = -1, ypos = -1;
6356
6357 if ( row >= 0 && row < m_numRows &&
6358 col >= 0 && col < m_numCols )
6359 {
6360 // get the cell rectangle in logical coords
6361 wxRect r( CellToRect( row, col ) );
6362
6363 // convert to device coords
6364 int left, top, right, bottom;
6365 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
6366 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
6367
6368 int cw, ch;
6369 m_gridWin->GetClientSize( &cw, &ch );
6370
6371 if ( top < 0 )
6372 {
6373 ypos = r.GetTop();
6374 }
6375 else if ( bottom > ch )
6376 {
6377 int h = r.GetHeight();
6378 ypos = r.GetTop();
6379 for ( i = row - 1; i >= 0; i-- )
6380 {
6381 int rowHeight = GetRowHeight(i);
6382 if ( h + rowHeight > ch )
6383 break;
6384
6385 h += rowHeight;
6386 ypos -= rowHeight;
6387 }
6388
6389 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
6390 // have rounding errors (this is important, because if we do,
6391 // we might not scroll at all and some cells won't be redrawn)
6392 //
6393 // Sometimes GRID_SCROLL_LINE / 2 is not enough,
6394 // so just add a full scroll unit...
6395 ypos += m_yScrollPixelsPerLine;
6396 }
6397
6398 // special handling for wide cells - show always left part of the cell!
6399 // Otherwise, e.g. when stepping from row to row, it would jump between
6400 // left and right part of the cell on every step!
6401 // if ( left < 0 )
6402 if ( left < 0 || (right - left) >= cw )
6403 {
6404 xpos = r.GetLeft();
6405 }
6406 else if ( right > cw )
6407 {
6408 // position the view so that the cell is on the right
6409 int x0, y0;
6410 CalcUnscrolledPosition(0, 0, &x0, &y0);
6411 xpos = x0 + (right - cw);
6412
6413 // see comment for ypos above
6414 xpos += m_xScrollPixelsPerLine;
6415 }
6416
6417 if ( xpos != -1 || ypos != -1 )
6418 {
6419 if ( xpos != -1 )
6420 xpos /= m_xScrollPixelsPerLine;
6421 if ( ypos != -1 )
6422 ypos /= m_yScrollPixelsPerLine;
6423 Scroll( xpos, ypos );
6424 AdjustScrollbars();
6425 }
6426 }
6427 }
6428
6429 //
6430 // ------ Grid cursor movement functions
6431 //
6432
6433 bool
6434 wxGrid::DoMoveCursor(bool expandSelection,
6435 const wxGridDirectionOperations& diroper)
6436 {
6437 if ( m_currentCellCoords == wxGridNoCellCoords )
6438 return false;
6439
6440 if ( expandSelection )
6441 {
6442 wxGridCellCoords coords = m_selectedBlockCorner;
6443 if ( coords == wxGridNoCellCoords )
6444 coords = m_currentCellCoords;
6445
6446 if ( diroper.IsAtBoundary(coords) )
6447 return false;
6448
6449 diroper.Advance(coords);
6450
6451 UpdateBlockBeingSelected(m_currentCellCoords, coords);
6452 }
6453 else // don't expand selection
6454 {
6455 ClearSelection();
6456
6457 if ( diroper.IsAtBoundary(m_currentCellCoords) )
6458 return false;
6459
6460 wxGridCellCoords coords = m_currentCellCoords;
6461 diroper.Advance(coords);
6462
6463 GoToCell(coords);
6464 }
6465
6466 return true;
6467 }
6468
6469 bool wxGrid::MoveCursorUp(bool expandSelection)
6470 {
6471 return DoMoveCursor(expandSelection,
6472 wxGridBackwardOperations(this, wxGridRowOperations()));
6473 }
6474
6475 bool wxGrid::MoveCursorDown(bool expandSelection)
6476 {
6477 return DoMoveCursor(expandSelection,
6478 wxGridForwardOperations(this, wxGridRowOperations()));
6479 }
6480
6481 bool wxGrid::MoveCursorLeft(bool expandSelection)
6482 {
6483 return DoMoveCursor(expandSelection,
6484 wxGridBackwardOperations(this, wxGridColumnOperations()));
6485 }
6486
6487 bool wxGrid::MoveCursorRight(bool expandSelection)
6488 {
6489 return DoMoveCursor(expandSelection,
6490 wxGridForwardOperations(this, wxGridColumnOperations()));
6491 }
6492
6493 bool wxGrid::DoMoveCursorByPage(const wxGridDirectionOperations& diroper)
6494 {
6495 if ( m_currentCellCoords == wxGridNoCellCoords )
6496 return false;
6497
6498 if ( diroper.IsAtBoundary(m_currentCellCoords) )
6499 return false;
6500
6501 const int oldRow = m_currentCellCoords.GetRow();
6502 int newRow = diroper.MoveByPixelDistance(oldRow, m_gridWin->GetClientSize().y);
6503 if ( newRow == oldRow )
6504 {
6505 wxGridCellCoords coords(m_currentCellCoords);
6506 diroper.Advance(coords);
6507 newRow = coords.GetRow();
6508 }
6509
6510 GoToCell(newRow, m_currentCellCoords.GetCol());
6511
6512 return true;
6513 }
6514
6515 bool wxGrid::MovePageUp()
6516 {
6517 return DoMoveCursorByPage(
6518 wxGridBackwardOperations(this, wxGridRowOperations()));
6519 }
6520
6521 bool wxGrid::MovePageDown()
6522 {
6523 return DoMoveCursorByPage(
6524 wxGridForwardOperations(this, wxGridRowOperations()));
6525 }
6526
6527 // helper of DoMoveCursorByBlock(): advance the cell coordinates using diroper
6528 // until we find a non-empty cell or reach the grid end
6529 void
6530 wxGrid::AdvanceToNextNonEmpty(wxGridCellCoords& coords,
6531 const wxGridDirectionOperations& diroper)
6532 {
6533 while ( !diroper.IsAtBoundary(coords) )
6534 {
6535 diroper.Advance(coords);
6536 if ( !m_table->IsEmpty(coords) )
6537 break;
6538 }
6539 }
6540
6541 bool
6542 wxGrid::DoMoveCursorByBlock(bool expandSelection,
6543 const wxGridDirectionOperations& diroper)
6544 {
6545 if ( !m_table || m_currentCellCoords == wxGridNoCellCoords )
6546 return false;
6547
6548 if ( diroper.IsAtBoundary(m_currentCellCoords) )
6549 return false;
6550
6551 wxGridCellCoords coords(m_currentCellCoords);
6552 if ( m_table->IsEmpty(coords) )
6553 {
6554 // we are in an empty cell: find the next block of non-empty cells
6555 AdvanceToNextNonEmpty(coords, diroper);
6556 }
6557 else // current cell is not empty
6558 {
6559 diroper.Advance(coords);
6560 if ( m_table->IsEmpty(coords) )
6561 {
6562 // we started at the end of a block, find the next one
6563 AdvanceToNextNonEmpty(coords, diroper);
6564 }
6565 else // we're in a middle of a block
6566 {
6567 // go to the end of it, i.e. find the last cell before the next
6568 // empty one
6569 while ( !diroper.IsAtBoundary(coords) )
6570 {
6571 wxGridCellCoords coordsNext(coords);
6572 diroper.Advance(coordsNext);
6573 if ( m_table->IsEmpty(coordsNext) )
6574 break;
6575
6576 coords = coordsNext;
6577 }
6578 }
6579 }
6580
6581 if ( expandSelection )
6582 {
6583 UpdateBlockBeingSelected(m_currentCellCoords, coords);
6584 }
6585 else
6586 {
6587 ClearSelection();
6588 GoToCell(coords);
6589 }
6590
6591 return true;
6592 }
6593
6594 bool wxGrid::MoveCursorUpBlock(bool expandSelection)
6595 {
6596 return DoMoveCursorByBlock(
6597 expandSelection,
6598 wxGridBackwardOperations(this, wxGridRowOperations())
6599 );
6600 }
6601
6602 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
6603 {
6604 return DoMoveCursorByBlock(
6605 expandSelection,
6606 wxGridForwardOperations(this, wxGridRowOperations())
6607 );
6608 }
6609
6610 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
6611 {
6612 return DoMoveCursorByBlock(
6613 expandSelection,
6614 wxGridBackwardOperations(this, wxGridColumnOperations())
6615 );
6616 }
6617
6618 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
6619 {
6620 return DoMoveCursorByBlock(
6621 expandSelection,
6622 wxGridForwardOperations(this, wxGridColumnOperations())
6623 );
6624 }
6625
6626 //
6627 // ------ Label values and formatting
6628 //
6629
6630 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert ) const
6631 {
6632 if ( horiz )
6633 *horiz = m_rowLabelHorizAlign;
6634 if ( vert )
6635 *vert = m_rowLabelVertAlign;
6636 }
6637
6638 void wxGrid::GetColLabelAlignment( int *horiz, int *vert ) const
6639 {
6640 if ( horiz )
6641 *horiz = m_colLabelHorizAlign;
6642 if ( vert )
6643 *vert = m_colLabelVertAlign;
6644 }
6645
6646 int wxGrid::GetColLabelTextOrientation() const
6647 {
6648 return m_colLabelTextOrientation;
6649 }
6650
6651 wxString wxGrid::GetRowLabelValue( int row ) const
6652 {
6653 if ( m_table )
6654 {
6655 return m_table->GetRowLabelValue( row );
6656 }
6657 else
6658 {
6659 wxString s;
6660 s << row;
6661 return s;
6662 }
6663 }
6664
6665 wxString wxGrid::GetColLabelValue( int col ) const
6666 {
6667 if ( m_table )
6668 {
6669 return m_table->GetColLabelValue( col );
6670 }
6671 else
6672 {
6673 wxString s;
6674 s << col;
6675 return s;
6676 }
6677 }
6678
6679 void wxGrid::SetRowLabelSize( int width )
6680 {
6681 wxASSERT( width >= 0 || width == wxGRID_AUTOSIZE );
6682
6683 if ( width == wxGRID_AUTOSIZE )
6684 {
6685 width = CalcColOrRowLabelAreaMinSize(wxGRID_ROW);
6686 }
6687
6688 if ( width != m_rowLabelWidth )
6689 {
6690 if ( width == 0 )
6691 {
6692 m_rowLabelWin->Show( false );
6693 m_cornerLabelWin->Show( false );
6694 }
6695 else if ( m_rowLabelWidth == 0 )
6696 {
6697 m_rowLabelWin->Show( true );
6698 if ( m_colLabelHeight > 0 )
6699 m_cornerLabelWin->Show( true );
6700 }
6701
6702 m_rowLabelWidth = width;
6703 CalcWindowSizes();
6704 wxScrolledWindow::Refresh( true );
6705 }
6706 }
6707
6708 void wxGrid::SetColLabelSize( int height )
6709 {
6710 wxASSERT( height >=0 || height == wxGRID_AUTOSIZE );
6711
6712 if ( height == wxGRID_AUTOSIZE )
6713 {
6714 height = CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN);
6715 }
6716
6717 if ( height != m_colLabelHeight )
6718 {
6719 if ( height == 0 )
6720 {
6721 m_colWindow->Show( false );
6722 m_cornerLabelWin->Show( false );
6723 }
6724 else if ( m_colLabelHeight == 0 )
6725 {
6726 m_colWindow->Show( true );
6727 if ( m_rowLabelWidth > 0 )
6728 m_cornerLabelWin->Show( true );
6729 }
6730
6731 m_colLabelHeight = height;
6732 CalcWindowSizes();
6733 wxScrolledWindow::Refresh( true );
6734 }
6735 }
6736
6737 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
6738 {
6739 if ( m_labelBackgroundColour != colour )
6740 {
6741 m_labelBackgroundColour = colour;
6742 m_rowLabelWin->SetBackgroundColour( colour );
6743 m_colWindow->SetBackgroundColour( colour );
6744 m_cornerLabelWin->SetBackgroundColour( colour );
6745
6746 if ( !GetBatchCount() )
6747 {
6748 m_rowLabelWin->Refresh();
6749 m_colWindow->Refresh();
6750 m_cornerLabelWin->Refresh();
6751 }
6752 }
6753 }
6754
6755 void wxGrid::SetLabelTextColour( const wxColour& colour )
6756 {
6757 if ( m_labelTextColour != colour )
6758 {
6759 m_labelTextColour = colour;
6760 if ( !GetBatchCount() )
6761 {
6762 m_rowLabelWin->Refresh();
6763 m_colWindow->Refresh();
6764 }
6765 }
6766 }
6767
6768 void wxGrid::SetLabelFont( const wxFont& font )
6769 {
6770 m_labelFont = font;
6771 if ( !GetBatchCount() )
6772 {
6773 m_rowLabelWin->Refresh();
6774 m_colWindow->Refresh();
6775 }
6776 }
6777
6778 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
6779 {
6780 // allow old (incorrect) defs to be used
6781 switch ( horiz )
6782 {
6783 case wxLEFT: horiz = wxALIGN_LEFT; break;
6784 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
6785 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
6786 }
6787
6788 switch ( vert )
6789 {
6790 case wxTOP: vert = wxALIGN_TOP; break;
6791 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
6792 case wxCENTRE: vert = wxALIGN_CENTRE; break;
6793 }
6794
6795 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
6796 {
6797 m_rowLabelHorizAlign = horiz;
6798 }
6799
6800 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
6801 {
6802 m_rowLabelVertAlign = vert;
6803 }
6804
6805 if ( !GetBatchCount() )
6806 {
6807 m_rowLabelWin->Refresh();
6808 }
6809 }
6810
6811 void wxGrid::SetColLabelAlignment( int horiz, int vert )
6812 {
6813 // allow old (incorrect) defs to be used
6814 switch ( horiz )
6815 {
6816 case wxLEFT: horiz = wxALIGN_LEFT; break;
6817 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
6818 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
6819 }
6820
6821 switch ( vert )
6822 {
6823 case wxTOP: vert = wxALIGN_TOP; break;
6824 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
6825 case wxCENTRE: vert = wxALIGN_CENTRE; break;
6826 }
6827
6828 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
6829 {
6830 m_colLabelHorizAlign = horiz;
6831 }
6832
6833 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
6834 {
6835 m_colLabelVertAlign = vert;
6836 }
6837
6838 if ( !GetBatchCount() )
6839 {
6840 m_colWindow->Refresh();
6841 }
6842 }
6843
6844 // Note: under MSW, the default column label font must be changed because it
6845 // does not support vertical printing
6846 //
6847 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
6848 // pGrid->SetLabelFont(font);
6849 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
6850 //
6851 void wxGrid::SetColLabelTextOrientation( int textOrientation )
6852 {
6853 if ( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
6854 m_colLabelTextOrientation = textOrientation;
6855
6856 if ( !GetBatchCount() )
6857 m_colWindow->Refresh();
6858 }
6859
6860 void wxGrid::SetRowLabelValue( int row, const wxString& s )
6861 {
6862 if ( m_table )
6863 {
6864 m_table->SetRowLabelValue( row, s );
6865 if ( !GetBatchCount() )
6866 {
6867 wxRect rect = CellToRect( row, 0 );
6868 if ( rect.height > 0 )
6869 {
6870 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
6871 rect.x = 0;
6872 rect.width = m_rowLabelWidth;
6873 m_rowLabelWin->Refresh( true, &rect );
6874 }
6875 }
6876 }
6877 }
6878
6879 void wxGrid::SetColLabelValue( int col, const wxString& s )
6880 {
6881 if ( m_table )
6882 {
6883 m_table->SetColLabelValue( col, s );
6884 if ( !GetBatchCount() )
6885 {
6886 if ( m_useNativeHeader )
6887 {
6888 GetGridColHeader()->UpdateColumn(col);
6889 }
6890 else
6891 {
6892 wxRect rect = CellToRect( 0, col );
6893 if ( rect.width > 0 )
6894 {
6895 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
6896 rect.y = 0;
6897 rect.height = m_colLabelHeight;
6898 GetColLabelWindow()->Refresh( true, &rect );
6899 }
6900 }
6901 }
6902 }
6903 }
6904
6905 void wxGrid::SetGridLineColour( const wxColour& colour )
6906 {
6907 if ( m_gridLineColour != colour )
6908 {
6909 m_gridLineColour = colour;
6910
6911 if ( GridLinesEnabled() )
6912 RedrawGridLines();
6913 }
6914 }
6915
6916 void wxGrid::SetCellHighlightColour( const wxColour& colour )
6917 {
6918 if ( m_cellHighlightColour != colour )
6919 {
6920 m_cellHighlightColour = colour;
6921
6922 wxClientDC dc( m_gridWin );
6923 PrepareDC( dc );
6924 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6925 DrawCellHighlight(dc, attr);
6926 attr->DecRef();
6927 }
6928 }
6929
6930 void wxGrid::SetCellHighlightPenWidth(int width)
6931 {
6932 if (m_cellHighlightPenWidth != width)
6933 {
6934 m_cellHighlightPenWidth = width;
6935
6936 // Just redrawing the cell highlight is not enough since that won't
6937 // make any visible change if the thickness is getting smaller.
6938 int row = m_currentCellCoords.GetRow();
6939 int col = m_currentCellCoords.GetCol();
6940 if ( row == -1 || col == -1 || GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6941 return;
6942
6943 wxRect rect = CellToRect(row, col);
6944 m_gridWin->Refresh(true, &rect);
6945 }
6946 }
6947
6948 void wxGrid::SetCellHighlightROPenWidth(int width)
6949 {
6950 if (m_cellHighlightROPenWidth != width)
6951 {
6952 m_cellHighlightROPenWidth = width;
6953
6954 // Just redrawing the cell highlight is not enough since that won't
6955 // make any visible change if the thickness is getting smaller.
6956 int row = m_currentCellCoords.GetRow();
6957 int col = m_currentCellCoords.GetCol();
6958 if ( row == -1 || col == -1 ||
6959 GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6960 return;
6961
6962 wxRect rect = CellToRect(row, col);
6963 m_gridWin->Refresh(true, &rect);
6964 }
6965 }
6966
6967 void wxGrid::RedrawGridLines()
6968 {
6969 // the lines will be redrawn when the window is thawn
6970 if ( GetBatchCount() )
6971 return;
6972
6973 if ( GridLinesEnabled() )
6974 {
6975 wxClientDC dc( m_gridWin );
6976 PrepareDC( dc );
6977 DrawAllGridLines( dc, wxRegion() );
6978 }
6979 else // remove the grid lines
6980 {
6981 m_gridWin->Refresh();
6982 }
6983 }
6984
6985 void wxGrid::EnableGridLines( bool enable )
6986 {
6987 if ( enable != m_gridLinesEnabled )
6988 {
6989 m_gridLinesEnabled = enable;
6990
6991 RedrawGridLines();
6992 }
6993 }
6994
6995 void wxGrid::DoClipGridLines(bool& var, bool clip)
6996 {
6997 if ( clip != var )
6998 {
6999 var = clip;
7000
7001 if ( GridLinesEnabled() )
7002 RedrawGridLines();
7003 }
7004 }
7005
7006 int wxGrid::GetDefaultRowSize() const
7007 {
7008 return m_defaultRowHeight;
7009 }
7010
7011 int wxGrid::GetRowSize( int row ) const
7012 {
7013 wxCHECK_MSG( row >= 0 && row < m_numRows, 0, wxT("invalid row index") );
7014
7015 return GetRowHeight(row);
7016 }
7017
7018 int wxGrid::GetDefaultColSize() const
7019 {
7020 return m_defaultColWidth;
7021 }
7022
7023 int wxGrid::GetColSize( int col ) const
7024 {
7025 wxCHECK_MSG( col >= 0 && col < m_numCols, 0, wxT("invalid column index") );
7026
7027 return GetColWidth(col);
7028 }
7029
7030 // ============================================================================
7031 // access to the grid attributes: each of them has a default value in the grid
7032 // itself and may be overidden on a per-cell basis
7033 // ============================================================================
7034
7035 // ----------------------------------------------------------------------------
7036 // setting default attributes
7037 // ----------------------------------------------------------------------------
7038
7039 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
7040 {
7041 m_defaultCellAttr->SetBackgroundColour(col);
7042 #ifdef __WXGTK__
7043 m_gridWin->SetBackgroundColour(col);
7044 #endif
7045 }
7046
7047 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
7048 {
7049 m_defaultCellAttr->SetTextColour(col);
7050 }
7051
7052 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
7053 {
7054 m_defaultCellAttr->SetAlignment(horiz, vert);
7055 }
7056
7057 void wxGrid::SetDefaultCellOverflow( bool allow )
7058 {
7059 m_defaultCellAttr->SetOverflow(allow);
7060 }
7061
7062 void wxGrid::SetDefaultCellFont( const wxFont& font )
7063 {
7064 m_defaultCellAttr->SetFont(font);
7065 }
7066
7067 // For editors and renderers the type registry takes precedence over the
7068 // default attr, so we need to register the new editor/renderer for the string
7069 // data type in order to make setting a default editor/renderer appear to
7070 // work correctly.
7071
7072 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
7073 {
7074 RegisterDataType(wxGRID_VALUE_STRING,
7075 renderer,
7076 GetDefaultEditorForType(wxGRID_VALUE_STRING));
7077 }
7078
7079 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
7080 {
7081 RegisterDataType(wxGRID_VALUE_STRING,
7082 GetDefaultRendererForType(wxGRID_VALUE_STRING),
7083 editor);
7084 }
7085
7086 // ----------------------------------------------------------------------------
7087 // access to the default attributes
7088 // ----------------------------------------------------------------------------
7089
7090 wxColour wxGrid::GetDefaultCellBackgroundColour() const
7091 {
7092 return m_defaultCellAttr->GetBackgroundColour();
7093 }
7094
7095 wxColour wxGrid::GetDefaultCellTextColour() const
7096 {
7097 return m_defaultCellAttr->GetTextColour();
7098 }
7099
7100 wxFont wxGrid::GetDefaultCellFont() const
7101 {
7102 return m_defaultCellAttr->GetFont();
7103 }
7104
7105 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert ) const
7106 {
7107 m_defaultCellAttr->GetAlignment(horiz, vert);
7108 }
7109
7110 bool wxGrid::GetDefaultCellOverflow() const
7111 {
7112 return m_defaultCellAttr->GetOverflow();
7113 }
7114
7115 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
7116 {
7117 return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
7118 }
7119
7120 wxGridCellEditor *wxGrid::GetDefaultEditor() const
7121 {
7122 return m_defaultCellAttr->GetEditor(NULL, 0, 0);
7123 }
7124
7125 // ----------------------------------------------------------------------------
7126 // access to cell attributes
7127 // ----------------------------------------------------------------------------
7128
7129 wxColour wxGrid::GetCellBackgroundColour(int row, int col) const
7130 {
7131 wxGridCellAttr *attr = GetCellAttr(row, col);
7132 wxColour colour = attr->GetBackgroundColour();
7133 attr->DecRef();
7134
7135 return colour;
7136 }
7137
7138 wxColour wxGrid::GetCellTextColour( int row, int col ) const
7139 {
7140 wxGridCellAttr *attr = GetCellAttr(row, col);
7141 wxColour colour = attr->GetTextColour();
7142 attr->DecRef();
7143
7144 return colour;
7145 }
7146
7147 wxFont wxGrid::GetCellFont( int row, int col ) const
7148 {
7149 wxGridCellAttr *attr = GetCellAttr(row, col);
7150 wxFont font = attr->GetFont();
7151 attr->DecRef();
7152
7153 return font;
7154 }
7155
7156 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert ) const
7157 {
7158 wxGridCellAttr *attr = GetCellAttr(row, col);
7159 attr->GetAlignment(horiz, vert);
7160 attr->DecRef();
7161 }
7162
7163 bool wxGrid::GetCellOverflow( int row, int col ) const
7164 {
7165 wxGridCellAttr *attr = GetCellAttr(row, col);
7166 bool allow = attr->GetOverflow();
7167 attr->DecRef();
7168
7169 return allow;
7170 }
7171
7172 wxGrid::CellSpan
7173 wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols ) const
7174 {
7175 wxGridCellAttr *attr = GetCellAttr(row, col);
7176 attr->GetSize( num_rows, num_cols );
7177 attr->DecRef();
7178
7179 if ( *num_rows == 1 && *num_cols == 1 )
7180 return CellSpan_None; // just a normal cell
7181
7182 if ( *num_rows < 0 || *num_cols < 0 )
7183 return CellSpan_Inside; // covered by a multi-span cell
7184
7185 // this cell spans multiple cells to its right/bottom
7186 return CellSpan_Main;
7187 }
7188
7189 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const
7190 {
7191 wxGridCellAttr* attr = GetCellAttr(row, col);
7192 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
7193 attr->DecRef();
7194
7195 return renderer;
7196 }
7197
7198 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const
7199 {
7200 wxGridCellAttr* attr = GetCellAttr(row, col);
7201 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7202 attr->DecRef();
7203
7204 return editor;
7205 }
7206
7207 bool wxGrid::IsReadOnly(int row, int col) const
7208 {
7209 wxGridCellAttr* attr = GetCellAttr(row, col);
7210 bool isReadOnly = attr->IsReadOnly();
7211 attr->DecRef();
7212
7213 return isReadOnly;
7214 }
7215
7216 // ----------------------------------------------------------------------------
7217 // attribute support: cache, automatic provider creation, ...
7218 // ----------------------------------------------------------------------------
7219
7220 bool wxGrid::CanHaveAttributes() const
7221 {
7222 if ( !m_table )
7223 {
7224 return false;
7225 }
7226
7227 return m_table->CanHaveAttributes();
7228 }
7229
7230 void wxGrid::ClearAttrCache()
7231 {
7232 if ( m_attrCache.row != -1 )
7233 {
7234 wxGridCellAttr *oldAttr = m_attrCache.attr;
7235 m_attrCache.attr = NULL;
7236 m_attrCache.row = -1;
7237 // wxSafeDecRec(...) might cause event processing that accesses
7238 // the cached attribute, if one exists (e.g. by deleting the
7239 // editor stored within the attribute). Therefore it is important
7240 // to invalidate the cache before calling wxSafeDecRef!
7241 wxSafeDecRef(oldAttr);
7242 }
7243 }
7244
7245 void wxGrid::RefreshAttr(int row, int col)
7246 {
7247 if ( m_attrCache.row == row && m_attrCache.col == col )
7248 ClearAttrCache();
7249 }
7250
7251
7252 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
7253 {
7254 if ( attr != NULL )
7255 {
7256 wxGrid * const self = const_cast<wxGrid *>(this);
7257
7258 self->ClearAttrCache();
7259 self->m_attrCache.row = row;
7260 self->m_attrCache.col = col;
7261 self->m_attrCache.attr = attr;
7262 wxSafeIncRef(attr);
7263 }
7264 }
7265
7266 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
7267 {
7268 if ( row == m_attrCache.row && col == m_attrCache.col )
7269 {
7270 *attr = m_attrCache.attr;
7271 wxSafeIncRef(m_attrCache.attr);
7272
7273 #ifdef DEBUG_ATTR_CACHE
7274 gs_nAttrCacheHits++;
7275 #endif
7276
7277 return true;
7278 }
7279 else
7280 {
7281 #ifdef DEBUG_ATTR_CACHE
7282 gs_nAttrCacheMisses++;
7283 #endif
7284
7285 return false;
7286 }
7287 }
7288
7289 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
7290 {
7291 wxGridCellAttr *attr = NULL;
7292 // Additional test to avoid looking at the cache e.g. for
7293 // wxNoCellCoords, as this will confuse memory management.
7294 if ( row >= 0 )
7295 {
7296 if ( !LookupAttr(row, col, &attr) )
7297 {
7298 attr = m_table ? m_table->GetAttr(row, col, wxGridCellAttr::Any)
7299 : NULL;
7300 CacheAttr(row, col, attr);
7301 }
7302 }
7303
7304 if (attr)
7305 {
7306 attr->SetDefAttr(m_defaultCellAttr);
7307 }
7308 else
7309 {
7310 attr = m_defaultCellAttr;
7311 attr->IncRef();
7312 }
7313
7314 return attr;
7315 }
7316
7317 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
7318 {
7319 wxGridCellAttr *attr = NULL;
7320 bool canHave = ((wxGrid*)this)->CanHaveAttributes();
7321
7322 wxCHECK_MSG( canHave, attr, wxT("Cell attributes not allowed"));
7323 wxCHECK_MSG( m_table, attr, wxT("must have a table") );
7324
7325 attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
7326 if ( !attr )
7327 {
7328 attr = new wxGridCellAttr(m_defaultCellAttr);
7329
7330 // artificially inc the ref count to match DecRef() in caller
7331 attr->IncRef();
7332 m_table->SetAttr(attr, row, col);
7333 }
7334
7335 return attr;
7336 }
7337
7338 // ----------------------------------------------------------------------------
7339 // setting column attributes (wrappers around SetColAttr)
7340 // ----------------------------------------------------------------------------
7341
7342 void wxGrid::SetColFormatBool(int col)
7343 {
7344 SetColFormatCustom(col, wxGRID_VALUE_BOOL);
7345 }
7346
7347 void wxGrid::SetColFormatNumber(int col)
7348 {
7349 SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
7350 }
7351
7352 void wxGrid::SetColFormatFloat(int col, int width, int precision)
7353 {
7354 wxString typeName = wxGRID_VALUE_FLOAT;
7355 if ( (width != -1) || (precision != -1) )
7356 {
7357 typeName << wxT(':') << width << wxT(',') << precision;
7358 }
7359
7360 SetColFormatCustom(col, typeName);
7361 }
7362
7363 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
7364 {
7365 wxGridCellAttr *attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
7366 if (!attr)
7367 attr = new wxGridCellAttr;
7368 wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
7369 attr->SetRenderer(renderer);
7370 wxGridCellEditor *editor = GetDefaultEditorForType(typeName);
7371 attr->SetEditor(editor);
7372
7373 SetColAttr(col, attr);
7374
7375 }
7376
7377 // ----------------------------------------------------------------------------
7378 // setting cell attributes: this is forwarded to the table
7379 // ----------------------------------------------------------------------------
7380
7381 void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
7382 {
7383 if ( CanHaveAttributes() )
7384 {
7385 m_table->SetAttr(attr, row, col);
7386 ClearAttrCache();
7387 }
7388 else
7389 {
7390 wxSafeDecRef(attr);
7391 }
7392 }
7393
7394 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
7395 {
7396 if ( CanHaveAttributes() )
7397 {
7398 m_table->SetRowAttr(attr, row);
7399 ClearAttrCache();
7400 }
7401 else
7402 {
7403 wxSafeDecRef(attr);
7404 }
7405 }
7406
7407 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
7408 {
7409 if ( CanHaveAttributes() )
7410 {
7411 m_table->SetColAttr(attr, col);
7412 ClearAttrCache();
7413 }
7414 else
7415 {
7416 wxSafeDecRef(attr);
7417 }
7418 }
7419
7420 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
7421 {
7422 if ( CanHaveAttributes() )
7423 {
7424 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7425 attr->SetBackgroundColour(colour);
7426 attr->DecRef();
7427 }
7428 }
7429
7430 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
7431 {
7432 if ( CanHaveAttributes() )
7433 {
7434 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7435 attr->SetTextColour(colour);
7436 attr->DecRef();
7437 }
7438 }
7439
7440 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
7441 {
7442 if ( CanHaveAttributes() )
7443 {
7444 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7445 attr->SetFont(font);
7446 attr->DecRef();
7447 }
7448 }
7449
7450 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
7451 {
7452 if ( CanHaveAttributes() )
7453 {
7454 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7455 attr->SetAlignment(horiz, vert);
7456 attr->DecRef();
7457 }
7458 }
7459
7460 void wxGrid::SetCellOverflow( int row, int col, bool allow )
7461 {
7462 if ( CanHaveAttributes() )
7463 {
7464 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7465 attr->SetOverflow(allow);
7466 attr->DecRef();
7467 }
7468 }
7469
7470 void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
7471 {
7472 if ( CanHaveAttributes() )
7473 {
7474 int cell_rows, cell_cols;
7475
7476 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7477 attr->GetSize(&cell_rows, &cell_cols);
7478 attr->SetSize(num_rows, num_cols);
7479 attr->DecRef();
7480
7481 // Cannot set the size of a cell to 0 or negative values
7482 // While it is perfectly legal to do that, this function cannot
7483 // handle all the possibilies, do it by hand by getting the CellAttr.
7484 // You can only set the size of a cell to 1,1 or greater with this fn
7485 wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
7486 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
7487 wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
7488 wxT("wxGrid::SetCellSize setting cell size to < 1"));
7489
7490 // if this was already a multicell then "turn off" the other cells first
7491 if ((cell_rows > 1) || (cell_cols > 1))
7492 {
7493 int i, j;
7494 for (j=row; j < row + cell_rows; j++)
7495 {
7496 for (i=col; i < col + cell_cols; i++)
7497 {
7498 if ((i != col) || (j != row))
7499 {
7500 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
7501 attr_stub->SetSize( 1, 1 );
7502 attr_stub->DecRef();
7503 }
7504 }
7505 }
7506 }
7507
7508 // mark the cells that will be covered by this cell to
7509 // negative or zero values to point back at this cell
7510 if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
7511 {
7512 int i, j;
7513 for (j=row; j < row + num_rows; j++)
7514 {
7515 for (i=col; i < col + num_cols; i++)
7516 {
7517 if ((i != col) || (j != row))
7518 {
7519 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
7520 attr_stub->SetSize( row - j, col - i );
7521 attr_stub->DecRef();
7522 }
7523 }
7524 }
7525 }
7526 }
7527 }
7528
7529 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
7530 {
7531 if ( CanHaveAttributes() )
7532 {
7533 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7534 attr->SetRenderer(renderer);
7535 attr->DecRef();
7536 }
7537 }
7538
7539 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
7540 {
7541 if ( CanHaveAttributes() )
7542 {
7543 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7544 attr->SetEditor(editor);
7545 attr->DecRef();
7546 }
7547 }
7548
7549 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
7550 {
7551 if ( CanHaveAttributes() )
7552 {
7553 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
7554 attr->SetReadOnly(isReadOnly);
7555 attr->DecRef();
7556 }
7557 }
7558
7559 // ----------------------------------------------------------------------------
7560 // Data type registration
7561 // ----------------------------------------------------------------------------
7562
7563 void wxGrid::RegisterDataType(const wxString& typeName,
7564 wxGridCellRenderer* renderer,
7565 wxGridCellEditor* editor)
7566 {
7567 m_typeRegistry->RegisterDataType(typeName, renderer, editor);
7568 }
7569
7570
7571 wxGridCellEditor * wxGrid::GetDefaultEditorForCell(int row, int col) const
7572 {
7573 wxString typeName = m_table->GetTypeName(row, col);
7574 return GetDefaultEditorForType(typeName);
7575 }
7576
7577 wxGridCellRenderer * wxGrid::GetDefaultRendererForCell(int row, int col) const
7578 {
7579 wxString typeName = m_table->GetTypeName(row, col);
7580 return GetDefaultRendererForType(typeName);
7581 }
7582
7583 wxGridCellEditor * wxGrid::GetDefaultEditorForType(const wxString& typeName) const
7584 {
7585 int index = m_typeRegistry->FindOrCloneDataType(typeName);
7586 if ( index == wxNOT_FOUND )
7587 {
7588 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
7589
7590 return NULL;
7591 }
7592
7593 return m_typeRegistry->GetEditor(index);
7594 }
7595
7596 wxGridCellRenderer * wxGrid::GetDefaultRendererForType(const wxString& typeName) const
7597 {
7598 int index = m_typeRegistry->FindOrCloneDataType(typeName);
7599 if ( index == wxNOT_FOUND )
7600 {
7601 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName.c_str()));
7602
7603 return NULL;
7604 }
7605
7606 return m_typeRegistry->GetRenderer(index);
7607 }
7608
7609 // ----------------------------------------------------------------------------
7610 // row/col size
7611 // ----------------------------------------------------------------------------
7612
7613 void wxGrid::DoDisableLineResize(int line, wxGridFixedIndicesSet *& setFixed)
7614 {
7615 if ( !setFixed )
7616 {
7617 setFixed = new wxGridFixedIndicesSet;
7618 }
7619
7620 setFixed->insert(line);
7621 }
7622
7623 bool
7624 wxGrid::DoCanResizeLine(int line, const wxGridFixedIndicesSet *setFixed) const
7625 {
7626 return !setFixed || !setFixed->count(line);
7627 }
7628
7629 void wxGrid::EnableDragRowSize( bool enable )
7630 {
7631 m_canDragRowSize = enable;
7632 }
7633
7634 void wxGrid::EnableDragColSize( bool enable )
7635 {
7636 m_canDragColSize = enable;
7637 }
7638
7639 void wxGrid::EnableDragGridSize( bool enable )
7640 {
7641 m_canDragGridSize = enable;
7642 }
7643
7644 void wxGrid::EnableDragCell( bool enable )
7645 {
7646 m_canDragCell = enable;
7647 }
7648
7649 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
7650 {
7651 m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
7652
7653 if ( resizeExistingRows )
7654 {
7655 // since we are resizing all rows to the default row size,
7656 // we can simply clear the row heights and row bottoms
7657 // arrays (which also allows us to take advantage of
7658 // some speed optimisations)
7659 m_rowHeights.Empty();
7660 m_rowBottoms.Empty();
7661 if ( !GetBatchCount() )
7662 CalcDimensions();
7663 }
7664 }
7665
7666 void wxGrid::SetRowSize( int row, int height )
7667 {
7668 wxCHECK_RET( row >= 0 && row < m_numRows, wxT("invalid row index") );
7669
7670 // if < 0 then calculate new height from label
7671 if ( height < 0 )
7672 {
7673 long w, h;
7674 wxArrayString lines;
7675 wxClientDC dc(m_rowLabelWin);
7676 dc.SetFont(GetLabelFont());
7677 StringToLines(GetRowLabelValue( row ), lines);
7678 GetTextBoxSize( dc, lines, &w, &h );
7679 //check that it is not less than the minimal height
7680 height = wxMax(h, GetRowMinimalAcceptableHeight());
7681 }
7682
7683 // See comment in SetColSize
7684 if ( height < GetRowMinimalAcceptableHeight())
7685 return;
7686
7687 if ( m_rowHeights.IsEmpty() )
7688 {
7689 // need to really create the array
7690 InitRowHeights();
7691 }
7692
7693 int h = wxMax( 0, height );
7694 int diff = h - m_rowHeights[row];
7695
7696 m_rowHeights[row] = h;
7697 for ( int i = row; i < m_numRows; i++ )
7698 {
7699 m_rowBottoms[i] += diff;
7700 }
7701
7702 if ( !GetBatchCount() )
7703 CalcDimensions();
7704 }
7705
7706 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
7707 {
7708 // we dont allow zero default column width
7709 m_defaultColWidth = wxMax( wxMax( width, m_minAcceptableColWidth ), 1 );
7710
7711 if ( resizeExistingCols )
7712 {
7713 // since we are resizing all columns to the default column size,
7714 // we can simply clear the col widths and col rights
7715 // arrays (which also allows us to take advantage of
7716 // some speed optimisations)
7717 m_colWidths.Empty();
7718 m_colRights.Empty();
7719 if ( !GetBatchCount() )
7720 CalcDimensions();
7721 }
7722 }
7723
7724 void wxGrid::SetColSize( int col, int width )
7725 {
7726 wxCHECK_RET( col >= 0 && col < m_numCols, wxT("invalid column index") );
7727
7728 // if < 0 then calculate new width from label
7729 if ( width < 0 )
7730 {
7731 long w, h;
7732 wxArrayString lines;
7733 wxClientDC dc(m_colWindow);
7734 dc.SetFont(GetLabelFont());
7735 StringToLines(GetColLabelValue(col), lines);
7736 if ( GetColLabelTextOrientation() == wxHORIZONTAL )
7737 GetTextBoxSize( dc, lines, &w, &h );
7738 else
7739 GetTextBoxSize( dc, lines, &h, &w );
7740 width = w + 6;
7741 //check that it is not less than the minimal width
7742 width = wxMax(width, GetColMinimalAcceptableWidth());
7743 }
7744
7745 // we intentionally don't test whether the width is less than
7746 // GetColMinimalWidth() here but we do compare it with
7747 // GetColMinimalAcceptableWidth() as otherwise things currently break (see
7748 // #651) -- and we also always allow the width of 0 as it has the special
7749 // sense of hiding the column
7750 if ( width > 0 && width < GetColMinimalAcceptableWidth() )
7751 return;
7752
7753 if ( m_colWidths.IsEmpty() )
7754 {
7755 // need to really create the array
7756 InitColWidths();
7757 }
7758
7759 const int diff = width - m_colWidths[col];
7760 m_colWidths[col] = width;
7761 if ( m_useNativeHeader )
7762 GetGridColHeader()->UpdateColumn(col);
7763 //else: will be refreshed when the header is redrawn
7764
7765 for ( int colPos = GetColPos(col); colPos < m_numCols; colPos++ )
7766 {
7767 m_colRights[GetColAt(colPos)] += diff;
7768 }
7769
7770 if ( !GetBatchCount() )
7771 {
7772 CalcDimensions();
7773 Refresh();
7774 }
7775 }
7776
7777 void wxGrid::SetColMinimalWidth( int col, int width )
7778 {
7779 if (width > GetColMinimalAcceptableWidth())
7780 {
7781 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
7782 m_colMinWidths[key] = width;
7783 }
7784 }
7785
7786 void wxGrid::SetRowMinimalHeight( int row, int width )
7787 {
7788 if (width > GetRowMinimalAcceptableHeight())
7789 {
7790 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
7791 m_rowMinHeights[key] = width;
7792 }
7793 }
7794
7795 int wxGrid::GetColMinimalWidth(int col) const
7796 {
7797 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)col;
7798 wxLongToLongHashMap::const_iterator it = m_colMinWidths.find(key);
7799
7800 return it != m_colMinWidths.end() ? (int)it->second : m_minAcceptableColWidth;
7801 }
7802
7803 int wxGrid::GetRowMinimalHeight(int row) const
7804 {
7805 wxLongToLongHashMap::key_type key = (wxLongToLongHashMap::key_type)row;
7806 wxLongToLongHashMap::const_iterator it = m_rowMinHeights.find(key);
7807
7808 return it != m_rowMinHeights.end() ? (int)it->second : m_minAcceptableRowHeight;
7809 }
7810
7811 void wxGrid::SetColMinimalAcceptableWidth( int width )
7812 {
7813 // We do allow a width of 0 since this gives us
7814 // an easy way to temporarily hiding columns.
7815 if ( width >= 0 )
7816 m_minAcceptableColWidth = width;
7817 }
7818
7819 void wxGrid::SetRowMinimalAcceptableHeight( int height )
7820 {
7821 // We do allow a height of 0 since this gives us
7822 // an easy way to temporarily hiding rows.
7823 if ( height >= 0 )
7824 m_minAcceptableRowHeight = height;
7825 }
7826
7827 int wxGrid::GetColMinimalAcceptableWidth() const
7828 {
7829 return m_minAcceptableColWidth;
7830 }
7831
7832 int wxGrid::GetRowMinimalAcceptableHeight() const
7833 {
7834 return m_minAcceptableRowHeight;
7835 }
7836
7837 // ----------------------------------------------------------------------------
7838 // auto sizing
7839 // ----------------------------------------------------------------------------
7840
7841 void
7842 wxGrid::AutoSizeColOrRow(int colOrRow, bool setAsMin, wxGridDirection direction)
7843 {
7844 const bool column = direction == wxGRID_COLUMN;
7845
7846 wxClientDC dc(m_gridWin);
7847
7848 // cancel editing of cell
7849 HideCellEditControl();
7850 SaveEditControlValue();
7851
7852 // initialize both of them just to avoid compiler warnings even if only
7853 // really needs to be initialized here
7854 int row,
7855 col;
7856 if ( column )
7857 {
7858 row = -1;
7859 col = colOrRow;
7860 }
7861 else
7862 {
7863 row = colOrRow;
7864 col = -1;
7865 }
7866
7867 wxCoord extent, extentMax = 0;
7868 int max = column ? m_numRows : m_numCols;
7869 for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
7870 {
7871 if ( column )
7872 row = rowOrCol;
7873 else
7874 col = rowOrCol;
7875
7876 // we need to account for the cells spanning multiple columns/rows:
7877 // while they may need a lot of space, they don't need all of it in
7878 // this column/row
7879 int numRows, numCols;
7880 const CellSpan span = GetCellSize(row, col, &numRows, &numCols);
7881 if ( span == CellSpan_Inside )
7882 {
7883 // we need to get the size of the main cell, not of a cell hidden
7884 // by it
7885 row += numRows;
7886 col += numCols;
7887
7888 // get the size of the main cell too
7889 GetCellSize(row, col, &numRows, &numCols);
7890 }
7891
7892 wxGridCellAttr *attr = GetCellAttr(row, col);
7893 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
7894 if ( renderer )
7895 {
7896 wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
7897 extent = column ? size.x : size.y;
7898
7899 if ( span != CellSpan_None )
7900 {
7901 // we spread the size of a spanning cell over all the cells it
7902 // covers evenly -- this is probably not ideal but we can't
7903 // really do much better here
7904 //
7905 // notice that numCols and numRows are never 0 as they
7906 // correspond to the size of the main cell of the span and not
7907 // of the cell inside it
7908 extent /= column ? numCols : numRows;
7909 }
7910
7911 if ( extent > extentMax )
7912 extentMax = extent;
7913
7914 renderer->DecRef();
7915 }
7916
7917 attr->DecRef();
7918 }
7919
7920 // now also compare with the column label extent
7921 wxCoord w, h;
7922 dc.SetFont( GetLabelFont() );
7923
7924 if ( column )
7925 {
7926 dc.GetMultiLineTextExtent( GetColLabelValue(col), &w, &h );
7927 if ( GetColLabelTextOrientation() == wxVERTICAL )
7928 w = h;
7929 }
7930 else
7931 dc.GetMultiLineTextExtent( GetRowLabelValue(row), &w, &h );
7932
7933 extent = column ? w : h;
7934 if ( extent > extentMax )
7935 extentMax = extent;
7936
7937 if ( !extentMax )
7938 {
7939 // empty column - give default extent (notice that if extentMax is less
7940 // than default extent but != 0, it's OK)
7941 extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
7942 }
7943 else
7944 {
7945 if ( column )
7946 // leave some space around text
7947 extentMax += 10;
7948 else
7949 extentMax += 6;
7950 }
7951
7952 if ( column )
7953 {
7954 // Ensure automatic width is not less than minimal width. See the
7955 // comment in SetColSize() for explanation of why this isn't done
7956 // in SetColSize().
7957 if ( !setAsMin )
7958 extentMax = wxMax(extentMax, GetColMinimalWidth(col));
7959
7960 SetColSize( col, extentMax );
7961 if ( !GetBatchCount() )
7962 {
7963 if ( m_useNativeHeader )
7964 {
7965 GetGridColHeader()->UpdateColumn(col);
7966 }
7967 else
7968 {
7969 int cw, ch, dummy;
7970 m_gridWin->GetClientSize( &cw, &ch );
7971 wxRect rect ( CellToRect( 0, col ) );
7972 rect.y = 0;
7973 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
7974 rect.width = cw - rect.x;
7975 rect.height = m_colLabelHeight;
7976 GetColLabelWindow()->Refresh( true, &rect );
7977 }
7978 }
7979 }
7980 else
7981 {
7982 // Ensure automatic width is not less than minimal height. See the
7983 // comment in SetColSize() for explanation of why this isn't done
7984 // in SetRowSize().
7985 if ( !setAsMin )
7986 extentMax = wxMax(extentMax, GetRowMinimalHeight(row));
7987
7988 SetRowSize(row, extentMax);
7989 if ( !GetBatchCount() )
7990 {
7991 int cw, ch, dummy;
7992 m_gridWin->GetClientSize( &cw, &ch );
7993 wxRect rect( CellToRect( row, 0 ) );
7994 rect.x = 0;
7995 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
7996 rect.width = m_rowLabelWidth;
7997 rect.height = ch - rect.y;
7998 m_rowLabelWin->Refresh( true, &rect );
7999 }
8000 }
8001
8002 if ( setAsMin )
8003 {
8004 if ( column )
8005 SetColMinimalWidth(col, extentMax);
8006 else
8007 SetRowMinimalHeight(row, extentMax);
8008 }
8009 }
8010
8011 wxCoord wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction)
8012 {
8013 // calculate size for the rows or columns?
8014 const bool calcRows = direction == wxGRID_ROW;
8015
8016 wxClientDC dc(calcRows ? GetGridRowLabelWindow()
8017 : GetGridColLabelWindow());
8018 dc.SetFont(GetLabelFont());
8019
8020 // which dimension should we take into account for calculations?
8021 //
8022 // for columns, the text can be only horizontal so it's easy but for rows
8023 // we also have to take into account the text orientation
8024 const bool
8025 useWidth = calcRows || (GetColLabelTextOrientation() == wxVERTICAL);
8026
8027 wxArrayString lines;
8028 wxCoord extentMax = 0;
8029
8030 const int numRowsOrCols = calcRows ? m_numRows : m_numCols;
8031 for ( int rowOrCol = 0; rowOrCol < numRowsOrCols; rowOrCol++ )
8032 {
8033 lines.Clear();
8034
8035 wxString label = calcRows ? GetRowLabelValue(rowOrCol)
8036 : GetColLabelValue(rowOrCol);
8037 StringToLines(label, lines);
8038
8039 long w, h;
8040 GetTextBoxSize(dc, lines, &w, &h);
8041
8042 const wxCoord extent = useWidth ? w : h;
8043 if ( extent > extentMax )
8044 extentMax = extent;
8045 }
8046
8047 if ( !extentMax )
8048 {
8049 // empty column - give default extent (notice that if extentMax is less
8050 // than default extent but != 0, it's OK)
8051 extentMax = calcRows ? GetDefaultRowLabelSize()
8052 : GetDefaultColLabelSize();
8053 }
8054
8055 // leave some space around text (taken from AutoSizeColOrRow)
8056 if ( calcRows )
8057 extentMax += 10;
8058 else
8059 extentMax += 6;
8060
8061 return extentMax;
8062 }
8063
8064 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
8065 {
8066 int width = m_rowLabelWidth;
8067
8068 wxGridUpdateLocker locker;
8069 if(!calcOnly)
8070 locker.Create(this);
8071
8072 for ( int col = 0; col < m_numCols; col++ )
8073 {
8074 if ( !calcOnly )
8075 AutoSizeColumn(col, setAsMin);
8076
8077 width += GetColWidth(col);
8078 }
8079
8080 return width;
8081 }
8082
8083 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
8084 {
8085 int height = m_colLabelHeight;
8086
8087 wxGridUpdateLocker locker;
8088 if(!calcOnly)
8089 locker.Create(this);
8090
8091 for ( int row = 0; row < m_numRows; row++ )
8092 {
8093 if ( !calcOnly )
8094 AutoSizeRow(row, setAsMin);
8095
8096 height += GetRowHeight(row);
8097 }
8098
8099 return height;
8100 }
8101
8102 void wxGrid::AutoSize()
8103 {
8104 wxGridUpdateLocker locker(this);
8105
8106 wxSize size(SetOrCalcColumnSizes(false) - m_rowLabelWidth + m_extraWidth,
8107 SetOrCalcRowSizes(false) - m_colLabelHeight + m_extraHeight);
8108
8109 // we know that we're not going to have scrollbars so disable them now to
8110 // avoid trouble in SetClientSize() which can otherwise set the correct
8111 // client size but also leave space for (not needed any more) scrollbars
8112 SetScrollbars(m_xScrollPixelsPerLine, m_yScrollPixelsPerLine,
8113 0, 0, 0, 0, true);
8114
8115 SetClientSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight);
8116 }
8117
8118 void wxGrid::AutoSizeRowLabelSize( int row )
8119 {
8120 // Hide the edit control, so it
8121 // won't interfere with drag-shrinking.
8122 if ( IsCellEditControlShown() )
8123 {
8124 HideCellEditControl();
8125 SaveEditControlValue();
8126 }
8127
8128 // autosize row height depending on label text
8129 SetRowSize(row, -1);
8130 ForceRefresh();
8131 }
8132
8133 void wxGrid::AutoSizeColLabelSize( int col )
8134 {
8135 // Hide the edit control, so it
8136 // won't interfere with drag-shrinking.
8137 if ( IsCellEditControlShown() )
8138 {
8139 HideCellEditControl();
8140 SaveEditControlValue();
8141 }
8142
8143 // autosize column width depending on label text
8144 SetColSize(col, -1);
8145 ForceRefresh();
8146 }
8147
8148 wxSize wxGrid::DoGetBestSize() const
8149 {
8150 wxGrid * const self = const_cast<wxGrid *>(this);
8151
8152 // we do the same as in AutoSize() here with the exception that we don't
8153 // change the column/row sizes, only calculate them
8154 wxSize size(self->SetOrCalcColumnSizes(true) - m_rowLabelWidth + m_extraWidth,
8155 self->SetOrCalcRowSizes(true) - m_colLabelHeight + m_extraHeight);
8156
8157 // NOTE: This size should be cached, but first we need to add calls to
8158 // InvalidateBestSize everywhere that could change the results of this
8159 // calculation.
8160 // CacheBestSize(size);
8161
8162 return wxSize(size.x + m_rowLabelWidth, size.y + m_colLabelHeight)
8163 + GetWindowBorderSize();
8164 }
8165
8166 void wxGrid::Fit()
8167 {
8168 AutoSize();
8169 }
8170
8171 #if WXWIN_COMPATIBILITY_2_8
8172 wxPen& wxGrid::GetDividerPen() const
8173 {
8174 return wxNullPen;
8175 }
8176 #endif // WXWIN_COMPATIBILITY_2_8
8177
8178 // ----------------------------------------------------------------------------
8179 // cell value accessor functions
8180 // ----------------------------------------------------------------------------
8181
8182 void wxGrid::SetCellValue( int row, int col, const wxString& s )
8183 {
8184 if ( m_table )
8185 {
8186 m_table->SetValue( row, col, s );
8187 if ( !GetBatchCount() )
8188 {
8189 int dummy;
8190 wxRect rect( CellToRect( row, col ) );
8191 rect.x = 0;
8192 rect.width = m_gridWin->GetClientSize().GetWidth();
8193 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
8194 m_gridWin->Refresh( false, &rect );
8195 }
8196
8197 if ( m_currentCellCoords.GetRow() == row &&
8198 m_currentCellCoords.GetCol() == col &&
8199 IsCellEditControlShown())
8200 // Note: If we are using IsCellEditControlEnabled,
8201 // this interacts badly with calling SetCellValue from
8202 // an EVT_GRID_CELL_CHANGE handler.
8203 {
8204 HideCellEditControl();
8205 ShowCellEditControl(); // will reread data from table
8206 }
8207 }
8208 }
8209
8210 // ----------------------------------------------------------------------------
8211 // block, row and column selection
8212 // ----------------------------------------------------------------------------
8213
8214 void wxGrid::SelectRow( int row, bool addToSelected )
8215 {
8216 if ( !m_selection )
8217 return;
8218
8219 if ( !addToSelected )
8220 ClearSelection();
8221
8222 m_selection->SelectRow(row);
8223 }
8224
8225 void wxGrid::SelectCol( int col, bool addToSelected )
8226 {
8227 if ( !m_selection )
8228 return;
8229
8230 if ( !addToSelected )
8231 ClearSelection();
8232
8233 m_selection->SelectCol(col);
8234 }
8235
8236 void wxGrid::SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol,
8237 bool addToSelected)
8238 {
8239 if ( !m_selection )
8240 return;
8241
8242 if ( !addToSelected )
8243 ClearSelection();
8244
8245 m_selection->SelectBlock(topRow, leftCol, bottomRow, rightCol);
8246 }
8247
8248 void wxGrid::SelectAll()
8249 {
8250 if ( m_numRows > 0 && m_numCols > 0 )
8251 {
8252 if ( m_selection )
8253 m_selection->SelectBlock( 0, 0, m_numRows - 1, m_numCols - 1 );
8254 }
8255 }
8256
8257 // ----------------------------------------------------------------------------
8258 // cell, row and col deselection
8259 // ----------------------------------------------------------------------------
8260
8261 void wxGrid::DeselectLine(int line, const wxGridOperations& oper)
8262 {
8263 if ( !m_selection )
8264 return;
8265
8266 const wxGridSelectionModes mode = m_selection->GetSelectionMode();
8267 if ( mode == oper.GetSelectionMode() ||
8268 mode == wxGrid::wxGridSelectRowsOrColumns )
8269 {
8270 const wxGridCellCoords c(oper.MakeCoords(line, 0));
8271 if ( m_selection->IsInSelection(c) )
8272 m_selection->ToggleCellSelection(c);
8273 }
8274 else if ( mode != oper.Dual().GetSelectionMode() )
8275 {
8276 const int nOther = oper.Dual().GetNumberOfLines(this);
8277 for ( int i = 0; i < nOther; i++ )
8278 {
8279 const wxGridCellCoords c(oper.MakeCoords(line, i));
8280 if ( m_selection->IsInSelection(c) )
8281 m_selection->ToggleCellSelection(c);
8282 }
8283 }
8284 //else: can only select orthogonal lines so no lines in this direction
8285 // could have been selected anyhow
8286 }
8287
8288 void wxGrid::DeselectRow(int row)
8289 {
8290 DeselectLine(row, wxGridRowOperations());
8291 }
8292
8293 void wxGrid::DeselectCol(int col)
8294 {
8295 DeselectLine(col, wxGridColumnOperations());
8296 }
8297
8298 void wxGrid::DeselectCell( int row, int col )
8299 {
8300 if ( m_selection && m_selection->IsInSelection(row, col) )
8301 m_selection->ToggleCellSelection(row, col);
8302 }
8303
8304 bool wxGrid::IsSelection() const
8305 {
8306 return ( m_selection && (m_selection->IsSelection() ||
8307 ( m_selectedBlockTopLeft != wxGridNoCellCoords &&
8308 m_selectedBlockBottomRight != wxGridNoCellCoords) ) );
8309 }
8310
8311 bool wxGrid::IsInSelection( int row, int col ) const
8312 {
8313 return ( m_selection && (m_selection->IsInSelection( row, col ) ||
8314 ( row >= m_selectedBlockTopLeft.GetRow() &&
8315 col >= m_selectedBlockTopLeft.GetCol() &&
8316 row <= m_selectedBlockBottomRight.GetRow() &&
8317 col <= m_selectedBlockBottomRight.GetCol() )) );
8318 }
8319
8320 wxGridCellCoordsArray wxGrid::GetSelectedCells() const
8321 {
8322 if (!m_selection)
8323 {
8324 wxGridCellCoordsArray a;
8325 return a;
8326 }
8327
8328 return m_selection->m_cellSelection;
8329 }
8330
8331 wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
8332 {
8333 if (!m_selection)
8334 {
8335 wxGridCellCoordsArray a;
8336 return a;
8337 }
8338
8339 return m_selection->m_blockSelectionTopLeft;
8340 }
8341
8342 wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
8343 {
8344 if (!m_selection)
8345 {
8346 wxGridCellCoordsArray a;
8347 return a;
8348 }
8349
8350 return m_selection->m_blockSelectionBottomRight;
8351 }
8352
8353 wxArrayInt wxGrid::GetSelectedRows() const
8354 {
8355 if (!m_selection)
8356 {
8357 wxArrayInt a;
8358 return a;
8359 }
8360
8361 return m_selection->m_rowSelection;
8362 }
8363
8364 wxArrayInt wxGrid::GetSelectedCols() const
8365 {
8366 if (!m_selection)
8367 {
8368 wxArrayInt a;
8369 return a;
8370 }
8371
8372 return m_selection->m_colSelection;
8373 }
8374
8375 void wxGrid::ClearSelection()
8376 {
8377 wxRect r1 = BlockToDeviceRect(m_selectedBlockTopLeft,
8378 m_selectedBlockBottomRight);
8379 wxRect r2 = BlockToDeviceRect(m_currentCellCoords,
8380 m_selectedBlockCorner);
8381
8382 m_selectedBlockTopLeft =
8383 m_selectedBlockBottomRight =
8384 m_selectedBlockCorner = wxGridNoCellCoords;
8385
8386 if ( !r1.IsEmpty() )
8387 RefreshRect(r1, false);
8388 if ( !r2.IsEmpty() )
8389 RefreshRect(r2, false);
8390
8391 if ( m_selection )
8392 m_selection->ClearSelection();
8393 }
8394
8395 // This function returns the rectangle that encloses the given block
8396 // in device coords clipped to the client size of the grid window.
8397 //
8398 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords& topLeft,
8399 const wxGridCellCoords& bottomRight ) const
8400 {
8401 wxRect resultRect;
8402 wxRect tempCellRect = CellToRect(topLeft);
8403 if ( tempCellRect != wxGridNoCellRect )
8404 {
8405 resultRect = tempCellRect;
8406 }
8407 else
8408 {
8409 resultRect = wxRect(0, 0, 0, 0);
8410 }
8411
8412 tempCellRect = CellToRect(bottomRight);
8413 if ( tempCellRect != wxGridNoCellRect )
8414 {
8415 resultRect += tempCellRect;
8416 }
8417 else
8418 {
8419 // If both inputs were "wxGridNoCellRect," then there's nothing to do.
8420 return wxGridNoCellRect;
8421 }
8422
8423 // Ensure that left/right and top/bottom pairs are in order.
8424 int left = resultRect.GetLeft();
8425 int top = resultRect.GetTop();
8426 int right = resultRect.GetRight();
8427 int bottom = resultRect.GetBottom();
8428
8429 int leftCol = topLeft.GetCol();
8430 int topRow = topLeft.GetRow();
8431 int rightCol = bottomRight.GetCol();
8432 int bottomRow = bottomRight.GetRow();
8433
8434 if (left > right)
8435 {
8436 int tmp = left;
8437 left = right;
8438 right = tmp;
8439
8440 tmp = leftCol;
8441 leftCol = rightCol;
8442 rightCol = tmp;
8443 }
8444
8445 if (top > bottom)
8446 {
8447 int tmp = top;
8448 top = bottom;
8449 bottom = tmp;
8450
8451 tmp = topRow;
8452 topRow = bottomRow;
8453 bottomRow = tmp;
8454 }
8455
8456 // The following loop is ONLY necessary to detect and handle merged cells.
8457 int cw, ch;
8458 m_gridWin->GetClientSize( &cw, &ch );
8459
8460 // Get the origin coordinates: notice that they will be negative if the
8461 // grid is scrolled downwards/to the right.
8462 int gridOriginX = 0;
8463 int gridOriginY = 0;
8464 CalcScrolledPosition(gridOriginX, gridOriginY, &gridOriginX, &gridOriginY);
8465
8466 int onScreenLeftmostCol = internalXToCol(-gridOriginX);
8467 int onScreenUppermostRow = internalYToRow(-gridOriginY);
8468
8469 int onScreenRightmostCol = internalXToCol(-gridOriginX + cw);
8470 int onScreenBottommostRow = internalYToRow(-gridOriginY + ch);
8471
8472 // Bound our loop so that we only examine the portion of the selected block
8473 // that is shown on screen. Therefore, we compare the Top-Left block values
8474 // to the Top-Left screen values, and the Bottom-Right block values to the
8475 // Bottom-Right screen values, choosing appropriately.
8476 const int visibleTopRow = wxMax(topRow, onScreenUppermostRow);
8477 const int visibleBottomRow = wxMin(bottomRow, onScreenBottommostRow);
8478 const int visibleLeftCol = wxMax(leftCol, onScreenLeftmostCol);
8479 const int visibleRightCol = wxMin(rightCol, onScreenRightmostCol);
8480
8481 for ( int j = visibleTopRow; j <= visibleBottomRow; j++ )
8482 {
8483 for ( int i = visibleLeftCol; i <= visibleRightCol; i++ )
8484 {
8485 if ( (j == visibleTopRow) || (j == visibleBottomRow) ||
8486 (i == visibleLeftCol) || (i == visibleRightCol) )
8487 {
8488 tempCellRect = CellToRect( j, i );
8489
8490 if (tempCellRect.x < left)
8491 left = tempCellRect.x;
8492 if (tempCellRect.y < top)
8493 top = tempCellRect.y;
8494 if (tempCellRect.x + tempCellRect.width > right)
8495 right = tempCellRect.x + tempCellRect.width;
8496 if (tempCellRect.y + tempCellRect.height > bottom)
8497 bottom = tempCellRect.y + tempCellRect.height;
8498 }
8499 else
8500 {
8501 i = visibleRightCol; // jump over inner cells.
8502 }
8503 }
8504 }
8505
8506 // Convert to scrolled coords
8507 CalcScrolledPosition( left, top, &left, &top );
8508 CalcScrolledPosition( right, bottom, &right, &bottom );
8509
8510 if (right < 0 || bottom < 0 || left > cw || top > ch)
8511 return wxRect(0,0,0,0);
8512
8513 resultRect.SetLeft( wxMax(0, left) );
8514 resultRect.SetTop( wxMax(0, top) );
8515 resultRect.SetRight( wxMin(cw, right) );
8516 resultRect.SetBottom( wxMin(ch, bottom) );
8517
8518 return resultRect;
8519 }
8520
8521 void wxGrid::DoSetSizes(const wxGridSizesInfo& sizeInfo,
8522 const wxGridOperations& oper)
8523 {
8524 BeginBatch();
8525 oper.SetDefaultLineSize(this, sizeInfo.m_sizeDefault, true);
8526 const int numLines = oper.GetNumberOfLines(this);
8527 for ( int i = 0; i < numLines; i++ )
8528 {
8529 int size = sizeInfo.GetSize(i);
8530 if ( size != sizeInfo.m_sizeDefault)
8531 oper.SetLineSize(this, i, size);
8532 }
8533 EndBatch();
8534 }
8535
8536 void wxGrid::SetColSizes(const wxGridSizesInfo& sizeInfo)
8537 {
8538 DoSetSizes(sizeInfo, wxGridColumnOperations());
8539 }
8540
8541 void wxGrid::SetRowSizes(const wxGridSizesInfo& sizeInfo)
8542 {
8543 DoSetSizes(sizeInfo, wxGridRowOperations());
8544 }
8545
8546 wxGridSizesInfo::wxGridSizesInfo(int defSize, const wxArrayInt& allSizes)
8547 {
8548 m_sizeDefault = defSize;
8549 for ( size_t i = 0; i < allSizes.size(); i++ )
8550 {
8551 if ( allSizes[i] != defSize )
8552 m_customSizes[i] = allSizes[i];
8553 }
8554 }
8555
8556 int wxGridSizesInfo::GetSize(unsigned pos) const
8557 {
8558 wxUnsignedToIntHashMap::const_iterator it = m_customSizes.find(pos);
8559
8560 return it == m_customSizes.end() ? m_sizeDefault : it->second;
8561 }
8562
8563 // ----------------------------------------------------------------------------
8564 // drop target
8565 // ----------------------------------------------------------------------------
8566
8567 #if wxUSE_DRAG_AND_DROP
8568
8569 // this allow setting drop target directly on wxGrid
8570 void wxGrid::SetDropTarget(wxDropTarget *dropTarget)
8571 {
8572 GetGridWindow()->SetDropTarget(dropTarget);
8573 }
8574
8575 #endif // wxUSE_DRAG_AND_DROP
8576
8577 // ----------------------------------------------------------------------------
8578 // grid event classes
8579 // ----------------------------------------------------------------------------
8580
8581 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
8582
8583 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
8584 int row, int col, int x, int y, bool sel,
8585 bool control, bool shift, bool alt, bool meta )
8586 : wxNotifyEvent( type, id ),
8587 wxKeyboardState(control, shift, alt, meta)
8588 {
8589 Init(row, col, x, y, sel);
8590
8591 SetEventObject(obj);
8592 }
8593
8594 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent, wxNotifyEvent )
8595
8596 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
8597 int rowOrCol, int x, int y,
8598 bool control, bool shift, bool alt, bool meta )
8599 : wxNotifyEvent( type, id ),
8600 wxKeyboardState(control, shift, alt, meta)
8601 {
8602 Init(rowOrCol, x, y);
8603
8604 SetEventObject(obj);
8605 }
8606
8607
8608 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
8609
8610 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
8611 const wxGridCellCoords& topLeft,
8612 const wxGridCellCoords& bottomRight,
8613 bool sel, bool control,
8614 bool shift, bool alt, bool meta )
8615 : wxNotifyEvent( type, id ),
8616 wxKeyboardState(control, shift, alt, meta)
8617 {
8618 Init(topLeft, bottomRight, sel);
8619
8620 SetEventObject(obj);
8621 }
8622
8623
8624 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
8625
8626 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
8627 wxObject* obj, int row,
8628 int col, wxControl* ctrl)
8629 : wxCommandEvent(type, id)
8630 {
8631 SetEventObject(obj);
8632 m_row = row;
8633 m_col = col;
8634 m_ctrl = ctrl;
8635 }
8636
8637
8638 // ----------------------------------------------------------------------------
8639 // wxGridTypeRegistry
8640 // ----------------------------------------------------------------------------
8641
8642 wxGridTypeRegistry::~wxGridTypeRegistry()
8643 {
8644 size_t count = m_typeinfo.GetCount();
8645 for ( size_t i = 0; i < count; i++ )
8646 delete m_typeinfo[i];
8647 }
8648
8649 void wxGridTypeRegistry::RegisterDataType(const wxString& typeName,
8650 wxGridCellRenderer* renderer,
8651 wxGridCellEditor* editor)
8652 {
8653 wxGridDataTypeInfo* info = new wxGridDataTypeInfo(typeName, renderer, editor);
8654
8655 // is it already registered?
8656 int loc = FindRegisteredDataType(typeName);
8657 if ( loc != wxNOT_FOUND )
8658 {
8659 delete m_typeinfo[loc];
8660 m_typeinfo[loc] = info;
8661 }
8662 else
8663 {
8664 m_typeinfo.Add(info);
8665 }
8666 }
8667
8668 int wxGridTypeRegistry::FindRegisteredDataType(const wxString& typeName)
8669 {
8670 size_t count = m_typeinfo.GetCount();
8671 for ( size_t i = 0; i < count; i++ )
8672 {
8673 if ( typeName == m_typeinfo[i]->m_typeName )
8674 {
8675 return i;
8676 }
8677 }
8678
8679 return wxNOT_FOUND;
8680 }
8681
8682 int wxGridTypeRegistry::FindDataType(const wxString& typeName)
8683 {
8684 int index = FindRegisteredDataType(typeName);
8685 if ( index == wxNOT_FOUND )
8686 {
8687 // check whether this is one of the standard ones, in which case
8688 // register it "on the fly"
8689 #if wxUSE_TEXTCTRL
8690 if ( typeName == wxGRID_VALUE_STRING )
8691 {
8692 RegisterDataType(wxGRID_VALUE_STRING,
8693 new wxGridCellStringRenderer,
8694 new wxGridCellTextEditor);
8695 }
8696 else
8697 #endif // wxUSE_TEXTCTRL
8698 #if wxUSE_CHECKBOX
8699 if ( typeName == wxGRID_VALUE_BOOL )
8700 {
8701 RegisterDataType(wxGRID_VALUE_BOOL,
8702 new wxGridCellBoolRenderer,
8703 new wxGridCellBoolEditor);
8704 }
8705 else
8706 #endif // wxUSE_CHECKBOX
8707 #if wxUSE_TEXTCTRL
8708 if ( typeName == wxGRID_VALUE_NUMBER )
8709 {
8710 RegisterDataType(wxGRID_VALUE_NUMBER,
8711 new wxGridCellNumberRenderer,
8712 new wxGridCellNumberEditor);
8713 }
8714 else if ( typeName == wxGRID_VALUE_FLOAT )
8715 {
8716 RegisterDataType(wxGRID_VALUE_FLOAT,
8717 new wxGridCellFloatRenderer,
8718 new wxGridCellFloatEditor);
8719 }
8720 else
8721 #endif // wxUSE_TEXTCTRL
8722 #if wxUSE_COMBOBOX
8723 if ( typeName == wxGRID_VALUE_CHOICE )
8724 {
8725 RegisterDataType(wxGRID_VALUE_CHOICE,
8726 new wxGridCellStringRenderer,
8727 new wxGridCellChoiceEditor);
8728 }
8729 else
8730 #endif // wxUSE_COMBOBOX
8731 {
8732 return wxNOT_FOUND;
8733 }
8734
8735 // we get here only if just added the entry for this type, so return
8736 // the last index
8737 index = m_typeinfo.GetCount() - 1;
8738 }
8739
8740 return index;
8741 }
8742
8743 int wxGridTypeRegistry::FindOrCloneDataType(const wxString& typeName)
8744 {
8745 int index = FindDataType(typeName);
8746 if ( index == wxNOT_FOUND )
8747 {
8748 // the first part of the typename is the "real" type, anything after ':'
8749 // are the parameters for the renderer
8750 index = FindDataType(typeName.BeforeFirst(wxT(':')));
8751 if ( index == wxNOT_FOUND )
8752 {
8753 return wxNOT_FOUND;
8754 }
8755
8756 wxGridCellRenderer *renderer = GetRenderer(index);
8757 wxGridCellRenderer *rendererOld = renderer;
8758 renderer = renderer->Clone();
8759 rendererOld->DecRef();
8760
8761 wxGridCellEditor *editor = GetEditor(index);
8762 wxGridCellEditor *editorOld = editor;
8763 editor = editor->Clone();
8764 editorOld->DecRef();
8765
8766 // do it even if there are no parameters to reset them to defaults
8767 wxString params = typeName.AfterFirst(wxT(':'));
8768 renderer->SetParameters(params);
8769 editor->SetParameters(params);
8770
8771 // register the new typename
8772 RegisterDataType(typeName, renderer, editor);
8773
8774 // we just registered it, it's the last one
8775 index = m_typeinfo.GetCount() - 1;
8776 }
8777
8778 return index;
8779 }
8780
8781 wxGridCellRenderer* wxGridTypeRegistry::GetRenderer(int index)
8782 {
8783 wxGridCellRenderer* renderer = m_typeinfo[index]->m_renderer;
8784 if (renderer)
8785 renderer->IncRef();
8786
8787 return renderer;
8788 }
8789
8790 wxGridCellEditor* wxGridTypeRegistry::GetEditor(int index)
8791 {
8792 wxGridCellEditor* editor = m_typeinfo[index]->m_editor;
8793 if (editor)
8794 editor->IncRef();
8795
8796 return editor;
8797 }
8798
8799 #endif // wxUSE_GRID
wxWidgets (Impactor)