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