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