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