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