]> git.saurik.com Git - wxWidgets.git/blob - src/generic/grid.cpp
projects / wxWidgets.git / blob
? search:


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