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