]> 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
allow untranslated accelerators, too
[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 m_minAcceptableColWidth, \
3752 m_colRights, m_numCols, TRUE)
3753 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
3754 m_minAcceptableRowHeight, \
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 m_minAcceptableColWidth = WXGRID_MIN_COL_WIDTH;
3982 m_minAcceptableRowHeight = WXGRID_MIN_ROW_HEIGHT;
3983
3984 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
3985 m_defaultRowHeight += 8;
3986 #else
3987 m_defaultRowHeight += 4;
3988 #endif
3989
3990 m_gridLineColour = wxColour( 192,192,192 );
3991 m_gridLinesEnabled = TRUE;
3992 m_cellHighlightColour = *wxBLACK;
3993 m_cellHighlightPenWidth = 2;
3994 m_cellHighlightROPenWidth = 1;
3995
3996 m_cursorMode = WXGRID_CURSOR_SELECT_CELL;
3997 m_winCapture = (wxWindow *)NULL;
3998 m_canDragRowSize = TRUE;
3999 m_canDragColSize = TRUE;
4000 m_canDragGridSize = TRUE;
4001 m_dragLastPos = -1;
4002 m_dragRowOrCol = -1;
4003 m_isDragging = FALSE;
4004 m_startDragPos = wxDefaultPosition;
4005
4006 m_waitForSlowClick = FALSE;
4007
4008 m_rowResizeCursor = wxCursor( wxCURSOR_SIZENS );
4009 m_colResizeCursor = wxCursor( wxCURSOR_SIZEWE );
4010
4011 m_currentCellCoords = wxGridNoCellCoords;
4012
4013 m_selectingTopLeft = wxGridNoCellCoords;
4014 m_selectingBottomRight = wxGridNoCellCoords;
4015 m_selectionBackground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
4016 m_selectionForeground = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
4017
4018 m_editable = TRUE; // default for whole grid
4019
4020 m_inOnKeyDown = FALSE;
4021 m_batchCount = 0;
4022
4023 m_extraWidth =
4024 m_extraHeight = 0;
4025 }
4026
4027 // ----------------------------------------------------------------------------
4028 // the idea is to call these functions only when necessary because they create
4029 // quite big arrays which eat memory mostly unnecessary - in particular, if
4030 // default widths/heights are used for all rows/columns, we may not use these
4031 // arrays at all
4032 //
4033 // with some extra code, it should be possible to only store the
4034 // widths/heights different from default ones but this will be done later...
4035 // ----------------------------------------------------------------------------
4036
4037 void wxGrid::InitRowHeights()
4038 {
4039 m_rowHeights.Empty();
4040 m_rowBottoms.Empty();
4041
4042 m_rowHeights.Alloc( m_numRows );
4043 m_rowBottoms.Alloc( m_numRows );
4044
4045 int rowBottom = 0;
4046
4047 m_rowHeights.Add( m_defaultRowHeight, m_numRows );
4048
4049 for ( int i = 0; i < m_numRows; i++ )
4050 {
4051 rowBottom += m_defaultRowHeight;
4052 m_rowBottoms.Add( rowBottom );
4053 }
4054 }
4055
4056 void wxGrid::InitColWidths()
4057 {
4058 m_colWidths.Empty();
4059 m_colRights.Empty();
4060
4061 m_colWidths.Alloc( m_numCols );
4062 m_colRights.Alloc( m_numCols );
4063 int colRight = 0;
4064
4065 m_colWidths.Add( m_defaultColWidth, m_numCols );
4066
4067 for ( int i = 0; i < m_numCols; i++ )
4068 {
4069 colRight += m_defaultColWidth;
4070 m_colRights.Add( colRight );
4071 }
4072 }
4073
4074 int wxGrid::GetColWidth(int col) const
4075 {
4076 return m_colWidths.IsEmpty() ? m_defaultColWidth : m_colWidths[col];
4077 }
4078
4079 int wxGrid::GetColLeft(int col) const
4080 {
4081 return m_colRights.IsEmpty() ? col * m_defaultColWidth
4082 : m_colRights[col] - m_colWidths[col];
4083 }
4084
4085 int wxGrid::GetColRight(int col) const
4086 {
4087 return m_colRights.IsEmpty() ? (col + 1) * m_defaultColWidth
4088 : m_colRights[col];
4089 }
4090
4091 int wxGrid::GetRowHeight(int row) const
4092 {
4093 return m_rowHeights.IsEmpty() ? m_defaultRowHeight : m_rowHeights[row];
4094 }
4095
4096 int wxGrid::GetRowTop(int row) const
4097 {
4098 return m_rowBottoms.IsEmpty() ? row * m_defaultRowHeight
4099 : m_rowBottoms[row] - m_rowHeights[row];
4100 }
4101
4102 int wxGrid::GetRowBottom(int row) const
4103 {
4104 return m_rowBottoms.IsEmpty() ? (row + 1) * m_defaultRowHeight
4105 : m_rowBottoms[row];
4106 }
4107
4108 void wxGrid::CalcDimensions()
4109 {
4110 int cw, ch;
4111 GetClientSize( &cw, &ch );
4112
4113 if ( m_rowLabelWin->IsShown() )
4114 cw -= m_rowLabelWidth;
4115 if ( m_colLabelWin->IsShown() )
4116 ch -= m_colLabelHeight;
4117
4118 // grid total size
4119 int w = m_numCols > 0 ? GetColRight(m_numCols - 1) + m_extraWidth + 1 : 0;
4120 int h = m_numRows > 0 ? GetRowBottom(m_numRows - 1) + m_extraHeight + 1 : 0;
4121
4122 // take into account editor if shown
4123 if( IsCellEditControlShown() )
4124 {
4125 int w2, h2;
4126 int r = m_currentCellCoords.GetRow();
4127 int c = m_currentCellCoords.GetCol();
4128 int x = GetColLeft(c);
4129 int y = GetRowTop(r);
4130
4131 // how big is the editor
4132 wxGridCellAttr* attr = GetCellAttr(r, c);
4133 wxGridCellEditor* editor = attr->GetEditor(this, r, c);
4134 editor->GetControl()->GetSize(&w2, &h2);
4135 w2 += x;
4136 h2 += y;
4137 if( w2 > w ) w = w2;
4138 if( h2 > h ) h = h2;
4139 editor->DecRef();
4140 attr->DecRef();
4141 }
4142
4143 // preserve (more or less) the previous position
4144 int x, y;
4145 GetViewStart( &x, &y );
4146
4147 // maybe we don't need scrollbars at all?
4148 //
4149 // also adjust the position to be valid for the new scroll rangs
4150 if ( w <= cw )
4151 {
4152 w = x = 0;
4153 }
4154 else
4155 {
4156 if ( x >= w )
4157 x = w - 1;
4158 }
4159
4160 if ( h <= ch )
4161 {
4162 h = y = 0;
4163 }
4164 else
4165 {
4166 if ( y >= h )
4167 y = h - 1;
4168 }
4169
4170 // do set scrollbar parameters
4171 SetScrollbars( GRID_SCROLL_LINE_X, GRID_SCROLL_LINE_Y,
4172 GetScrollX(w), GetScrollY(h), x, y,
4173 GetBatchCount() != 0);
4174
4175 // if our OnSize() hadn't been called (it would if we have scrollbars), we
4176 // still must reposition the children
4177 CalcWindowSizes();
4178 }
4179
4180
4181 void wxGrid::CalcWindowSizes()
4182 {
4183 int cw, ch;
4184 GetClientSize( &cw, &ch );
4185
4186 if ( m_cornerLabelWin->IsShown() )
4187 m_cornerLabelWin->SetSize( 0, 0, m_rowLabelWidth, m_colLabelHeight );
4188
4189 if ( m_colLabelWin->IsShown() )
4190 m_colLabelWin->SetSize( m_rowLabelWidth, 0, cw-m_rowLabelWidth, m_colLabelHeight);
4191
4192 if ( m_rowLabelWin->IsShown() )
4193 m_rowLabelWin->SetSize( 0, m_colLabelHeight, m_rowLabelWidth, ch-m_colLabelHeight);
4194
4195 if ( m_gridWin->IsShown() )
4196 m_gridWin->SetSize( m_rowLabelWidth, m_colLabelHeight, cw-m_rowLabelWidth, ch-m_colLabelHeight);
4197 }
4198
4199
4200 // this is called when the grid table sends a message to say that it
4201 // has been redimensioned
4202 //
4203 bool wxGrid::Redimension( wxGridTableMessage& msg )
4204 {
4205 int i;
4206 bool result = FALSE;
4207
4208 // Clear the attribute cache as the attribute might refer to a different
4209 // cell than stored in the cache after adding/removing rows/columns.
4210 ClearAttrCache();
4211 // By the same reasoning, the editor should be dismissed if columns are
4212 // added or removed. And for consistency, it should IMHO always be
4213 // removed, not only if the cell "underneath" it actually changes.
4214 // For now, I intentionally do not save the editor's content as the
4215 // cell it might want to save that stuff to might no longer exist.
4216 HideCellEditControl();
4217 #if 0
4218 // if we were using the default widths/heights so far, we must change them
4219 // now
4220 if ( m_colWidths.IsEmpty() )
4221 {
4222 InitColWidths();
4223 }
4224
4225 if ( m_rowHeights.IsEmpty() )
4226 {
4227 InitRowHeights();
4228 }
4229 #endif
4230
4231 switch ( msg.GetId() )
4232 {
4233 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
4234 {
4235 size_t pos = msg.GetCommandInt();
4236 int numRows = msg.GetCommandInt2();
4237
4238 m_numRows += numRows;
4239
4240 if ( !m_rowHeights.IsEmpty() )
4241 {
4242 m_rowHeights.Insert( m_defaultRowHeight, pos, numRows );
4243 m_rowBottoms.Insert( 0, pos, numRows );
4244
4245 int bottom = 0;
4246 if ( pos > 0 ) bottom = m_rowBottoms[pos-1];
4247
4248 for ( i = pos; i < m_numRows; i++ )
4249 {
4250 bottom += m_rowHeights[i];
4251 m_rowBottoms[i] = bottom;
4252 }
4253 }
4254 if ( m_currentCellCoords == wxGridNoCellCoords )
4255 {
4256 // if we have just inserted cols into an empty grid the current
4257 // cell will be undefined...
4258 //
4259 SetCurrentCell( 0, 0 );
4260 }
4261
4262 if ( m_selection )
4263 m_selection->UpdateRows( pos, numRows );
4264 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4265 if (attrProvider)
4266 attrProvider->UpdateAttrRows( pos, numRows );
4267
4268 if ( !GetBatchCount() )
4269 {
4270 CalcDimensions();
4271 m_rowLabelWin->Refresh();
4272 }
4273 }
4274 result = TRUE;
4275 break;
4276
4277 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
4278 {
4279 int numRows = msg.GetCommandInt();
4280 int oldNumRows = m_numRows;
4281 m_numRows += numRows;
4282
4283 if ( !m_rowHeights.IsEmpty() )
4284 {
4285 m_rowHeights.Add( m_defaultRowHeight, numRows );
4286 m_rowBottoms.Add( 0, numRows );
4287
4288 int bottom = 0;
4289 if ( oldNumRows > 0 ) bottom = m_rowBottoms[oldNumRows-1];
4290
4291 for ( i = oldNumRows; i < m_numRows; i++ )
4292 {
4293 bottom += m_rowHeights[i];
4294 m_rowBottoms[i] = bottom;
4295 }
4296 }
4297 if ( m_currentCellCoords == wxGridNoCellCoords )
4298 {
4299 // if we have just inserted cols into an empty grid the current
4300 // cell will be undefined...
4301 //
4302 SetCurrentCell( 0, 0 );
4303 }
4304 if ( !GetBatchCount() )
4305 {
4306 CalcDimensions();
4307 m_rowLabelWin->Refresh();
4308 }
4309 }
4310 result = TRUE;
4311 break;
4312
4313 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
4314 {
4315 size_t pos = msg.GetCommandInt();
4316 int numRows = msg.GetCommandInt2();
4317 m_numRows -= numRows;
4318
4319 if ( !m_rowHeights.IsEmpty() )
4320 {
4321 m_rowHeights.RemoveAt( pos, numRows );
4322 m_rowBottoms.RemoveAt( pos, numRows );
4323
4324 int h = 0;
4325 for ( i = 0; i < m_numRows; i++ )
4326 {
4327 h += m_rowHeights[i];
4328 m_rowBottoms[i] = h;
4329 }
4330 }
4331 if ( !m_numRows )
4332 {
4333 m_currentCellCoords = wxGridNoCellCoords;
4334 }
4335 else
4336 {
4337 if ( m_currentCellCoords.GetRow() >= m_numRows )
4338 m_currentCellCoords.Set( 0, 0 );
4339 }
4340
4341 if ( m_selection )
4342 m_selection->UpdateRows( pos, -((int)numRows) );
4343 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4344 if (attrProvider) {
4345 attrProvider->UpdateAttrRows( pos, -((int)numRows) );
4346 // ifdef'd out following patch from Paul Gammans
4347 #if 0
4348 // No need to touch column attributes, unless we
4349 // removed _all_ rows, in this case, we remove
4350 // all column attributes.
4351 // I hate to do this here, but the
4352 // needed data is not available inside UpdateAttrRows.
4353 if ( !GetNumberRows() )
4354 attrProvider->UpdateAttrCols( 0, -GetNumberCols() );
4355 #endif
4356 }
4357 if ( !GetBatchCount() )
4358 {
4359 CalcDimensions();
4360 m_rowLabelWin->Refresh();
4361 }
4362 }
4363 result = TRUE;
4364 break;
4365
4366 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
4367 {
4368 size_t pos = msg.GetCommandInt();
4369 int numCols = msg.GetCommandInt2();
4370 m_numCols += numCols;
4371
4372 if ( !m_colWidths.IsEmpty() )
4373 {
4374 m_colWidths.Insert( m_defaultColWidth, pos, numCols );
4375 m_colRights.Insert( 0, pos, numCols );
4376
4377 int right = 0;
4378 if ( pos > 0 ) right = m_colRights[pos-1];
4379
4380 for ( i = pos; i < m_numCols; i++ )
4381 {
4382 right += m_colWidths[i];
4383 m_colRights[i] = right;
4384 }
4385 }
4386 if ( m_currentCellCoords == wxGridNoCellCoords )
4387 {
4388 // if we have just inserted cols into an empty grid the current
4389 // cell will be undefined...
4390 //
4391 SetCurrentCell( 0, 0 );
4392 }
4393
4394 if ( m_selection )
4395 m_selection->UpdateCols( pos, numCols );
4396 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4397 if (attrProvider)
4398 attrProvider->UpdateAttrCols( pos, numCols );
4399 if ( !GetBatchCount() )
4400 {
4401 CalcDimensions();
4402 m_colLabelWin->Refresh();
4403 }
4404
4405 }
4406 result = TRUE;
4407 break;
4408
4409 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
4410 {
4411 int numCols = msg.GetCommandInt();
4412 int oldNumCols = m_numCols;
4413 m_numCols += numCols;
4414 if ( !m_colWidths.IsEmpty() )
4415 {
4416 m_colWidths.Add( m_defaultColWidth, numCols );
4417 m_colRights.Add( 0, numCols );
4418
4419 int right = 0;
4420 if ( oldNumCols > 0 ) right = m_colRights[oldNumCols-1];
4421
4422 for ( i = oldNumCols; i < m_numCols; i++ )
4423 {
4424 right += m_colWidths[i];
4425 m_colRights[i] = right;
4426 }
4427 }
4428 if ( m_currentCellCoords == wxGridNoCellCoords )
4429 {
4430 // if we have just inserted cols into an empty grid the current
4431 // cell will be undefined...
4432 //
4433 SetCurrentCell( 0, 0 );
4434 }
4435 if ( !GetBatchCount() )
4436 {
4437 CalcDimensions();
4438 m_colLabelWin->Refresh();
4439 }
4440 }
4441 result = TRUE;
4442 break;
4443
4444 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
4445 {
4446 size_t pos = msg.GetCommandInt();
4447 int numCols = msg.GetCommandInt2();
4448 m_numCols -= numCols;
4449
4450 if ( !m_colWidths.IsEmpty() )
4451 {
4452 m_colWidths.RemoveAt( pos, numCols );
4453 m_colRights.RemoveAt( pos, numCols );
4454
4455 int w = 0;
4456 for ( i = 0; i < m_numCols; i++ )
4457 {
4458 w += m_colWidths[i];
4459 m_colRights[i] = w;
4460 }
4461 }
4462 if ( !m_numCols )
4463 {
4464 m_currentCellCoords = wxGridNoCellCoords;
4465 }
4466 else
4467 {
4468 if ( m_currentCellCoords.GetCol() >= m_numCols )
4469 m_currentCellCoords.Set( 0, 0 );
4470 }
4471
4472 if ( m_selection )
4473 m_selection->UpdateCols( pos, -((int)numCols) );
4474 wxGridCellAttrProvider * attrProvider = m_table->GetAttrProvider();
4475 if (attrProvider) {
4476 attrProvider->UpdateAttrCols( pos, -((int)numCols) );
4477 // ifdef'd out following patch from Paul Gammans
4478 #if 0
4479 // No need to touch row attributes, unless we
4480 // removed _all_ columns, in this case, we remove
4481 // all row attributes.
4482 // I hate to do this here, but the
4483 // needed data is not available inside UpdateAttrCols.
4484 if ( !GetNumberCols() )
4485 attrProvider->UpdateAttrRows( 0, -GetNumberRows() );
4486 #endif
4487 }
4488 if ( !GetBatchCount() )
4489 {
4490 CalcDimensions();
4491 m_colLabelWin->Refresh();
4492 }
4493 }
4494 result = TRUE;
4495 break;
4496 }
4497
4498 if (result && !GetBatchCount() )
4499 m_gridWin->Refresh();
4500 return result;
4501 }
4502
4503
4504 wxArrayInt wxGrid::CalcRowLabelsExposed( const wxRegion& reg )
4505 {
4506 wxRegionIterator iter( reg );
4507 wxRect r;
4508
4509 wxArrayInt rowlabels;
4510
4511 int top, bottom;
4512 while ( iter )
4513 {
4514 r = iter.GetRect();
4515
4516 // TODO: remove this when we can...
4517 // There is a bug in wxMotif that gives garbage update
4518 // rectangles if you jump-scroll a long way by clicking the
4519 // scrollbar with middle button. This is a work-around
4520 //
4521 #if defined(__WXMOTIF__)
4522 int cw, ch;
4523 m_gridWin->GetClientSize( &cw, &ch );
4524 if ( r.GetTop() > ch ) r.SetTop( 0 );
4525 r.SetBottom( wxMin( r.GetBottom(), ch ) );
4526 #endif
4527
4528 // logical bounds of update region
4529 //
4530 int dummy;
4531 CalcUnscrolledPosition( 0, r.GetTop(), &dummy, &top );
4532 CalcUnscrolledPosition( 0, r.GetBottom(), &dummy, &bottom );
4533
4534 // find the row labels within these bounds
4535 //
4536 int row;
4537 for ( row = internalYToRow(top); row < m_numRows; row++ )
4538 {
4539 if ( GetRowBottom(row) < top )
4540 continue;
4541
4542 if ( GetRowTop(row) > bottom )
4543 break;
4544
4545 rowlabels.Add( row );
4546 }
4547
4548 iter++ ;
4549 }
4550
4551 return rowlabels;
4552 }
4553
4554
4555 wxArrayInt wxGrid::CalcColLabelsExposed( const wxRegion& reg )
4556 {
4557 wxRegionIterator iter( reg );
4558 wxRect r;
4559
4560 wxArrayInt colLabels;
4561
4562 int left, right;
4563 while ( iter )
4564 {
4565 r = iter.GetRect();
4566
4567 // TODO: remove this when we can...
4568 // There is a bug in wxMotif that gives garbage update
4569 // rectangles if you jump-scroll a long way by clicking the
4570 // scrollbar with middle button. This is a work-around
4571 //
4572 #if defined(__WXMOTIF__)
4573 int cw, ch;
4574 m_gridWin->GetClientSize( &cw, &ch );
4575 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4576 r.SetRight( wxMin( r.GetRight(), cw ) );
4577 #endif
4578
4579 // logical bounds of update region
4580 //
4581 int dummy;
4582 CalcUnscrolledPosition( r.GetLeft(), 0, &left, &dummy );
4583 CalcUnscrolledPosition( r.GetRight(), 0, &right, &dummy );
4584
4585 // find the cells within these bounds
4586 //
4587 int col;
4588 for ( col = internalXToCol(left); col < m_numCols; col++ )
4589 {
4590 if ( GetColRight(col) < left )
4591 continue;
4592
4593 if ( GetColLeft(col) > right )
4594 break;
4595
4596 colLabels.Add( col );
4597 }
4598
4599 iter++ ;
4600 }
4601 return colLabels;
4602 }
4603
4604
4605 wxGridCellCoordsArray wxGrid::CalcCellsExposed( const wxRegion& reg )
4606 {
4607 wxRegionIterator iter( reg );
4608 wxRect r;
4609
4610 wxGridCellCoordsArray cellsExposed;
4611
4612 int left, top, right, bottom;
4613 while ( iter )
4614 {
4615 r = iter.GetRect();
4616
4617 // TODO: remove this when we can...
4618 // There is a bug in wxMotif that gives garbage update
4619 // rectangles if you jump-scroll a long way by clicking the
4620 // scrollbar with middle button. This is a work-around
4621 //
4622 #if defined(__WXMOTIF__)
4623 int cw, ch;
4624 m_gridWin->GetClientSize( &cw, &ch );
4625 if ( r.GetTop() > ch ) r.SetTop( 0 );
4626 if ( r.GetLeft() > cw ) r.SetLeft( 0 );
4627 r.SetRight( wxMin( r.GetRight(), cw ) );
4628 r.SetBottom( wxMin( r.GetBottom(), ch ) );
4629 #endif
4630
4631 // logical bounds of update region
4632 //
4633 CalcUnscrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
4634 CalcUnscrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
4635
4636 // find the cells within these bounds
4637 //
4638 int row, col;
4639 for ( row = internalYToRow(top); row < m_numRows; row++ )
4640 {
4641 if ( GetRowBottom(row) <= top )
4642 continue;
4643
4644 if ( GetRowTop(row) > bottom )
4645 break;
4646
4647 for ( col = internalXToCol(left); col < m_numCols; col++ )
4648 {
4649 if ( GetColRight(col) <= left )
4650 continue;
4651
4652 if ( GetColLeft(col) > right )
4653 break;
4654
4655 cellsExposed.Add( wxGridCellCoords( row, col ) );
4656 }
4657 }
4658
4659 iter++;
4660 }
4661
4662 return cellsExposed;
4663 }
4664
4665
4666 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent& event )
4667 {
4668 int x, y, row;
4669 wxPoint pos( event.GetPosition() );
4670 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4671
4672 if ( event.Dragging() )
4673 {
4674 if (!m_isDragging)
4675 {
4676 m_isDragging = TRUE;
4677 m_rowLabelWin->CaptureMouse();
4678 }
4679
4680 if ( event.LeftIsDown() )
4681 {
4682 switch( m_cursorMode )
4683 {
4684 case WXGRID_CURSOR_RESIZE_ROW:
4685 {
4686 int cw, ch, left, dummy;
4687 m_gridWin->GetClientSize( &cw, &ch );
4688 CalcUnscrolledPosition( 0, 0, &left, &dummy );
4689
4690 wxClientDC dc( m_gridWin );
4691 PrepareDC( dc );
4692 y = wxMax( y,
4693 GetRowTop(m_dragRowOrCol) +
4694 GetRowMinimalHeight(m_dragRowOrCol) );
4695 dc.SetLogicalFunction(wxINVERT);
4696 if ( m_dragLastPos >= 0 )
4697 {
4698 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
4699 }
4700 dc.DrawLine( left, y, left+cw, y );
4701 m_dragLastPos = y;
4702 }
4703 break;
4704
4705 case WXGRID_CURSOR_SELECT_ROW:
4706 if ( (row = YToRow( y )) >= 0 )
4707 {
4708 if ( m_selection )
4709 {
4710 m_selection->SelectRow( row,
4711 event.ControlDown(),
4712 event.ShiftDown(),
4713 event.AltDown(),
4714 event.MetaDown() );
4715 }
4716 }
4717
4718 // default label to suppress warnings about "enumeration value
4719 // 'xxx' not handled in switch
4720 default:
4721 break;
4722 }
4723 }
4724 return;
4725 }
4726
4727 if ( m_isDragging && (event.Entering() || event.Leaving()) )
4728 return;
4729
4730 if (m_isDragging)
4731 {
4732 if (m_rowLabelWin->HasCapture()) m_rowLabelWin->ReleaseMouse();
4733 m_isDragging = FALSE;
4734 }
4735
4736 // ------------ Entering or leaving the window
4737 //
4738 if ( event.Entering() || event.Leaving() )
4739 {
4740 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4741 }
4742
4743
4744 // ------------ Left button pressed
4745 //
4746 else if ( event.LeftDown() )
4747 {
4748 // don't send a label click event for a hit on the
4749 // edge of the row label - this is probably the user
4750 // wanting to resize the row
4751 //
4752 if ( YToEdgeOfRow(y) < 0 )
4753 {
4754 row = YToRow(y);
4755 if ( row >= 0 &&
4756 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, row, -1, event ) )
4757 {
4758 if ( !event.ShiftDown() && !event.ControlDown() )
4759 ClearSelection();
4760 if ( m_selection )
4761 {
4762 if ( event.ShiftDown() )
4763 {
4764 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
4765 0,
4766 row,
4767 GetNumberCols() - 1,
4768 event.ControlDown(),
4769 event.ShiftDown(),
4770 event.AltDown(),
4771 event.MetaDown() );
4772 }
4773 else
4774 {
4775 m_selection->SelectRow( row,
4776 event.ControlDown(),
4777 event.ShiftDown(),
4778 event.AltDown(),
4779 event.MetaDown() );
4780 }
4781 }
4782
4783 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW, m_rowLabelWin);
4784 }
4785 }
4786 else
4787 {
4788 // starting to drag-resize a row
4789 //
4790 if ( CanDragRowSize() )
4791 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin);
4792 }
4793 }
4794
4795
4796 // ------------ Left double click
4797 //
4798 else if (event.LeftDClick() )
4799 {
4800 int row = YToEdgeOfRow(y);
4801 if ( row < 0 )
4802 {
4803 row = YToRow(y);
4804 if ( row >=0 &&
4805 !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, row, -1, event ) )
4806 {
4807 // no default action at the moment
4808 }
4809 }
4810 else
4811 {
4812 // adjust row height depending on label text
4813 AutoSizeRowLabelSize( row );
4814
4815 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4816 m_dragLastPos = -1;
4817 }
4818 }
4819
4820
4821 // ------------ Left button released
4822 //
4823 else if ( event.LeftUp() )
4824 {
4825 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
4826 {
4827 DoEndDragResizeRow();
4828
4829 // Note: we are ending the event *after* doing
4830 // default processing in this case
4831 //
4832 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
4833 }
4834
4835 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin);
4836 m_dragLastPos = -1;
4837 }
4838
4839
4840 // ------------ Right button down
4841 //
4842 else if ( event.RightDown() )
4843 {
4844 row = YToRow(y);
4845 if ( row >=0 &&
4846 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, row, -1, event ) )
4847 {
4848 // no default action at the moment
4849 }
4850 }
4851
4852
4853 // ------------ Right double click
4854 //
4855 else if ( event.RightDClick() )
4856 {
4857 row = YToRow(y);
4858 if ( row >= 0 &&
4859 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, row, -1, event ) )
4860 {
4861 // no default action at the moment
4862 }
4863 }
4864
4865
4866 // ------------ No buttons down and mouse moving
4867 //
4868 else if ( event.Moving() )
4869 {
4870 m_dragRowOrCol = YToEdgeOfRow( y );
4871 if ( m_dragRowOrCol >= 0 )
4872 {
4873 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
4874 {
4875 // don't capture the mouse yet
4876 if ( CanDragRowSize() )
4877 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW, m_rowLabelWin, FALSE);
4878 }
4879 }
4880 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
4881 {
4882 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_rowLabelWin, FALSE);
4883 }
4884 }
4885 }
4886
4887
4888 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent& event )
4889 {
4890 int x, y, col;
4891 wxPoint pos( event.GetPosition() );
4892 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
4893
4894 if ( event.Dragging() )
4895 {
4896 if (!m_isDragging)
4897 {
4898 m_isDragging = TRUE;
4899 m_colLabelWin->CaptureMouse();
4900 }
4901
4902 if ( event.LeftIsDown() )
4903 {
4904 switch( m_cursorMode )
4905 {
4906 case WXGRID_CURSOR_RESIZE_COL:
4907 {
4908 int cw, ch, dummy, top;
4909 m_gridWin->GetClientSize( &cw, &ch );
4910 CalcUnscrolledPosition( 0, 0, &dummy, &top );
4911
4912 wxClientDC dc( m_gridWin );
4913 PrepareDC( dc );
4914
4915 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
4916 GetColMinimalWidth(m_dragRowOrCol));
4917 dc.SetLogicalFunction(wxINVERT);
4918 if ( m_dragLastPos >= 0 )
4919 {
4920 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
4921 }
4922 dc.DrawLine( x, top, x, top+ch );
4923 m_dragLastPos = x;
4924 }
4925 break;
4926
4927 case WXGRID_CURSOR_SELECT_COL:
4928 if ( (col = XToCol( x )) >= 0 )
4929 {
4930 if ( m_selection )
4931 {
4932 m_selection->SelectCol( col,
4933 event.ControlDown(),
4934 event.ShiftDown(),
4935 event.AltDown(),
4936 event.MetaDown() );
4937 }
4938 }
4939
4940 // default label to suppress warnings about "enumeration value
4941 // 'xxx' not handled in switch
4942 default:
4943 break;
4944 }
4945 }
4946 return;
4947 }
4948
4949 if ( m_isDragging && (event.Entering() || event.Leaving()) )
4950 return;
4951
4952 if (m_isDragging)
4953 {
4954 if (m_colLabelWin->HasCapture()) m_colLabelWin->ReleaseMouse();
4955 m_isDragging = FALSE;
4956 }
4957
4958 // ------------ Entering or leaving the window
4959 //
4960 if ( event.Entering() || event.Leaving() )
4961 {
4962 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
4963 }
4964
4965
4966 // ------------ Left button pressed
4967 //
4968 else if ( event.LeftDown() )
4969 {
4970 // don't send a label click event for a hit on the
4971 // edge of the col label - this is probably the user
4972 // wanting to resize the col
4973 //
4974 if ( XToEdgeOfCol(x) < 0 )
4975 {
4976 col = XToCol(x);
4977 if ( col >= 0 &&
4978 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, col, event ) )
4979 {
4980 if ( !event.ShiftDown() && !event.ControlDown() )
4981 ClearSelection();
4982 if ( m_selection )
4983 {
4984 if ( event.ShiftDown() )
4985 {
4986 m_selection->SelectBlock( 0,
4987 m_currentCellCoords.GetCol(),
4988 GetNumberRows() - 1, col,
4989 event.ControlDown(),
4990 event.ShiftDown(),
4991 event.AltDown(),
4992 event.MetaDown() );
4993 }
4994 else
4995 {
4996 m_selection->SelectCol( col,
4997 event.ControlDown(),
4998 event.ShiftDown(),
4999 event.AltDown(),
5000 event.MetaDown() );
5001 }
5002 }
5003
5004 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL, m_colLabelWin);
5005 }
5006 }
5007 else
5008 {
5009 // starting to drag-resize a col
5010 //
5011 if ( CanDragColSize() )
5012 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin);
5013 }
5014 }
5015
5016
5017 // ------------ Left double click
5018 //
5019 if ( event.LeftDClick() )
5020 {
5021 int col = XToEdgeOfCol(x);
5022 if ( col < 0 )
5023 {
5024 col = XToCol(x);
5025 if ( col >= 0 &&
5026 ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, col, event ) )
5027 {
5028 // no default action at the moment
5029 }
5030 }
5031 else
5032 {
5033 // adjust column width depending on label text
5034 AutoSizeColLabelSize( col );
5035
5036 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5037 m_dragLastPos = -1;
5038 }
5039 }
5040
5041
5042 // ------------ Left button released
5043 //
5044 else if ( event.LeftUp() )
5045 {
5046 if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5047 {
5048 DoEndDragResizeCol();
5049
5050 // Note: we are ending the event *after* doing
5051 // default processing in this case
5052 //
5053 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5054 }
5055
5056 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin);
5057 m_dragLastPos = -1;
5058 }
5059
5060
5061 // ------------ Right button down
5062 //
5063 else if ( event.RightDown() )
5064 {
5065 col = XToCol(x);
5066 if ( col >= 0 &&
5067 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, col, event ) )
5068 {
5069 // no default action at the moment
5070 }
5071 }
5072
5073
5074 // ------------ Right double click
5075 //
5076 else if ( event.RightDClick() )
5077 {
5078 col = XToCol(x);
5079 if ( col >= 0 &&
5080 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, col, event ) )
5081 {
5082 // no default action at the moment
5083 }
5084 }
5085
5086
5087 // ------------ No buttons down and mouse moving
5088 //
5089 else if ( event.Moving() )
5090 {
5091 m_dragRowOrCol = XToEdgeOfCol( x );
5092 if ( m_dragRowOrCol >= 0 )
5093 {
5094 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5095 {
5096 // don't capture the cursor yet
5097 if ( CanDragColSize() )
5098 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL, m_colLabelWin, FALSE);
5099 }
5100 }
5101 else if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5102 {
5103 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL, m_colLabelWin, FALSE);
5104 }
5105 }
5106 }
5107
5108
5109 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent& event )
5110 {
5111 if ( event.LeftDown() )
5112 {
5113 // indicate corner label by having both row and
5114 // col args == -1
5115 //
5116 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK, -1, -1, event ) )
5117 {
5118 SelectAll();
5119 }
5120 }
5121
5122 else if ( event.LeftDClick() )
5123 {
5124 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK, -1, -1, event );
5125 }
5126
5127 else if ( event.RightDown() )
5128 {
5129 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK, -1, -1, event ) )
5130 {
5131 // no default action at the moment
5132 }
5133 }
5134
5135 else if ( event.RightDClick() )
5136 {
5137 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK, -1, -1, event ) )
5138 {
5139 // no default action at the moment
5140 }
5141 }
5142 }
5143
5144 void wxGrid::ChangeCursorMode(CursorMode mode,
5145 wxWindow *win,
5146 bool captureMouse)
5147 {
5148 #ifdef __WXDEBUG__
5149 static const wxChar *cursorModes[] =
5150 {
5151 _T("SELECT_CELL"),
5152 _T("RESIZE_ROW"),
5153 _T("RESIZE_COL"),
5154 _T("SELECT_ROW"),
5155 _T("SELECT_COL")
5156 };
5157
5158 wxLogTrace(_T("grid"),
5159 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
5160 win == m_colLabelWin ? _T("colLabelWin")
5161 : win ? _T("rowLabelWin")
5162 : _T("gridWin"),
5163 cursorModes[m_cursorMode], cursorModes[mode]);
5164 #endif // __WXDEBUG__
5165
5166 if ( mode == m_cursorMode &&
5167 win == m_winCapture &&
5168 captureMouse == (m_winCapture != NULL))
5169 return;
5170
5171 if ( !win )
5172 {
5173 // by default use the grid itself
5174 win = m_gridWin;
5175 }
5176
5177 if ( m_winCapture )
5178 {
5179 if (m_winCapture->HasCapture()) m_winCapture->ReleaseMouse();
5180 m_winCapture = (wxWindow *)NULL;
5181 }
5182
5183 m_cursorMode = mode;
5184
5185 switch ( m_cursorMode )
5186 {
5187 case WXGRID_CURSOR_RESIZE_ROW:
5188 win->SetCursor( m_rowResizeCursor );
5189 break;
5190
5191 case WXGRID_CURSOR_RESIZE_COL:
5192 win->SetCursor( m_colResizeCursor );
5193 break;
5194
5195 default:
5196 win->SetCursor( *wxSTANDARD_CURSOR );
5197 }
5198
5199 // we need to capture mouse when resizing
5200 bool resize = m_cursorMode == WXGRID_CURSOR_RESIZE_ROW ||
5201 m_cursorMode == WXGRID_CURSOR_RESIZE_COL;
5202
5203 if ( captureMouse && resize )
5204 {
5205 win->CaptureMouse();
5206 m_winCapture = win;
5207 }
5208 }
5209
5210 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent& event )
5211 {
5212 int x, y;
5213 wxPoint pos( event.GetPosition() );
5214 CalcUnscrolledPosition( pos.x, pos.y, &x, &y );
5215
5216 wxGridCellCoords coords;
5217 XYToCell( x, y, coords );
5218
5219 int cell_rows, cell_cols;
5220 GetCellSize( coords.GetRow(), coords.GetCol(), &cell_rows, &cell_cols );
5221 if ((cell_rows < 0) || (cell_cols < 0))
5222 {
5223 coords.SetRow(coords.GetRow() + cell_rows);
5224 coords.SetCol(coords.GetCol() + cell_cols);
5225 }
5226
5227 if ( event.Dragging() )
5228 {
5229 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
5230
5231 // Don't start doing anything until the mouse has been drug at
5232 // least 3 pixels in any direction...
5233 if (! m_isDragging)
5234 {
5235 if (m_startDragPos == wxDefaultPosition)
5236 {
5237 m_startDragPos = pos;
5238 return;
5239 }
5240 if (abs(m_startDragPos.x - pos.x) < 4 && abs(m_startDragPos.y - pos.y) < 4)
5241 return;
5242 }
5243
5244 m_isDragging = TRUE;
5245 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5246 {
5247 // Hide the edit control, so it
5248 // won't interfer with drag-shrinking.
5249 if ( IsCellEditControlShown() )
5250 {
5251 HideCellEditControl();
5252 SaveEditControlValue();
5253 }
5254
5255 // Have we captured the mouse yet?
5256 if (! m_winCapture)
5257 {
5258 m_winCapture = m_gridWin;
5259 m_winCapture->CaptureMouse();
5260 }
5261
5262 if ( coords != wxGridNoCellCoords )
5263 {
5264 if ( event.ControlDown() )
5265 {
5266 if ( m_selectingKeyboard == wxGridNoCellCoords)
5267 m_selectingKeyboard = coords;
5268 HighlightBlock ( m_selectingKeyboard, coords );
5269 }
5270 else
5271 {
5272 if ( !IsSelection() )
5273 {
5274 HighlightBlock( coords, coords );
5275 }
5276 else
5277 {
5278 HighlightBlock( m_currentCellCoords, coords );
5279 }
5280 }
5281
5282 if (! IsVisible(coords))
5283 {
5284 MakeCellVisible(coords);
5285 // TODO: need to introduce a delay or something here. The
5286 // scrolling is way to fast, at least on MSW - also on GTK.
5287 }
5288 }
5289 }
5290 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5291 {
5292 int cw, ch, left, dummy;
5293 m_gridWin->GetClientSize( &cw, &ch );
5294 CalcUnscrolledPosition( 0, 0, &left, &dummy );
5295
5296 wxClientDC dc( m_gridWin );
5297 PrepareDC( dc );
5298 y = wxMax( y, GetRowTop(m_dragRowOrCol) +
5299 GetRowMinimalHeight(m_dragRowOrCol) );
5300 dc.SetLogicalFunction(wxINVERT);
5301 if ( m_dragLastPos >= 0 )
5302 {
5303 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5304 }
5305 dc.DrawLine( left, y, left+cw, y );
5306 m_dragLastPos = y;
5307 }
5308 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5309 {
5310 int cw, ch, dummy, top;
5311 m_gridWin->GetClientSize( &cw, &ch );
5312 CalcUnscrolledPosition( 0, 0, &dummy, &top );
5313
5314 wxClientDC dc( m_gridWin );
5315 PrepareDC( dc );
5316 x = wxMax( x, GetColLeft(m_dragRowOrCol) +
5317 GetColMinimalWidth(m_dragRowOrCol) );
5318 dc.SetLogicalFunction(wxINVERT);
5319 if ( m_dragLastPos >= 0 )
5320 {
5321 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5322 }
5323 dc.DrawLine( x, top, x, top+ch );
5324 m_dragLastPos = x;
5325 }
5326
5327 return;
5328 }
5329
5330 m_isDragging = FALSE;
5331 m_startDragPos = wxDefaultPosition;
5332
5333 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
5334 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
5335 // wxGTK
5336 #if 0
5337 if ( event.Entering() || event.Leaving() )
5338 {
5339 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5340 m_gridWin->SetCursor( *wxSTANDARD_CURSOR );
5341 }
5342 else
5343 #endif // 0
5344
5345 // ------------ Left button pressed
5346 //
5347 if ( event.LeftDown() && coords != wxGridNoCellCoords )
5348 {
5349 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK,
5350 coords.GetRow(),
5351 coords.GetCol(),
5352 event ) )
5353 {
5354 if ( !event.ControlDown() )
5355 ClearSelection();
5356 if ( event.ShiftDown() )
5357 {
5358 if ( m_selection )
5359 {
5360 m_selection->SelectBlock( m_currentCellCoords.GetRow(),
5361 m_currentCellCoords.GetCol(),
5362 coords.GetRow(),
5363 coords.GetCol(),
5364 event.ControlDown(),
5365 event.ShiftDown(),
5366 event.AltDown(),
5367 event.MetaDown() );
5368 }
5369 }
5370 else if ( XToEdgeOfCol(x) < 0 &&
5371 YToEdgeOfRow(y) < 0 )
5372 {
5373 DisableCellEditControl();
5374 MakeCellVisible( coords );
5375
5376 if ( event.ControlDown() )
5377 {
5378 if ( m_selection )
5379 {
5380 m_selection->ToggleCellSelection( coords.GetRow(),
5381 coords.GetCol(),
5382 event.ControlDown(),
5383 event.ShiftDown(),
5384 event.AltDown(),
5385 event.MetaDown() );
5386 }
5387 m_selectingTopLeft = wxGridNoCellCoords;
5388 m_selectingBottomRight = wxGridNoCellCoords;
5389 m_selectingKeyboard = coords;
5390 }
5391 else
5392 {
5393 m_waitForSlowClick = m_currentCellCoords == coords && coords != wxGridNoCellCoords;
5394 SetCurrentCell( coords );
5395 if ( m_selection )
5396 {
5397 if ( m_selection->GetSelectionMode() !=
5398 wxGrid::wxGridSelectCells )
5399 {
5400 HighlightBlock( coords, coords );
5401 }
5402 }
5403 }
5404 }
5405 }
5406 }
5407
5408
5409 // ------------ Left double click
5410 //
5411 else if ( event.LeftDClick() && coords != wxGridNoCellCoords )
5412 {
5413 DisableCellEditControl();
5414
5415 if ( XToEdgeOfCol(x) < 0 && YToEdgeOfRow(y) < 0 )
5416 {
5417 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK,
5418 coords.GetRow(),
5419 coords.GetCol(),
5420 event );
5421 }
5422 }
5423
5424
5425 // ------------ Left button released
5426 //
5427 else if ( event.LeftUp() )
5428 {
5429 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5430 {
5431 if (m_winCapture)
5432 {
5433 if (m_winCapture->HasCapture()) m_winCapture->ReleaseMouse();
5434 m_winCapture = NULL;
5435 }
5436
5437 if ( coords == m_currentCellCoords && m_waitForSlowClick && CanEnableCellControl())
5438 {
5439 ClearSelection();
5440 EnableCellEditControl();
5441
5442 wxGridCellAttr* attr = GetCellAttr(coords);
5443 wxGridCellEditor *editor = attr->GetEditor(this, coords.GetRow(), coords.GetCol());
5444 editor->StartingClick();
5445 editor->DecRef();
5446 attr->DecRef();
5447
5448 m_waitForSlowClick = FALSE;
5449 }
5450 else if ( m_selectingTopLeft != wxGridNoCellCoords &&
5451 m_selectingBottomRight != wxGridNoCellCoords )
5452 {
5453 if ( m_selection )
5454 {
5455 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
5456 m_selectingTopLeft.GetCol(),
5457 m_selectingBottomRight.GetRow(),
5458 m_selectingBottomRight.GetCol(),
5459 event.ControlDown(),
5460 event.ShiftDown(),
5461 event.AltDown(),
5462 event.MetaDown() );
5463 }
5464
5465 m_selectingTopLeft = wxGridNoCellCoords;
5466 m_selectingBottomRight = wxGridNoCellCoords;
5467
5468 // Show the edit control, if it has been hidden for
5469 // drag-shrinking.
5470 ShowCellEditControl();
5471 }
5472 }
5473 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_ROW )
5474 {
5475 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5476 DoEndDragResizeRow();
5477
5478 // Note: we are ending the event *after* doing
5479 // default processing in this case
5480 //
5481 SendEvent( wxEVT_GRID_ROW_SIZE, m_dragRowOrCol, -1, event );
5482 }
5483 else if ( m_cursorMode == WXGRID_CURSOR_RESIZE_COL )
5484 {
5485 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5486 DoEndDragResizeCol();
5487
5488 // Note: we are ending the event *after* doing
5489 // default processing in this case
5490 //
5491 SendEvent( wxEVT_GRID_COL_SIZE, -1, m_dragRowOrCol, event );
5492 }
5493
5494 m_dragLastPos = -1;
5495 }
5496
5497
5498 // ------------ Right button down
5499 //
5500 else if ( event.RightDown() && coords != wxGridNoCellCoords )
5501 {
5502 DisableCellEditControl();
5503 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK,
5504 coords.GetRow(),
5505 coords.GetCol(),
5506 event ) )
5507 {
5508 // no default action at the moment
5509 }
5510 }
5511
5512
5513 // ------------ Right double click
5514 //
5515 else if ( event.RightDClick() && coords != wxGridNoCellCoords )
5516 {
5517 DisableCellEditControl();
5518 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK,
5519 coords.GetRow(),
5520 coords.GetCol(),
5521 event ) )
5522 {
5523 // no default action at the moment
5524 }
5525 }
5526
5527 // ------------ Moving and no button action
5528 //
5529 else if ( event.Moving() && !event.IsButton() )
5530 {
5531 if( coords.GetRow() < 0 || coords.GetCol() < 0 )
5532 {
5533 // out of grid cell area
5534 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5535 return;
5536 }
5537
5538 int dragRow = YToEdgeOfRow( y );
5539 int dragCol = XToEdgeOfCol( x );
5540
5541 // Dragging on the corner of a cell to resize in both
5542 // directions is not implemented yet...
5543 //
5544 if ( dragRow >= 0 && dragCol >= 0 )
5545 {
5546 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5547 return;
5548 }
5549
5550 if ( dragRow >= 0 )
5551 {
5552 m_dragRowOrCol = dragRow;
5553
5554 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5555 {
5556 if ( CanDragRowSize() && CanDragGridSize() )
5557 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW);
5558 }
5559
5560 if ( dragCol >= 0 )
5561 {
5562 m_dragRowOrCol = dragCol;
5563 }
5564
5565 return;
5566 }
5567
5568 if ( dragCol >= 0 )
5569 {
5570 m_dragRowOrCol = dragCol;
5571
5572 if ( m_cursorMode == WXGRID_CURSOR_SELECT_CELL )
5573 {
5574 if ( CanDragColSize() && CanDragGridSize() )
5575 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL);
5576 }
5577
5578 return;
5579 }
5580
5581 // Neither on a row or col edge
5582 //
5583 if ( m_cursorMode != WXGRID_CURSOR_SELECT_CELL )
5584 {
5585 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL);
5586 }
5587 }
5588 }
5589
5590
5591 void wxGrid::DoEndDragResizeRow()
5592 {
5593 if ( m_dragLastPos >= 0 )
5594 {
5595 // erase the last line and resize the row
5596 //
5597 int cw, ch, left, dummy;
5598 m_gridWin->GetClientSize( &cw, &ch );
5599 CalcUnscrolledPosition( 0, 0, &left, &dummy );
5600
5601 wxClientDC dc( m_gridWin );
5602 PrepareDC( dc );
5603 dc.SetLogicalFunction( wxINVERT );
5604 dc.DrawLine( left, m_dragLastPos, left+cw, m_dragLastPos );
5605 HideCellEditControl();
5606 SaveEditControlValue();
5607
5608 int rowTop = GetRowTop(m_dragRowOrCol);
5609 SetRowSize( m_dragRowOrCol,
5610 wxMax( m_dragLastPos - rowTop, m_minAcceptableRowHeight ) );
5611
5612 if ( !GetBatchCount() )
5613 {
5614 // Only needed to get the correct rect.y:
5615 wxRect rect ( CellToRect( m_dragRowOrCol, 0 ) );
5616 rect.x = 0;
5617 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5618 rect.width = m_rowLabelWidth;
5619 rect.height = ch - rect.y;
5620 m_rowLabelWin->Refresh( TRUE, &rect );
5621 rect.width = cw;
5622 // if there is a multicell block, paint all of it
5623 if (m_table)
5624 {
5625 int i, cell_rows, cell_cols, subtract_rows = 0;
5626 int leftCol = XToCol(left);
5627 int rightCol = internalXToCol(left+cw);
5628 if (leftCol >= 0)
5629 {
5630 for (i=leftCol; i<rightCol; i++)
5631 {
5632 GetCellSize(m_dragRowOrCol, i, &cell_rows, &cell_cols);
5633 if (cell_rows < subtract_rows)
5634 subtract_rows = cell_rows;
5635 }
5636 rect.y = GetRowTop(m_dragRowOrCol + subtract_rows);
5637 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
5638 rect.height = ch - rect.y;
5639 }
5640 }
5641 m_gridWin->Refresh( FALSE, &rect );
5642 }
5643
5644 ShowCellEditControl();
5645 }
5646 }
5647
5648
5649 void wxGrid::DoEndDragResizeCol()
5650 {
5651 if ( m_dragLastPos >= 0 )
5652 {
5653 // erase the last line and resize the col
5654 //
5655 int cw, ch, dummy, top;
5656 m_gridWin->GetClientSize( &cw, &ch );
5657 CalcUnscrolledPosition( 0, 0, &dummy, &top );
5658
5659 wxClientDC dc( m_gridWin );
5660 PrepareDC( dc );
5661 dc.SetLogicalFunction( wxINVERT );
5662 dc.DrawLine( m_dragLastPos, top, m_dragLastPos, top+ch );
5663 HideCellEditControl();
5664 SaveEditControlValue();
5665
5666 int colLeft = GetColLeft(m_dragRowOrCol);
5667 SetColSize( m_dragRowOrCol,
5668 wxMax( m_dragLastPos - colLeft,
5669 GetColMinimalWidth(m_dragRowOrCol) ) );
5670
5671 if ( !GetBatchCount() )
5672 {
5673 // Only needed to get the correct rect.x:
5674 wxRect rect ( CellToRect( 0, m_dragRowOrCol ) );
5675 rect.y = 0;
5676 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5677 rect.width = cw - rect.x;
5678 rect.height = m_colLabelHeight;
5679 m_colLabelWin->Refresh( TRUE, &rect );
5680 rect.height = ch;
5681 // if there is a multicell block, paint all of it
5682 if (m_table)
5683 {
5684 int i, cell_rows, cell_cols, subtract_cols = 0;
5685 int topRow = YToRow(top);
5686 int bottomRow = internalYToRow(top+cw);
5687 if (topRow >= 0)
5688 {
5689 for (i=topRow; i<bottomRow; i++)
5690 {
5691 GetCellSize(i, m_dragRowOrCol, &cell_rows, &cell_cols);
5692 if (cell_cols < subtract_cols)
5693 subtract_cols = cell_cols;
5694 }
5695 rect.x = GetColLeft(m_dragRowOrCol + subtract_cols);
5696 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
5697 rect.width = cw - rect.x;
5698 }
5699 }
5700 m_gridWin->Refresh( FALSE, &rect );
5701 }
5702
5703 ShowCellEditControl();
5704 }
5705 }
5706
5707
5708
5709 //
5710 // ------ interaction with data model
5711 //
5712 bool wxGrid::ProcessTableMessage( wxGridTableMessage& msg )
5713 {
5714 switch ( msg.GetId() )
5715 {
5716 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES:
5717 return GetModelValues();
5718
5719 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES:
5720 return SetModelValues();
5721
5722 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED:
5723 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED:
5724 case wxGRIDTABLE_NOTIFY_ROWS_DELETED:
5725 case wxGRIDTABLE_NOTIFY_COLS_INSERTED:
5726 case wxGRIDTABLE_NOTIFY_COLS_APPENDED:
5727 case wxGRIDTABLE_NOTIFY_COLS_DELETED:
5728 return Redimension( msg );
5729
5730 default:
5731 return FALSE;
5732 }
5733 }
5734
5735
5736
5737 // The behaviour of this function depends on the grid table class
5738 // Clear() function. For the default wxGridStringTable class the
5739 // behavious is to replace all cell contents with wxEmptyString but
5740 // not to change the number of rows or cols.
5741 //
5742 void wxGrid::ClearGrid()
5743 {
5744 if ( m_table )
5745 {
5746 if (IsCellEditControlEnabled())
5747 DisableCellEditControl();
5748
5749 m_table->Clear();
5750 if ( !GetBatchCount() ) m_gridWin->Refresh();
5751 }
5752 }
5753
5754
5755 bool wxGrid::InsertRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5756 {
5757 // TODO: something with updateLabels flag
5758
5759 if ( !m_created )
5760 {
5761 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5762 return FALSE;
5763 }
5764
5765 if ( m_table )
5766 {
5767 if (IsCellEditControlEnabled())
5768 DisableCellEditControl();
5769
5770 return m_table->InsertRows( pos, numRows );
5771
5772 // the table will have sent the results of the insert row
5773 // operation to this view object as a grid table message
5774 }
5775 return FALSE;
5776 }
5777
5778
5779 bool wxGrid::AppendRows( int numRows, bool WXUNUSED(updateLabels) )
5780 {
5781 // TODO: something with updateLabels flag
5782
5783 if ( !m_created )
5784 {
5785 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5786 return FALSE;
5787 }
5788
5789 return ( m_table && m_table->AppendRows( numRows ) );
5790 // the table will have sent the results of the append row
5791 // operation to this view object as a grid table message
5792 }
5793
5794
5795 bool wxGrid::DeleteRows( int pos, int numRows, bool WXUNUSED(updateLabels) )
5796 {
5797 // TODO: something with updateLabels flag
5798
5799 if ( !m_created )
5800 {
5801 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5802 return FALSE;
5803 }
5804
5805 if ( m_table )
5806 {
5807 if (IsCellEditControlEnabled())
5808 DisableCellEditControl();
5809
5810 return (m_table->DeleteRows( pos, numRows ));
5811 // the table will have sent the results of the delete row
5812 // operation to this view object as a grid table message
5813 }
5814 return FALSE;
5815 }
5816
5817
5818 bool wxGrid::InsertCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5819 {
5820 // TODO: something with updateLabels flag
5821
5822 if ( !m_created )
5823 {
5824 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5825 return FALSE;
5826 }
5827
5828 if ( m_table )
5829 {
5830 if (IsCellEditControlEnabled())
5831 DisableCellEditControl();
5832
5833 return m_table->InsertCols( pos, numCols );
5834 // the table will have sent the results of the insert col
5835 // operation to this view object as a grid table message
5836 }
5837 return FALSE;
5838 }
5839
5840
5841 bool wxGrid::AppendCols( int numCols, bool WXUNUSED(updateLabels) )
5842 {
5843 // TODO: something with updateLabels flag
5844
5845 if ( !m_created )
5846 {
5847 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5848 return FALSE;
5849 }
5850
5851 return ( m_table && m_table->AppendCols( numCols ) );
5852 // the table will have sent the results of the append col
5853 // operation to this view object as a grid table message
5854 }
5855
5856
5857 bool wxGrid::DeleteCols( int pos, int numCols, bool WXUNUSED(updateLabels) )
5858 {
5859 // TODO: something with updateLabels flag
5860
5861 if ( !m_created )
5862 {
5863 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5864 return FALSE;
5865 }
5866
5867 if ( m_table )
5868 {
5869 if (IsCellEditControlEnabled())
5870 DisableCellEditControl();
5871
5872 return ( m_table->DeleteCols( pos, numCols ) );
5873 // the table will have sent the results of the delete col
5874 // operation to this view object as a grid table message
5875 }
5876 return FALSE;
5877 }
5878
5879
5880
5881 //
5882 // ----- event handlers
5883 //
5884
5885 // Generate a grid event based on a mouse event and
5886 // return the result of ProcessEvent()
5887 //
5888 int wxGrid::SendEvent( const wxEventType type,
5889 int row, int col,
5890 wxMouseEvent& mouseEv )
5891 {
5892 bool claimed;
5893 bool vetoed= FALSE;
5894
5895 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5896 {
5897 int rowOrCol = (row == -1 ? col : row);
5898
5899 wxGridSizeEvent gridEvt( GetId(),
5900 type,
5901 this,
5902 rowOrCol,
5903 mouseEv.GetX() + GetRowLabelSize(),
5904 mouseEv.GetY() + GetColLabelSize(),
5905 mouseEv.ControlDown(),
5906 mouseEv.ShiftDown(),
5907 mouseEv.AltDown(),
5908 mouseEv.MetaDown() );
5909
5910 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5911 vetoed = !gridEvt.IsAllowed();
5912 }
5913 else if ( type == wxEVT_GRID_RANGE_SELECT )
5914 {
5915 // Right now, it should _never_ end up here!
5916 wxGridRangeSelectEvent gridEvt( GetId(),
5917 type,
5918 this,
5919 m_selectingTopLeft,
5920 m_selectingBottomRight,
5921 TRUE,
5922 mouseEv.ControlDown(),
5923 mouseEv.ShiftDown(),
5924 mouseEv.AltDown(),
5925 mouseEv.MetaDown() );
5926
5927 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5928 vetoed = !gridEvt.IsAllowed();
5929 }
5930 else
5931 {
5932 wxGridEvent gridEvt( GetId(),
5933 type,
5934 this,
5935 row, col,
5936 mouseEv.GetX() + GetRowLabelSize(),
5937 mouseEv.GetY() + GetColLabelSize(),
5938 FALSE,
5939 mouseEv.ControlDown(),
5940 mouseEv.ShiftDown(),
5941 mouseEv.AltDown(),
5942 mouseEv.MetaDown() );
5943 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5944 vetoed = !gridEvt.IsAllowed();
5945 }
5946
5947 // A Veto'd event may not be `claimed' so test this first
5948 if (vetoed) return -1;
5949 return claimed ? 1 : 0;
5950 }
5951
5952
5953 // Generate a grid event of specified type and return the result
5954 // of ProcessEvent().
5955 //
5956 int wxGrid::SendEvent( const wxEventType type,
5957 int row, int col )
5958 {
5959 bool claimed;
5960 bool vetoed= FALSE;
5961
5962 if ( type == wxEVT_GRID_ROW_SIZE || type == wxEVT_GRID_COL_SIZE )
5963 {
5964 int rowOrCol = (row == -1 ? col : row);
5965
5966 wxGridSizeEvent gridEvt( GetId(),
5967 type,
5968 this,
5969 rowOrCol );
5970
5971 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5972 vetoed = !gridEvt.IsAllowed();
5973 }
5974 else
5975 {
5976 wxGridEvent gridEvt( GetId(),
5977 type,
5978 this,
5979 row, col );
5980
5981 claimed = GetEventHandler()->ProcessEvent(gridEvt);
5982 vetoed = !gridEvt.IsAllowed();
5983 }
5984
5985 // A Veto'd event may not be `claimed' so test this first
5986 if (vetoed) return -1;
5987 return claimed ? 1 : 0;
5988 }
5989
5990
5991 void wxGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
5992 {
5993 wxPaintDC dc(this); // needed to prevent zillions of paint events on MSW
5994 }
5995
5996 void wxGrid::Refresh(bool eraseb, const wxRect* rect)
5997 {
5998 // Don't do anything if between Begin/EndBatch...
5999 // EndBatch() will do all this on the last nested one anyway.
6000 if (! GetBatchCount())
6001 {
6002 // Refresh to get correct scrolled position:
6003 wxScrolledWindow::Refresh(eraseb,rect);
6004
6005 if (rect)
6006 {
6007 int rect_x, rect_y, rectWidth, rectHeight;
6008 int width_label, width_cell, height_label, height_cell;
6009 int x, y;
6010
6011 //Copy rectangle can get scroll offsets..
6012 rect_x = rect->GetX();
6013 rect_y = rect->GetY();
6014 rectWidth = rect->GetWidth();
6015 rectHeight = rect->GetHeight();
6016
6017 width_label = m_rowLabelWidth - rect_x;
6018 if (width_label > rectWidth) width_label = rectWidth;
6019
6020 height_label = m_colLabelHeight - rect_y;
6021 if (height_label > rectHeight) height_label = rectHeight;
6022
6023 if (rect_x > m_rowLabelWidth)
6024 {
6025 x = rect_x - m_rowLabelWidth;
6026 width_cell = rectWidth;
6027 }
6028 else
6029 {
6030 x = 0;
6031 width_cell = rectWidth - (m_rowLabelWidth - rect_x);
6032 }
6033
6034 if (rect_y > m_colLabelHeight)
6035 {
6036 y = rect_y - m_colLabelHeight;
6037 height_cell = rectHeight;
6038 }
6039 else
6040 {
6041 y = 0;
6042 height_cell = rectHeight - (m_colLabelHeight - rect_y);
6043 }
6044
6045 // Paint corner label part intersecting rect.
6046 if ( width_label > 0 && height_label > 0 )
6047 {
6048 wxRect anotherrect(rect_x, rect_y, width_label, height_label);
6049 m_cornerLabelWin->Refresh(eraseb, &anotherrect);
6050 }
6051
6052 // Paint col labels part intersecting rect.
6053 if ( width_cell > 0 && height_label > 0 )
6054 {
6055 wxRect anotherrect(x, rect_y, width_cell, height_label);
6056 m_colLabelWin->Refresh(eraseb, &anotherrect);
6057 }
6058
6059 // Paint row labels part intersecting rect.
6060 if ( width_label > 0 && height_cell > 0 )
6061 {
6062 wxRect anotherrect(rect_x, y, width_label, height_cell);
6063 m_rowLabelWin->Refresh(eraseb, &anotherrect);
6064 }
6065
6066 // Paint cell area part intersecting rect.
6067 if ( width_cell > 0 && height_cell > 0 )
6068 {
6069 wxRect anotherrect(x, y, width_cell, height_cell);
6070 m_gridWin->Refresh(eraseb, &anotherrect);
6071 }
6072 }
6073 else
6074 {
6075 m_cornerLabelWin->Refresh(eraseb, NULL);
6076 m_colLabelWin->Refresh(eraseb, NULL);
6077 m_rowLabelWin->Refresh(eraseb, NULL);
6078 m_gridWin->Refresh(eraseb, NULL);
6079 }
6080 }
6081 }
6082
6083 void wxGrid::OnSize( wxSizeEvent& event )
6084 {
6085 // position the child windows
6086 CalcWindowSizes();
6087
6088 // don't call CalcDimensions() from here, the base class handles the size
6089 // changes itself
6090 event.Skip();
6091 }
6092
6093
6094 void wxGrid::OnKeyDown( wxKeyEvent& event )
6095 {
6096 if ( m_inOnKeyDown )
6097 {
6098 // shouldn't be here - we are going round in circles...
6099 //
6100 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
6101 }
6102
6103 m_inOnKeyDown = TRUE;
6104
6105 // propagate the event up and see if it gets processed
6106 //
6107 wxWindow *parent = GetParent();
6108 wxKeyEvent keyEvt( event );
6109 keyEvt.SetEventObject( parent );
6110
6111 if ( !parent->GetEventHandler()->ProcessEvent( keyEvt ) )
6112 {
6113
6114 // try local handlers
6115 //
6116 switch ( event.GetKeyCode() )
6117 {
6118 case WXK_UP:
6119 if ( event.ControlDown() )
6120 {
6121 MoveCursorUpBlock( event.ShiftDown() );
6122 }
6123 else
6124 {
6125 MoveCursorUp( event.ShiftDown() );
6126 }
6127 break;
6128
6129 case WXK_DOWN:
6130 if ( event.ControlDown() )
6131 {
6132 MoveCursorDownBlock( event.ShiftDown() );
6133 }
6134 else
6135 {
6136 MoveCursorDown( event.ShiftDown() );
6137 }
6138 break;
6139
6140 case WXK_LEFT:
6141 if ( event.ControlDown() )
6142 {
6143 MoveCursorLeftBlock( event.ShiftDown() );
6144 }
6145 else
6146 {
6147 MoveCursorLeft( event.ShiftDown() );
6148 }
6149 break;
6150
6151 case WXK_RIGHT:
6152 if ( event.ControlDown() )
6153 {
6154 MoveCursorRightBlock( event.ShiftDown() );
6155 }
6156 else
6157 {
6158 MoveCursorRight( event.ShiftDown() );
6159 }
6160 break;
6161
6162 case WXK_RETURN:
6163 case WXK_NUMPAD_ENTER:
6164 if ( event.ControlDown() )
6165 {
6166 event.Skip(); // to let the edit control have the return
6167 }
6168 else
6169 {
6170 if ( GetGridCursorRow() < GetNumberRows()-1 )
6171 {
6172 MoveCursorDown( event.ShiftDown() );
6173 }
6174 else
6175 {
6176 // at the bottom of a column
6177 HideCellEditControl();
6178 SaveEditControlValue();
6179 }
6180 }
6181 break;
6182
6183 case WXK_ESCAPE:
6184 ClearSelection();
6185 break;
6186
6187 case WXK_TAB:
6188 if (event.ShiftDown())
6189 {
6190 if ( GetGridCursorCol() > 0 )
6191 {
6192 MoveCursorLeft( FALSE );
6193 }
6194 else
6195 {
6196 // at left of grid
6197 HideCellEditControl();
6198 SaveEditControlValue();
6199 }
6200 }
6201 else
6202 {
6203 if ( GetGridCursorCol() < GetNumberCols()-1 )
6204 {
6205 MoveCursorRight( FALSE );
6206 }
6207 else
6208 {
6209 // at right of grid
6210 HideCellEditControl();
6211 SaveEditControlValue();
6212 }
6213 }
6214 break;
6215
6216 case WXK_HOME:
6217 if ( event.ControlDown() )
6218 {
6219 MakeCellVisible( 0, 0 );
6220 SetCurrentCell( 0, 0 );
6221 }
6222 else
6223 {
6224 event.Skip();
6225 }
6226 break;
6227
6228 case WXK_END:
6229 if ( event.ControlDown() )
6230 {
6231 MakeCellVisible( m_numRows-1, m_numCols-1 );
6232 SetCurrentCell( m_numRows-1, m_numCols-1 );
6233 }
6234 else
6235 {
6236 event.Skip();
6237 }
6238 break;
6239
6240 case WXK_PRIOR:
6241 MovePageUp();
6242 break;
6243
6244 case WXK_NEXT:
6245 MovePageDown();
6246 break;
6247
6248 case WXK_SPACE:
6249 if ( event.ControlDown() )
6250 {
6251 if ( m_selection )
6252 {
6253 m_selection->ToggleCellSelection( m_currentCellCoords.GetRow(),
6254 m_currentCellCoords.GetCol(),
6255 event.ControlDown(),
6256 event.ShiftDown(),
6257 event.AltDown(),
6258 event.MetaDown() );
6259 }
6260 break;
6261 }
6262 if ( !IsEditable() )
6263 {
6264 MoveCursorRight( FALSE );
6265 break;
6266 }
6267 // Otherwise fall through to default
6268
6269 default:
6270 // is it possible to edit the current cell at all?
6271 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
6272 {
6273 // yes, now check whether the cells editor accepts the key
6274 int row = m_currentCellCoords.GetRow();
6275 int col = m_currentCellCoords.GetCol();
6276 wxGridCellAttr* attr = GetCellAttr(row, col);
6277 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6278
6279 // <F2> is special and will always start editing, for
6280 // other keys - ask the editor itself
6281 if ( (event.GetKeyCode() == WXK_F2 && !event.HasModifiers())
6282 || editor->IsAcceptedKey(event) )
6283 {
6284 // ensure cell is visble
6285 MakeCellVisible(row, col);
6286 EnableCellEditControl();
6287
6288 // a problem can arise if the cell is not completely
6289 // visible (even after calling MakeCellVisible the
6290 // control is not created and calling StartingKey will
6291 // crash the app
6292 if( editor->IsCreated() && m_cellEditCtrlEnabled ) editor->StartingKey(event);
6293 }
6294 else
6295 {
6296 event.Skip();
6297 }
6298
6299 editor->DecRef();
6300 attr->DecRef();
6301 }
6302 else
6303 {
6304 // let others process char events with modifiers or all
6305 // char events for readonly cells
6306 event.Skip();
6307 }
6308 break;
6309 }
6310 }
6311
6312 m_inOnKeyDown = FALSE;
6313 }
6314
6315 void wxGrid::OnKeyUp( wxKeyEvent& event )
6316 {
6317 // try local handlers
6318 //
6319 if ( event.GetKeyCode() == WXK_SHIFT )
6320 {
6321 if ( m_selectingTopLeft != wxGridNoCellCoords &&
6322 m_selectingBottomRight != wxGridNoCellCoords )
6323 {
6324 if ( m_selection )
6325 {
6326 m_selection->SelectBlock( m_selectingTopLeft.GetRow(),
6327 m_selectingTopLeft.GetCol(),
6328 m_selectingBottomRight.GetRow(),
6329 m_selectingBottomRight.GetCol(),
6330 event.ControlDown(),
6331 TRUE,
6332 event.AltDown(),
6333 event.MetaDown() );
6334 }
6335 }
6336
6337 m_selectingTopLeft = wxGridNoCellCoords;
6338 m_selectingBottomRight = wxGridNoCellCoords;
6339 m_selectingKeyboard = wxGridNoCellCoords;
6340 }
6341 }
6342
6343 void wxGrid::OnEraseBackground(wxEraseEvent&)
6344 {
6345 }
6346
6347 void wxGrid::SetCurrentCell( const wxGridCellCoords& coords )
6348 {
6349 if ( SendEvent( wxEVT_GRID_SELECT_CELL, coords.GetRow(), coords.GetCol() ) )
6350 {
6351 // the event has been intercepted - do nothing
6352 return;
6353 }
6354
6355 wxClientDC dc(m_gridWin);
6356 PrepareDC(dc);
6357
6358 if ( m_currentCellCoords != wxGridNoCellCoords )
6359 {
6360 HideCellEditControl();
6361 DisableCellEditControl();
6362
6363 if ( IsVisible( m_currentCellCoords, FALSE ) )
6364 {
6365 wxRect r;
6366 r = BlockToDeviceRect(m_currentCellCoords, m_currentCellCoords);
6367 if ( !m_gridLinesEnabled )
6368 {
6369 r.x--;
6370 r.y--;
6371 r.width++;
6372 r.height++;
6373 }
6374
6375 wxGridCellCoordsArray cells = CalcCellsExposed( r );
6376
6377 // Otherwise refresh redraws the highlight!
6378 m_currentCellCoords = coords;
6379
6380 DrawGridCellArea(dc,cells);
6381 DrawAllGridLines( dc, r );
6382 }
6383 }
6384
6385 m_currentCellCoords = coords;
6386
6387 wxGridCellAttr* attr = GetCellAttr(coords);
6388 DrawCellHighlight(dc, attr);
6389 attr->DecRef();
6390 }
6391
6392
6393 void wxGrid::HighlightBlock( int topRow, int leftCol, int bottomRow, int rightCol )
6394 {
6395 int temp;
6396 wxGridCellCoords updateTopLeft, updateBottomRight;
6397
6398 if ( m_selection )
6399 {
6400 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
6401 {
6402 leftCol = 0;
6403 rightCol = GetNumberCols() - 1;
6404 }
6405 else if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
6406 {
6407 topRow = 0;
6408 bottomRow = GetNumberRows() - 1;
6409 }
6410 }
6411
6412 if ( topRow > bottomRow )
6413 {
6414 temp = topRow;
6415 topRow = bottomRow;
6416 bottomRow = temp;
6417 }
6418
6419 if ( leftCol > rightCol )
6420 {
6421 temp = leftCol;
6422 leftCol = rightCol;
6423 rightCol = temp;
6424 }
6425
6426 updateTopLeft = wxGridCellCoords( topRow, leftCol );
6427 updateBottomRight = wxGridCellCoords( bottomRow, rightCol );
6428
6429 // First the case that we selected a completely new area
6430 if ( m_selectingTopLeft == wxGridNoCellCoords ||
6431 m_selectingBottomRight == wxGridNoCellCoords )
6432 {
6433 wxRect rect;
6434 rect = BlockToDeviceRect( wxGridCellCoords ( topRow, leftCol ),
6435 wxGridCellCoords ( bottomRow, rightCol ) );
6436 m_gridWin->Refresh( FALSE, &rect );
6437 }
6438 // Now handle changing an existing selection area.
6439 else if ( m_selectingTopLeft != updateTopLeft ||
6440 m_selectingBottomRight != updateBottomRight )
6441 {
6442 // Compute two optimal update rectangles:
6443 // Either one rectangle is a real subset of the
6444 // other, or they are (almost) disjoint!
6445 wxRect rect[4];
6446 bool need_refresh[4];
6447 need_refresh[0] =
6448 need_refresh[1] =
6449 need_refresh[2] =
6450 need_refresh[3] = FALSE;
6451 int i;
6452
6453 // Store intermediate values
6454 wxCoord oldLeft = m_selectingTopLeft.GetCol();
6455 wxCoord oldTop = m_selectingTopLeft.GetRow();
6456 wxCoord oldRight = m_selectingBottomRight.GetCol();
6457 wxCoord oldBottom = m_selectingBottomRight.GetRow();
6458
6459 // Determine the outer/inner coordinates.
6460 if (oldLeft > leftCol)
6461 {
6462 temp = oldLeft;
6463 oldLeft = leftCol;
6464 leftCol = temp;
6465 }
6466 if (oldTop > topRow )
6467 {
6468 temp = oldTop;
6469 oldTop = topRow;
6470 topRow = temp;
6471 }
6472 if (oldRight < rightCol )
6473 {
6474 temp = oldRight;
6475 oldRight = rightCol;
6476 rightCol = temp;
6477 }
6478 if (oldBottom < bottomRow)
6479 {
6480 temp = oldBottom;
6481 oldBottom = bottomRow;
6482 bottomRow = temp;
6483 }
6484
6485 // Now, either the stuff marked old is the outer
6486 // rectangle or we don't have a situation where one
6487 // is contained in the other.
6488
6489 if ( oldLeft < leftCol )
6490 {
6491 // Refresh the newly selected or deselected
6492 // area to the left of the old or new selection.
6493 need_refresh[0] = TRUE;
6494 rect[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6495 oldLeft ),
6496 wxGridCellCoords ( oldBottom,
6497 leftCol - 1 ) );
6498 }
6499
6500 if ( oldTop < topRow )
6501 {
6502 // Refresh the newly selected or deselected
6503 // area above the old or new selection.
6504 need_refresh[1] = TRUE;
6505 rect[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6506 leftCol ),
6507 wxGridCellCoords ( topRow - 1,
6508 rightCol ) );
6509 }
6510
6511 if ( oldRight > rightCol )
6512 {
6513 // Refresh the newly selected or deselected
6514 // area to the right of the old or new selection.
6515 need_refresh[2] = TRUE;
6516 rect[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop,
6517 rightCol + 1 ),
6518 wxGridCellCoords ( oldBottom,
6519 oldRight ) );
6520 }
6521
6522 if ( oldBottom > bottomRow )
6523 {
6524 // Refresh the newly selected or deselected
6525 // area below the old or new selection.
6526 need_refresh[3] = TRUE;
6527 rect[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow + 1,
6528 leftCol ),
6529 wxGridCellCoords ( oldBottom,
6530 rightCol ) );
6531 }
6532
6533 // various Refresh() calls
6534 for (i = 0; i < 4; i++ )
6535 if ( need_refresh[i] && rect[i] != wxGridNoCellRect )
6536 m_gridWin->Refresh( FALSE, &(rect[i]) );
6537 }
6538 // Change Selection
6539 m_selectingTopLeft = updateTopLeft;
6540 m_selectingBottomRight = updateBottomRight;
6541 }
6542
6543 //
6544 // ------ functions to get/send data (see also public functions)
6545 //
6546
6547 bool wxGrid::GetModelValues()
6548 {
6549 // Hide the editor, so it won't hide a changed value.
6550 HideCellEditControl();
6551
6552 if ( m_table )
6553 {
6554 // all we need to do is repaint the grid
6555 //
6556 m_gridWin->Refresh();
6557 return TRUE;
6558 }
6559
6560 return FALSE;
6561 }
6562
6563
6564 bool wxGrid::SetModelValues()
6565 {
6566 int row, col;
6567
6568 // Disable the editor, so it won't hide a changed value.
6569 // Do we also want to save the current value of the editor first?
6570 // I think so ...
6571 DisableCellEditControl();
6572
6573 if ( m_table )
6574 {
6575 for ( row = 0; row < m_numRows; row++ )
6576 {
6577 for ( col = 0; col < m_numCols; col++ )
6578 {
6579 m_table->SetValue( row, col, GetCellValue(row, col) );
6580 }
6581 }
6582
6583 return TRUE;
6584 }
6585
6586 return FALSE;
6587 }
6588
6589
6590
6591 // Note - this function only draws cells that are in the list of
6592 // exposed cells (usually set from the update region by
6593 // CalcExposedCells)
6594 //
6595 void wxGrid::DrawGridCellArea( wxDC& dc, const wxGridCellCoordsArray& cells )
6596 {
6597 if ( !m_numRows || !m_numCols ) return;
6598
6599 int i, numCells = cells.GetCount();
6600 int row, col, cell_rows, cell_cols;
6601 wxGridCellCoordsArray redrawCells;
6602
6603 for ( i = numCells-1; i >= 0; i-- )
6604 {
6605 row = cells[i].GetRow();
6606 col = cells[i].GetCol();
6607 GetCellSize( row, col, &cell_rows, &cell_cols );
6608
6609 // If this cell is part of a multicell block, find owner for repaint
6610 if ( cell_rows <= 0 || cell_cols <= 0 )
6611 {
6612 wxGridCellCoords cell(row+cell_rows, col+cell_cols);
6613 bool marked = FALSE;
6614 for ( int j = 0; j < numCells; j++ )
6615 {
6616 if ( cell == cells[j] )
6617 {
6618 marked = TRUE;
6619 break;
6620 }
6621 }
6622 if (!marked)
6623 {
6624 int count = redrawCells.GetCount();
6625 for (int j = 0; j < count; j++)
6626 {
6627 if ( cell == redrawCells[j] )
6628 {
6629 marked = TRUE;
6630 break;
6631 }
6632 }
6633 if (!marked) redrawCells.Add( cell );
6634 }
6635 continue; // don't bother drawing this cell
6636 }
6637
6638 // If this cell is empty, find cell to left that might want to overflow
6639 if (m_table && m_table->IsEmptyCell(row, col))
6640 {
6641 for ( int l = 0; l < cell_rows; l++ )
6642 {
6643 // find a cell in this row to left alreay marked for repaint
6644 int left = col;
6645 for (int k = 0; k < int(redrawCells.GetCount()); k++)
6646 if ((redrawCells[k].GetCol() < left) &&
6647 (redrawCells[k].GetRow() == row))
6648 left=redrawCells[k].GetCol();
6649
6650 if (left == col) left = 0; // oh well
6651
6652 for (int j = col-1; j >= left; j--)
6653 {
6654 if (!m_table->IsEmptyCell(row+l, j))
6655 {
6656 if (GetCellOverflow(row+l, j))
6657 {
6658 wxGridCellCoords cell(row+l, j);
6659 bool marked = FALSE;
6660
6661 for (int k = 0; k < numCells; k++)
6662 {
6663 if ( cell == cells[k] )
6664 {
6665 marked = TRUE;
6666 break;
6667 }
6668 }
6669 if (!marked)
6670 {
6671 int count = redrawCells.GetCount();
6672 for (int k = 0; k < count; k++)
6673 {
6674 if ( cell == redrawCells[k] )
6675 {
6676 marked = TRUE;
6677 break;
6678 }
6679 }
6680 if (!marked) redrawCells.Add( cell );
6681 }
6682 }
6683 break;
6684 }
6685 }
6686 }
6687 }
6688 DrawCell( dc, cells[i] );
6689 }
6690
6691 numCells = redrawCells.GetCount();
6692
6693 for ( i = numCells - 1; i >= 0; i-- )
6694 {
6695 DrawCell( dc, redrawCells[i] );
6696 }
6697 }
6698
6699
6700 void wxGrid::DrawGridSpace( wxDC& dc )
6701 {
6702 int cw, ch;
6703 m_gridWin->GetClientSize( &cw, &ch );
6704
6705 int right, bottom;
6706 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6707
6708 int rightCol = m_numCols > 0 ? GetColRight(m_numCols - 1) : 0;
6709 int bottomRow = m_numRows > 0 ? GetRowBottom(m_numRows - 1) : 0 ;
6710
6711 if ( right > rightCol || bottom > bottomRow )
6712 {
6713 int left, top;
6714 CalcUnscrolledPosition( 0, 0, &left, &top );
6715
6716 dc.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID) );
6717 dc.SetPen( *wxTRANSPARENT_PEN );
6718
6719 if ( right > rightCol )
6720 {
6721 dc.DrawRectangle( rightCol, top, right - rightCol, ch);
6722 }
6723
6724 if ( bottom > bottomRow )
6725 {
6726 dc.DrawRectangle( left, bottomRow, cw, bottom - bottomRow);
6727 }
6728 }
6729 }
6730
6731
6732 void wxGrid::DrawCell( wxDC& dc, const wxGridCellCoords& coords )
6733 {
6734 int row = coords.GetRow();
6735 int col = coords.GetCol();
6736
6737 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6738 return;
6739
6740 // we draw the cell border ourselves
6741 #if !WXGRID_DRAW_LINES
6742 if ( m_gridLinesEnabled )
6743 DrawCellBorder( dc, coords );
6744 #endif
6745
6746 wxGridCellAttr* attr = GetCellAttr(row, col);
6747
6748 bool isCurrent = coords == m_currentCellCoords;
6749
6750 wxRect rect = CellToRect( row, col );
6751
6752 // if the editor is shown, we should use it and not the renderer
6753 // Note: However, only if it is really _shown_, i.e. not hidden!
6754 if ( isCurrent && IsCellEditControlShown() )
6755 {
6756 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
6757 editor->PaintBackground(rect, attr);
6758 editor->DecRef();
6759 }
6760 else
6761 {
6762 // but all the rest is drawn by the cell renderer and hence may be
6763 // customized
6764 wxGridCellRenderer *renderer = attr->GetRenderer(this, row, col);
6765 renderer->Draw(*this, *attr, dc, rect, row, col, IsInSelection(coords));
6766 renderer->DecRef();
6767 }
6768
6769 attr->DecRef();
6770 }
6771
6772 void wxGrid::DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr )
6773 {
6774 int row = m_currentCellCoords.GetRow();
6775 int col = m_currentCellCoords.GetCol();
6776
6777 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6778 return;
6779
6780 wxRect rect = CellToRect(row, col);
6781
6782 // hmmm... what could we do here to show that the cell is disabled?
6783 // for now, I just draw a thinner border than for the other ones, but
6784 // it doesn't look really good
6785
6786 int penWidth = attr->IsReadOnly() ? m_cellHighlightROPenWidth : m_cellHighlightPenWidth;
6787
6788 if (penWidth > 0)
6789 {
6790 // The center of th drawn line is where the position/width/height of
6791 // the rectangle is actually at, (on wxMSW atr least,) so we will
6792 // reduce the size of the rectangle to compensate for the thickness of
6793 // the line. If this is too strange on non wxMSW platforms then
6794 // please #ifdef this appropriately.
6795 rect.x += penWidth/2;
6796 rect.y += penWidth/2;
6797 rect.width -= penWidth-1;
6798 rect.height -= penWidth-1;
6799
6800
6801 // Now draw the rectangle
6802 // use the cellHighlightColour if the cell is inside a selection, this
6803 // will ensure the cell is always visible.
6804 dc.SetPen(wxPen(IsInSelection(row,col)?m_selectionForeground:m_cellHighlightColour, penWidth, wxSOLID));
6805 dc.SetBrush(*wxTRANSPARENT_BRUSH);
6806 dc.DrawRectangle(rect);
6807 }
6808
6809 #if 0
6810 // VZ: my experiments with 3d borders...
6811
6812 // how to properly set colours for arbitrary bg?
6813 wxCoord x1 = rect.x,
6814 y1 = rect.y,
6815 x2 = rect.x + rect.width -1,
6816 y2 = rect.y + rect.height -1;
6817
6818 dc.SetPen(*wxWHITE_PEN);
6819 dc.DrawLine(x1, y1, x2, y1);
6820 dc.DrawLine(x1, y1, x1, y2);
6821
6822 dc.DrawLine(x1 + 1, y2 - 1, x2 - 1, y2 - 1);
6823 dc.DrawLine(x2 - 1, y1 + 1, x2 - 1, y2 );
6824
6825 dc.SetPen(*wxBLACK_PEN);
6826 dc.DrawLine(x1, y2, x2, y2);
6827 dc.DrawLine(x2, y1, x2, y2+1);
6828 #endif // 0
6829 }
6830
6831
6832 void wxGrid::DrawCellBorder( wxDC& dc, const wxGridCellCoords& coords )
6833 {
6834 int row = coords.GetRow();
6835 int col = coords.GetCol();
6836 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
6837 return;
6838
6839 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6840
6841 wxRect rect = CellToRect( row, col );
6842
6843 // right hand border
6844 //
6845 dc.DrawLine( rect.x + rect.width, rect.y,
6846 rect.x + rect.width, rect.y + rect.height + 1 );
6847
6848 // bottom border
6849 //
6850 dc.DrawLine( rect.x, rect.y + rect.height,
6851 rect.x + rect.width, rect.y + rect.height);
6852 }
6853
6854 void wxGrid::DrawHighlight(wxDC& dc,const wxGridCellCoordsArray& cells)
6855 {
6856 // This if block was previously in wxGrid::OnPaint but that doesn't
6857 // seem to get called under wxGTK - MB
6858 //
6859 if ( m_currentCellCoords == wxGridNoCellCoords &&
6860 m_numRows && m_numCols )
6861 {
6862 m_currentCellCoords.Set(0, 0);
6863 }
6864
6865 if ( IsCellEditControlShown() )
6866 {
6867 // don't show highlight when the edit control is shown
6868 return;
6869 }
6870
6871 // if the active cell was repainted, repaint its highlight too because it
6872 // might have been damaged by the grid lines
6873 size_t count = cells.GetCount();
6874 for ( size_t n = 0; n < count; n++ )
6875 {
6876 if ( cells[n] == m_currentCellCoords )
6877 {
6878 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
6879 DrawCellHighlight(dc, attr);
6880 attr->DecRef();
6881
6882 break;
6883 }
6884 }
6885 }
6886
6887 // TODO: remove this ???
6888 // This is used to redraw all grid lines e.g. when the grid line colour
6889 // has been changed
6890 //
6891 void wxGrid::DrawAllGridLines( wxDC& dc, const wxRegion & WXUNUSED(reg) )
6892 {
6893 #if !WXGRID_DRAW_LINES
6894 return;
6895 #endif
6896
6897 if ( !m_gridLinesEnabled ||
6898 !m_numRows ||
6899 !m_numCols ) return;
6900
6901 int top, bottom, left, right;
6902
6903 #if 0 //#ifndef __WXGTK__
6904 if (reg.IsEmpty())
6905 {
6906 int cw, ch;
6907 m_gridWin->GetClientSize(&cw, &ch);
6908
6909 // virtual coords of visible area
6910 //
6911 CalcUnscrolledPosition( 0, 0, &left, &top );
6912 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6913 }
6914 else
6915 {
6916 wxCoord x, y, w, h;
6917 reg.GetBox(x, y, w, h);
6918 CalcUnscrolledPosition( x, y, &left, &top );
6919 CalcUnscrolledPosition( x + w, y + h, &right, &bottom );
6920 }
6921 #else
6922 int cw, ch;
6923 m_gridWin->GetClientSize(&cw, &ch);
6924 CalcUnscrolledPosition( 0, 0, &left, &top );
6925 CalcUnscrolledPosition( cw, ch, &right, &bottom );
6926 #endif
6927
6928 // avoid drawing grid lines past the last row and col
6929 //
6930 right = wxMin( right, GetColRight(m_numCols - 1) );
6931 bottom = wxMin( bottom, GetRowBottom(m_numRows - 1) );
6932
6933 // no gridlines inside multicells, clip them out
6934 int leftCol = internalXToCol(left);
6935 int topRow = internalYToRow(top);
6936 int rightCol = internalXToCol(right);
6937 int bottomRow = internalYToRow(bottom);
6938 wxRegion clippedcells(0, 0, cw, ch);
6939
6940
6941 int i, j, cell_rows, cell_cols;
6942 wxRect rect;
6943
6944 for (j=topRow; j<bottomRow; j++)
6945 {
6946 for (i=leftCol; i<rightCol; i++)
6947 {
6948 GetCellSize( j, i, &cell_rows, &cell_cols );
6949 if ((cell_rows > 1) || (cell_cols > 1))
6950 {
6951 rect = CellToRect(j,i);
6952 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
6953 clippedcells.Subtract(rect);
6954 }
6955 else if ((cell_rows < 0) || (cell_cols < 0))
6956 {
6957 rect = CellToRect(j+cell_rows, i+cell_cols);
6958 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
6959 clippedcells.Subtract(rect);
6960 }
6961 }
6962 }
6963 dc.SetClippingRegion( clippedcells );
6964
6965 dc.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID) );
6966
6967 // horizontal grid lines
6968 //
6969 // already declared above - int i;
6970 for ( i = internalYToRow(top); i < m_numRows; i++ )
6971 {
6972 int bot = GetRowBottom(i) - 1;
6973
6974 if ( bot > bottom )
6975 {
6976 break;
6977 }
6978
6979 if ( bot >= top )
6980 {
6981 dc.DrawLine( left, bot, right, bot );
6982 }
6983 }
6984
6985
6986 // vertical grid lines
6987 //
6988 for ( i = internalXToCol(left); i < m_numCols; i++ )
6989 {
6990 int colRight = GetColRight(i) - 1;
6991 if ( colRight > right )
6992 {
6993 break;
6994 }
6995
6996 if ( colRight >= left )
6997 {
6998 dc.DrawLine( colRight, top, colRight, bottom );
6999 }
7000 }
7001 dc.DestroyClippingRegion();
7002 }
7003
7004
7005 void wxGrid::DrawRowLabels( wxDC& dc ,const wxArrayInt& rows)
7006 {
7007 if ( !m_numRows ) return;
7008
7009 size_t i;
7010 size_t numLabels = rows.GetCount();
7011
7012 for ( i = 0; i < numLabels; i++ )
7013 {
7014 DrawRowLabel( dc, rows[i] );
7015 }
7016 }
7017
7018
7019 void wxGrid::DrawRowLabel( wxDC& dc, int row )
7020 {
7021 if ( GetRowHeight(row) <= 0 )
7022 return;
7023
7024 int rowTop = GetRowTop(row),
7025 rowBottom = GetRowBottom(row) - 1;
7026
7027 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
7028 dc.DrawLine( m_rowLabelWidth-1, rowTop,
7029 m_rowLabelWidth-1, rowBottom );
7030
7031 dc.DrawLine( 0, rowTop, 0, rowBottom );
7032
7033 dc.DrawLine( 0, rowBottom, m_rowLabelWidth, rowBottom );
7034
7035 dc.SetPen( *wxWHITE_PEN );
7036 dc.DrawLine( 1, rowTop, 1, rowBottom );
7037 dc.DrawLine( 1, rowTop, m_rowLabelWidth-1, rowTop );
7038
7039 dc.SetBackgroundMode( wxTRANSPARENT );
7040 dc.SetTextForeground( GetLabelTextColour() );
7041 dc.SetFont( GetLabelFont() );
7042
7043 int hAlign, vAlign;
7044 GetRowLabelAlignment( &hAlign, &vAlign );
7045
7046 wxRect rect;
7047 rect.SetX( 2 );
7048 rect.SetY( GetRowTop(row) + 2 );
7049 rect.SetWidth( m_rowLabelWidth - 4 );
7050 rect.SetHeight( GetRowHeight(row) - 4 );
7051 DrawTextRectangle( dc, GetRowLabelValue( row ), rect, hAlign, vAlign );
7052 }
7053
7054
7055 void wxGrid::DrawColLabels( wxDC& dc,const wxArrayInt& cols )
7056 {
7057 if ( !m_numCols ) return;
7058
7059 size_t i;
7060 size_t numLabels = cols.GetCount();
7061
7062 for ( i = 0; i < numLabels; i++ )
7063 {
7064 DrawColLabel( dc, cols[i] );
7065 }
7066 }
7067
7068
7069 void wxGrid::DrawColLabel( wxDC& dc, int col )
7070 {
7071 if ( GetColWidth(col) <= 0 )
7072 return;
7073
7074 int colLeft = GetColLeft(col),
7075 colRight = GetColRight(col) - 1;
7076
7077 dc.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW),1, wxSOLID) );
7078 dc.DrawLine( colRight, 0,
7079 colRight, m_colLabelHeight-1 );
7080
7081 dc.DrawLine( colLeft, 0, colRight, 0 );
7082
7083 dc.DrawLine( colLeft, m_colLabelHeight-1,
7084 colRight+1, m_colLabelHeight-1 );
7085
7086 dc.SetPen( *wxWHITE_PEN );
7087 dc.DrawLine( colLeft, 1, colLeft, m_colLabelHeight-1 );
7088 dc.DrawLine( colLeft, 1, colRight, 1 );
7089
7090 dc.SetBackgroundMode( wxTRANSPARENT );
7091 dc.SetTextForeground( GetLabelTextColour() );
7092 dc.SetFont( GetLabelFont() );
7093
7094 int hAlign, vAlign, orient;
7095 GetColLabelAlignment( &hAlign, &vAlign );
7096 orient = GetColLabelTextOrientation();
7097
7098 wxRect rect;
7099 rect.SetX( colLeft + 2 );
7100 rect.SetY( 2 );
7101 rect.SetWidth( GetColWidth(col) - 4 );
7102 rect.SetHeight( m_colLabelHeight - 4 );
7103 DrawTextRectangle( dc, GetColLabelValue( col ), rect, hAlign, vAlign, orient );
7104 }
7105
7106 void wxGrid::DrawTextRectangle( wxDC& dc,
7107 const wxString& value,
7108 const wxRect& rect,
7109 int horizAlign,
7110 int vertAlign,
7111 int textOrientation )
7112 {
7113 wxArrayString lines;
7114
7115 StringToLines( value, lines );
7116
7117
7118 //Forward to new API.
7119 DrawTextRectangle( dc,
7120 lines,
7121 rect,
7122 horizAlign,
7123 vertAlign,
7124 textOrientation );
7125
7126 }
7127
7128 void wxGrid::DrawTextRectangle( wxDC& dc,
7129 const wxArrayString& lines,
7130 const wxRect& rect,
7131 int horizAlign,
7132 int vertAlign,
7133 int textOrientation )
7134 {
7135 long textWidth, textHeight;
7136 long lineWidth, lineHeight;
7137 int nLines;
7138
7139 dc.SetClippingRegion( rect );
7140
7141 nLines = lines.GetCount();
7142 if( nLines > 0 )
7143 {
7144 int l;
7145 float x = 0.0, y = 0.0;
7146
7147 if( textOrientation == wxHORIZONTAL )
7148 GetTextBoxSize(dc, lines, &textWidth, &textHeight);
7149 else
7150 GetTextBoxSize( dc, lines, &textHeight, &textWidth );
7151
7152 switch( vertAlign )
7153 {
7154 case wxALIGN_BOTTOM:
7155 if( textOrientation == wxHORIZONTAL )
7156 y = rect.y + (rect.height - textHeight - 1);
7157 else
7158 x = rect.x + rect.width - textWidth;
7159 break;
7160
7161 case wxALIGN_CENTRE:
7162 if( textOrientation == wxHORIZONTAL )
7163 y = rect.y + ((rect.height - textHeight)/2);
7164 else
7165 x = rect.x + ((rect.width - textWidth)/2);
7166 break;
7167
7168 case wxALIGN_TOP:
7169 default:
7170 if( textOrientation == wxHORIZONTAL )
7171 y = rect.y + 1;
7172 else
7173 x = rect.x + 1;
7174 break;
7175 }
7176
7177 // Align each line of a multi-line label
7178 for( l = 0; l < nLines; l++ )
7179 {
7180 dc.GetTextExtent(lines[l], &lineWidth, &lineHeight);
7181
7182 switch( horizAlign )
7183 {
7184 case wxALIGN_RIGHT:
7185 if( textOrientation == wxHORIZONTAL )
7186 x = rect.x + (rect.width - lineWidth - 1);
7187 else
7188 y = rect.y + lineWidth + 1;
7189 break;
7190
7191 case wxALIGN_CENTRE:
7192 if( textOrientation == wxHORIZONTAL )
7193 x = rect.x + ((rect.width - lineWidth)/2);
7194 else
7195 y = rect.y + rect.height - ((rect.height - lineWidth)/2);
7196 break;
7197
7198 case wxALIGN_LEFT:
7199 default:
7200 if( textOrientation == wxHORIZONTAL )
7201 x = rect.x + 1;
7202 else
7203 y = rect.y + rect.height - 1;
7204 break;
7205 }
7206
7207 if( textOrientation == wxHORIZONTAL )
7208 {
7209 dc.DrawText( lines[l], (int)x, (int)y );
7210 y += lineHeight;
7211 }
7212 else
7213 {
7214 dc.DrawRotatedText( lines[l], (int)x, (int)y, 90.0 );
7215 x += lineHeight;
7216 }
7217 }
7218 }
7219 dc.DestroyClippingRegion();
7220 }
7221
7222
7223 // Split multi line text up into an array of strings. Any existing
7224 // contents of the string array are preserved.
7225 //
7226 void wxGrid::StringToLines( const wxString& value, wxArrayString& lines )
7227 {
7228 int startPos = 0;
7229 int pos;
7230 wxString eol = wxTextFile::GetEOL( wxTextFileType_Unix );
7231 wxString tVal = wxTextFile::Translate( value, wxTextFileType_Unix );
7232
7233 while ( startPos < (int)tVal.Length() )
7234 {
7235 pos = tVal.Mid(startPos).Find( eol );
7236 if ( pos < 0 )
7237 {
7238 break;
7239 }
7240 else if ( pos == 0 )
7241 {
7242 lines.Add( wxEmptyString );
7243 }
7244 else
7245 {
7246 lines.Add( value.Mid(startPos, pos) );
7247 }
7248 startPos += pos+1;
7249 }
7250 if ( startPos < (int)value.Length() )
7251 {
7252 lines.Add( value.Mid( startPos ) );
7253 }
7254 }
7255
7256
7257 void wxGrid::GetTextBoxSize( wxDC& dc,
7258 const wxArrayString& lines,
7259 long *width, long *height )
7260 {
7261 long w = 0;
7262 long h = 0;
7263 long lineW, lineH;
7264
7265 size_t i;
7266 for ( i = 0; i < lines.GetCount(); i++ )
7267 {
7268 dc.GetTextExtent( lines[i], &lineW, &lineH );
7269 w = wxMax( w, lineW );
7270 h += lineH;
7271 }
7272
7273 *width = w;
7274 *height = h;
7275 }
7276
7277 //
7278 // ------ Batch processing.
7279 //
7280 void wxGrid::EndBatch()
7281 {
7282 if ( m_batchCount > 0 )
7283 {
7284 m_batchCount--;
7285 if ( !m_batchCount )
7286 {
7287 CalcDimensions();
7288 m_rowLabelWin->Refresh();
7289 m_colLabelWin->Refresh();
7290 m_cornerLabelWin->Refresh();
7291 m_gridWin->Refresh();
7292 }
7293 }
7294 }
7295
7296 // Use this, rather than wxWindow::Refresh(), to force an immediate
7297 // repainting of the grid. Has no effect if you are already inside a
7298 // BeginBatch / EndBatch block.
7299 //
7300 void wxGrid::ForceRefresh()
7301 {
7302 BeginBatch();
7303 EndBatch();
7304 }
7305
7306
7307 //
7308 // ------ Edit control functions
7309 //
7310
7311
7312 void wxGrid::EnableEditing( bool edit )
7313 {
7314 // TODO: improve this ?
7315 //
7316 if ( edit != m_editable )
7317 {
7318 if(!edit) EnableCellEditControl(edit);
7319 m_editable = edit;
7320 }
7321 }
7322
7323
7324 void wxGrid::EnableCellEditControl( bool enable )
7325 {
7326 if (! m_editable)
7327 return;
7328
7329 if ( m_currentCellCoords == wxGridNoCellCoords )
7330 SetCurrentCell( 0, 0 );
7331
7332 if ( enable != m_cellEditCtrlEnabled )
7333 {
7334 if ( enable )
7335 {
7336 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN) <0)
7337 return;
7338
7339 // this should be checked by the caller!
7340 wxASSERT_MSG( CanEnableCellControl(),
7341 _T("can't enable editing for this cell!") );
7342
7343 // do it before ShowCellEditControl()
7344 m_cellEditCtrlEnabled = enable;
7345
7346 ShowCellEditControl();
7347 }
7348 else
7349 {
7350 //FIXME:add veto support
7351 SendEvent( wxEVT_GRID_EDITOR_HIDDEN);
7352
7353 HideCellEditControl();
7354 SaveEditControlValue();
7355
7356 // do it after HideCellEditControl()
7357 m_cellEditCtrlEnabled = enable;
7358 }
7359 }
7360 }
7361
7362 bool wxGrid::IsCurrentCellReadOnly() const
7363 {
7364 // const_cast
7365 wxGridCellAttr* attr = ((wxGrid *)this)->GetCellAttr(m_currentCellCoords);
7366 bool readonly = attr->IsReadOnly();
7367 attr->DecRef();
7368
7369 return readonly;
7370 }
7371
7372 bool wxGrid::CanEnableCellControl() const
7373 {
7374 return m_editable && !IsCurrentCellReadOnly();
7375 }
7376
7377 bool wxGrid::IsCellEditControlEnabled() const
7378 {
7379 // the cell edit control might be disable for all cells or just for the
7380 // current one if it's read only
7381 return m_cellEditCtrlEnabled ? !IsCurrentCellReadOnly() : FALSE;
7382 }
7383
7384 bool wxGrid::IsCellEditControlShown() const
7385 {
7386 bool isShown = FALSE;
7387
7388 if ( m_cellEditCtrlEnabled )
7389 {
7390 int row = m_currentCellCoords.GetRow();
7391 int col = m_currentCellCoords.GetCol();
7392 wxGridCellAttr* attr = GetCellAttr(row, col);
7393 wxGridCellEditor* editor = attr->GetEditor((wxGrid*) this, row, col);
7394 attr->DecRef();
7395
7396 if ( editor )
7397 {
7398 if ( editor->IsCreated() )
7399 {
7400 isShown = editor->GetControl()->IsShown();
7401 }
7402
7403 editor->DecRef();
7404 }
7405 }
7406
7407 return isShown;
7408 }
7409
7410 void wxGrid::ShowCellEditControl()
7411 {
7412 if ( IsCellEditControlEnabled() )
7413 {
7414 if ( !IsVisible( m_currentCellCoords ) )
7415 {
7416 m_cellEditCtrlEnabled = FALSE;
7417 return;
7418 }
7419 else
7420 {
7421 wxRect rect = CellToRect( m_currentCellCoords );
7422 int row = m_currentCellCoords.GetRow();
7423 int col = m_currentCellCoords.GetCol();
7424
7425 // if this is part of a multicell, find owner (topleft)
7426 int cell_rows, cell_cols;
7427 GetCellSize( row, col, &cell_rows, &cell_cols );
7428 if ( cell_rows <= 0 || cell_cols <= 0 )
7429 {
7430 row += cell_rows;
7431 col += cell_cols;
7432 m_currentCellCoords.SetRow( row );
7433 m_currentCellCoords.SetCol( col );
7434 }
7435
7436 // convert to scrolled coords
7437 //
7438 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
7439
7440 // done in PaintBackground()
7441 #if 0
7442 // erase the highlight and the cell contents because the editor
7443 // might not cover the entire cell
7444 wxClientDC dc( m_gridWin );
7445 PrepareDC( dc );
7446 dc.SetBrush(*wxLIGHT_GREY_BRUSH); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
7447 dc.SetPen(*wxTRANSPARENT_PEN);
7448 dc.DrawRectangle(rect);
7449 #endif // 0
7450
7451 // cell is shifted by one pixel
7452 // However, don't allow x or y to become negative
7453 // since the SetSize() method interprets that as
7454 // "don't change."
7455 if (rect.x > 0)
7456 rect.x--;
7457 if (rect.y > 0)
7458 rect.y--;
7459
7460 wxGridCellAttr* attr = GetCellAttr(row, col);
7461 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7462 if ( !editor->IsCreated() )
7463 {
7464 editor->Create(m_gridWin, -1,
7465 new wxGridCellEditorEvtHandler(this, editor));
7466
7467 wxGridEditorCreatedEvent evt(GetId(),
7468 wxEVT_GRID_EDITOR_CREATED,
7469 this,
7470 row,
7471 col,
7472 editor->GetControl());
7473 GetEventHandler()->ProcessEvent(evt);
7474 }
7475
7476
7477 // resize editor to overflow into righthand cells if allowed
7478 int maxWidth = rect.width;
7479 wxString value = GetCellValue(row, col);
7480 if ( (value != wxEmptyString) && (attr->GetOverflow()) )
7481 {
7482 int y;
7483 GetTextExtent(value, &maxWidth, &y,
7484 NULL, NULL, &attr->GetFont());
7485 if (maxWidth < rect.width) maxWidth = rect.width;
7486 }
7487 int client_right = m_gridWin->GetClientSize().GetWidth();
7488 if (rect.x+maxWidth > client_right)
7489 maxWidth = client_right - rect.x;
7490
7491 if ((maxWidth > rect.width) && (col < m_numCols) && m_table)
7492 {
7493 GetCellSize( row, col, &cell_rows, &cell_cols );
7494 // may have changed earlier
7495 for (int i = col+cell_cols; i < m_numCols; i++)
7496 {
7497 int c_rows, c_cols;
7498 GetCellSize( row, i, &c_rows, &c_cols );
7499 // looks weird going over a multicell
7500 if (m_table->IsEmptyCell(row,i) &&
7501 (rect.width < maxWidth) && (c_rows == 1))
7502 rect.width += GetColWidth(i);
7503 else
7504 break;
7505 }
7506 if (rect.GetRight() > client_right)
7507 rect.SetRight(client_right-1);
7508 }
7509
7510 editor->SetCellAttr(attr);
7511 editor->SetSize( rect );
7512 editor->Show( TRUE, attr );
7513
7514 // recalc dimensions in case we need to
7515 // expand the scrolled window to account for editor
7516 CalcDimensions();
7517
7518 editor->BeginEdit(row, col, this);
7519 editor->SetCellAttr(NULL);
7520
7521 editor->DecRef();
7522 attr->DecRef();
7523 }
7524 }
7525 }
7526
7527
7528 void wxGrid::HideCellEditControl()
7529 {
7530 if ( IsCellEditControlEnabled() )
7531 {
7532 int row = m_currentCellCoords.GetRow();
7533 int col = m_currentCellCoords.GetCol();
7534
7535 wxGridCellAttr* attr = GetCellAttr(row, col);
7536 wxGridCellEditor *editor = attr->GetEditor(this, row, col);
7537 editor->Show( FALSE );
7538 editor->DecRef();
7539 attr->DecRef();
7540 m_gridWin->SetFocus();
7541 // refresh whole row to the right
7542 wxRect rect( CellToRect(row, col) );
7543 CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y );
7544 rect.width = m_gridWin->GetClientSize().GetWidth() - rect.x;
7545 m_gridWin->Refresh( FALSE, &rect );
7546 }
7547 }
7548
7549
7550 void wxGrid::SaveEditControlValue()
7551 {
7552 if ( IsCellEditControlEnabled() )
7553 {
7554 int row = m_currentCellCoords.GetRow();
7555 int col = m_currentCellCoords.GetCol();
7556
7557 wxString oldval = GetCellValue(row,col);
7558
7559 wxGridCellAttr* attr = GetCellAttr(row, col);
7560 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
7561 bool changed = editor->EndEdit(row, col, this);
7562
7563 editor->DecRef();
7564 attr->DecRef();
7565
7566 if (changed)
7567 {
7568 if ( SendEvent( wxEVT_GRID_CELL_CHANGE,
7569 m_currentCellCoords.GetRow(),
7570 m_currentCellCoords.GetCol() ) < 0 ) {
7571
7572 // Event has been vetoed, set the data back.
7573 SetCellValue(row,col,oldval);
7574 }
7575 }
7576 }
7577 }
7578
7579
7580 //
7581 // ------ Grid location functions
7582 // Note that all of these functions work with the logical coordinates of
7583 // grid cells and labels so you will need to convert from device
7584 // coordinates for mouse events etc.
7585 //
7586
7587 void wxGrid::XYToCell( int x, int y, wxGridCellCoords& coords )
7588 {
7589 int row = YToRow(y);
7590 int col = XToCol(x);
7591
7592 if ( row == -1 || col == -1 )
7593 {
7594 coords = wxGridNoCellCoords;
7595 }
7596 else
7597 {
7598 coords.Set( row, col );
7599 }
7600 }
7601
7602
7603 // Internal Helper function for computing row or column from some
7604 // (unscrolled) coordinate value, using either
7605 // m_defaultRowHeight/m_defaultColWidth or binary search on array
7606 // of m_rowBottoms/m_ColRights to speed up the search!
7607
7608 static int CoordToRowOrCol(int coord, int defaultDist, int minDist,
7609 const wxArrayInt& BorderArray, int nMax,
7610 bool clipToMinMax)
7611 {
7612
7613 if (coord < 0)
7614 return clipToMinMax && (nMax > 0) ? 0 : -1;
7615
7616
7617 if (!defaultDist)
7618 defaultDist = 1;
7619
7620 size_t i_max = coord / defaultDist,
7621 i_min = 0;
7622
7623 if (BorderArray.IsEmpty())
7624 {
7625 if((int) i_max < nMax)
7626 return i_max;
7627 return clipToMinMax ? nMax - 1 : -1;
7628 }
7629
7630 if ( i_max >= BorderArray.GetCount())
7631 i_max = BorderArray.GetCount() - 1;
7632 else
7633 {
7634 if ( coord >= BorderArray[i_max])
7635 {
7636 i_min = i_max;
7637 i_max = coord / minDist;
7638 }
7639 if ( i_max >= BorderArray.GetCount())
7640 i_max = BorderArray.GetCount() - 1;
7641 }
7642 if ( coord >= BorderArray[i_max])
7643 return clipToMinMax ? (int)i_max : -1;
7644 if ( coord < BorderArray[0] )
7645 return 0;
7646
7647 while ( i_max - i_min > 0 )
7648 {
7649 wxCHECK_MSG(BorderArray[i_min] <= coord && coord < BorderArray[i_max],
7650 0, _T("wxGrid: internal error in CoordToRowOrCol"));
7651 if (coord >= BorderArray[ i_max - 1])
7652 return i_max;
7653 else
7654 i_max--;
7655 int median = i_min + (i_max - i_min + 1) / 2;
7656 if (coord < BorderArray[median])
7657 i_max = median;
7658 else
7659 i_min = median;
7660 }
7661 return i_max;
7662 }
7663
7664 int wxGrid::YToRow( int y )
7665 {
7666 return CoordToRowOrCol(y, m_defaultRowHeight,
7667 m_minAcceptableRowHeight, m_rowBottoms, m_numRows, FALSE);
7668 }
7669
7670
7671 int wxGrid::XToCol( int x )
7672 {
7673 return CoordToRowOrCol(x, m_defaultColWidth,
7674 m_minAcceptableColWidth, m_colRights, m_numCols, FALSE);
7675 }
7676
7677
7678 // return the row number that that the y coord is near the edge of, or
7679 // -1 if not near an edge
7680 //
7681 int wxGrid::YToEdgeOfRow( int y )
7682 {
7683 int i;
7684 i = internalYToRow(y);
7685
7686 if ( GetRowHeight(i) > WXGRID_LABEL_EDGE_ZONE )
7687 {
7688 // We know that we are in row i, test whether we are
7689 // close enough to lower or upper border, respectively.
7690 if ( abs(GetRowBottom(i) - y) < WXGRID_LABEL_EDGE_ZONE )
7691 return i;
7692 else if( i > 0 && y - GetRowTop(i) < WXGRID_LABEL_EDGE_ZONE )
7693 return i - 1;
7694 }
7695
7696 return -1;
7697 }
7698
7699
7700 // return the col number that that the x coord is near the edge of, or
7701 // -1 if not near an edge
7702 //
7703 int wxGrid::XToEdgeOfCol( int x )
7704 {
7705 int i;
7706 i = internalXToCol(x);
7707
7708 if ( GetColWidth(i) > WXGRID_LABEL_EDGE_ZONE )
7709 {
7710 // We know that we are in column i, test whether we are
7711 // close enough to right or left border, respectively.
7712 if ( abs(GetColRight(i) - x) < WXGRID_LABEL_EDGE_ZONE )
7713 return i;
7714 else if( i > 0 && x - GetColLeft(i) < WXGRID_LABEL_EDGE_ZONE )
7715 return i - 1;
7716 }
7717
7718 return -1;
7719 }
7720
7721
7722 wxRect wxGrid::CellToRect( int row, int col )
7723 {
7724 wxRect rect( -1, -1, -1, -1 );
7725
7726 if ( row >= 0 && row < m_numRows &&
7727 col >= 0 && col < m_numCols )
7728 {
7729 int i, cell_rows, cell_cols;
7730 rect.width = rect.height = 0;
7731 GetCellSize( row, col, &cell_rows, &cell_cols );
7732 // if negative then find multicell owner
7733 if (cell_rows < 0) row += cell_rows;
7734 if (cell_cols < 0) col += cell_cols;
7735 GetCellSize( row, col, &cell_rows, &cell_cols );
7736
7737 rect.x = GetColLeft(col);
7738 rect.y = GetRowTop(row);
7739 for (i=col; i<col+cell_cols; i++)
7740 rect.width += GetColWidth(i);
7741 for (i=row; i<row+cell_rows; i++)
7742 rect.height += GetRowHeight(i);
7743 }
7744
7745 // if grid lines are enabled, then the area of the cell is a bit smaller
7746 if (m_gridLinesEnabled) {
7747 rect.width -= 1;
7748 rect.height -= 1;
7749 }
7750 return rect;
7751 }
7752
7753
7754 bool wxGrid::IsVisible( int row, int col, bool wholeCellVisible )
7755 {
7756 // get the cell rectangle in logical coords
7757 //
7758 wxRect r( CellToRect( row, col ) );
7759
7760 // convert to device coords
7761 //
7762 int left, top, right, bottom;
7763 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
7764 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
7765
7766 // check against the client area of the grid window
7767 //
7768 int cw, ch;
7769 m_gridWin->GetClientSize( &cw, &ch );
7770
7771 if ( wholeCellVisible )
7772 {
7773 // is the cell wholly visible ?
7774 //
7775 return ( left >= 0 && right <= cw &&
7776 top >= 0 && bottom <= ch );
7777 }
7778 else
7779 {
7780 // is the cell partly visible ?
7781 //
7782 return ( ((left >=0 && left < cw) || (right > 0 && right <= cw)) &&
7783 ((top >=0 && top < ch) || (bottom > 0 && bottom <= ch)) );
7784 }
7785 }
7786
7787
7788 // make the specified cell location visible by doing a minimal amount
7789 // of scrolling
7790 //
7791 void wxGrid::MakeCellVisible( int row, int col )
7792 {
7793
7794 int i;
7795 int xpos = -1, ypos = -1;
7796
7797 if ( row >= 0 && row < m_numRows &&
7798 col >= 0 && col < m_numCols )
7799 {
7800 // get the cell rectangle in logical coords
7801 //
7802 wxRect r( CellToRect( row, col ) );
7803
7804 // convert to device coords
7805 //
7806 int left, top, right, bottom;
7807 CalcScrolledPosition( r.GetLeft(), r.GetTop(), &left, &top );
7808 CalcScrolledPosition( r.GetRight(), r.GetBottom(), &right, &bottom );
7809
7810 int cw, ch;
7811 m_gridWin->GetClientSize( &cw, &ch );
7812
7813 if ( top < 0 )
7814 {
7815 ypos = r.GetTop();
7816 }
7817 else if ( bottom > ch )
7818 {
7819 int h = r.GetHeight();
7820 ypos = r.GetTop();
7821 for ( i = row-1; i >= 0; i-- )
7822 {
7823 int rowHeight = GetRowHeight(i);
7824 if ( h + rowHeight > ch )
7825 break;
7826
7827 h += rowHeight;
7828 ypos -= rowHeight;
7829 }
7830
7831 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7832 // have rounding errors (this is important, because if we do, we
7833 // might not scroll at all and some cells won't be redrawn)
7834 //
7835 // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7836 // scroll unit...
7837 ypos += GRID_SCROLL_LINE_Y;
7838 }
7839
7840 if ( left < 0 )
7841 {
7842 xpos = r.GetLeft();
7843 }
7844 else if ( right > cw )
7845 {
7846 // position the view so that the cell is on the right
7847 int x0, y0;
7848 CalcUnscrolledPosition(0, 0, &x0, &y0);
7849 xpos = x0 + (right - cw);
7850
7851 // see comment for ypos above
7852 xpos += GRID_SCROLL_LINE_X;
7853 }
7854
7855 if ( xpos != -1 || ypos != -1 )
7856 {
7857 if ( xpos != -1 )
7858 xpos /= GRID_SCROLL_LINE_X;
7859 if ( ypos != -1 )
7860 ypos /= GRID_SCROLL_LINE_Y;
7861 Scroll( xpos, ypos );
7862 AdjustScrollbars();
7863 }
7864 }
7865 }
7866
7867
7868 //
7869 // ------ Grid cursor movement functions
7870 //
7871
7872 bool wxGrid::MoveCursorUp( bool expandSelection )
7873 {
7874 if ( m_currentCellCoords != wxGridNoCellCoords &&
7875 m_currentCellCoords.GetRow() >= 0 )
7876 {
7877 if ( expandSelection)
7878 {
7879 if ( m_selectingKeyboard == wxGridNoCellCoords )
7880 m_selectingKeyboard = m_currentCellCoords;
7881 if ( m_selectingKeyboard.GetRow() > 0 )
7882 {
7883 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() - 1 );
7884 MakeCellVisible( m_selectingKeyboard.GetRow(),
7885 m_selectingKeyboard.GetCol() );
7886 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7887 }
7888 }
7889 else if ( m_currentCellCoords.GetRow() > 0 )
7890 {
7891 ClearSelection();
7892 MakeCellVisible( m_currentCellCoords.GetRow() - 1,
7893 m_currentCellCoords.GetCol() );
7894 SetCurrentCell( m_currentCellCoords.GetRow() - 1,
7895 m_currentCellCoords.GetCol() );
7896 }
7897 else
7898 return FALSE;
7899 return TRUE;
7900 }
7901
7902 return FALSE;
7903 }
7904
7905
7906 bool wxGrid::MoveCursorDown( bool expandSelection )
7907 {
7908 if ( m_currentCellCoords != wxGridNoCellCoords &&
7909 m_currentCellCoords.GetRow() < m_numRows )
7910 {
7911 if ( expandSelection )
7912 {
7913 if ( m_selectingKeyboard == wxGridNoCellCoords )
7914 m_selectingKeyboard = m_currentCellCoords;
7915 if ( m_selectingKeyboard.GetRow() < m_numRows-1 )
7916 {
7917 m_selectingKeyboard.SetRow( m_selectingKeyboard.GetRow() + 1 );
7918 MakeCellVisible( m_selectingKeyboard.GetRow(),
7919 m_selectingKeyboard.GetCol() );
7920 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7921 }
7922 }
7923 else if ( m_currentCellCoords.GetRow() < m_numRows - 1 )
7924 {
7925 ClearSelection();
7926 MakeCellVisible( m_currentCellCoords.GetRow() + 1,
7927 m_currentCellCoords.GetCol() );
7928 SetCurrentCell( m_currentCellCoords.GetRow() + 1,
7929 m_currentCellCoords.GetCol() );
7930 }
7931 else
7932 return FALSE;
7933 return TRUE;
7934 }
7935
7936 return FALSE;
7937 }
7938
7939
7940 bool wxGrid::MoveCursorLeft( bool expandSelection )
7941 {
7942 if ( m_currentCellCoords != wxGridNoCellCoords &&
7943 m_currentCellCoords.GetCol() >= 0 )
7944 {
7945 if ( expandSelection )
7946 {
7947 if ( m_selectingKeyboard == wxGridNoCellCoords )
7948 m_selectingKeyboard = m_currentCellCoords;
7949 if ( m_selectingKeyboard.GetCol() > 0 )
7950 {
7951 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() - 1 );
7952 MakeCellVisible( m_selectingKeyboard.GetRow(),
7953 m_selectingKeyboard.GetCol() );
7954 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7955 }
7956 }
7957 else if ( m_currentCellCoords.GetCol() > 0 )
7958 {
7959 ClearSelection();
7960 MakeCellVisible( m_currentCellCoords.GetRow(),
7961 m_currentCellCoords.GetCol() - 1 );
7962 SetCurrentCell( m_currentCellCoords.GetRow(),
7963 m_currentCellCoords.GetCol() - 1 );
7964 }
7965 else
7966 return FALSE;
7967 return TRUE;
7968 }
7969
7970 return FALSE;
7971 }
7972
7973
7974 bool wxGrid::MoveCursorRight( bool expandSelection )
7975 {
7976 if ( m_currentCellCoords != wxGridNoCellCoords &&
7977 m_currentCellCoords.GetCol() < m_numCols )
7978 {
7979 if ( expandSelection )
7980 {
7981 if ( m_selectingKeyboard == wxGridNoCellCoords )
7982 m_selectingKeyboard = m_currentCellCoords;
7983 if ( m_selectingKeyboard.GetCol() < m_numCols - 1 )
7984 {
7985 m_selectingKeyboard.SetCol( m_selectingKeyboard.GetCol() + 1 );
7986 MakeCellVisible( m_selectingKeyboard.GetRow(),
7987 m_selectingKeyboard.GetCol() );
7988 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
7989 }
7990 }
7991 else if ( m_currentCellCoords.GetCol() < m_numCols - 1 )
7992 {
7993 ClearSelection();
7994 MakeCellVisible( m_currentCellCoords.GetRow(),
7995 m_currentCellCoords.GetCol() + 1 );
7996 SetCurrentCell( m_currentCellCoords.GetRow(),
7997 m_currentCellCoords.GetCol() + 1 );
7998 }
7999 else
8000 return FALSE;
8001 return TRUE;
8002 }
8003
8004 return FALSE;
8005 }
8006
8007
8008 bool wxGrid::MovePageUp()
8009 {
8010 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
8011
8012 int row = m_currentCellCoords.GetRow();
8013 if ( row > 0 )
8014 {
8015 int cw, ch;
8016 m_gridWin->GetClientSize( &cw, &ch );
8017
8018 int y = GetRowTop(row);
8019 int newRow = internalYToRow( y - ch + 1 );
8020
8021 if ( newRow == row )
8022 {
8023 //row > 0 , so newrow can never be less than 0 here.
8024 newRow = row - 1;
8025 }
8026
8027 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
8028 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
8029
8030 return TRUE;
8031 }
8032
8033 return FALSE;
8034 }
8035
8036 bool wxGrid::MovePageDown()
8037 {
8038 if ( m_currentCellCoords == wxGridNoCellCoords ) return FALSE;
8039
8040 int row = m_currentCellCoords.GetRow();
8041 if ( (row+1) < m_numRows )
8042 {
8043 int cw, ch;
8044 m_gridWin->GetClientSize( &cw, &ch );
8045
8046 int y = GetRowTop(row);
8047 int newRow = internalYToRow( y + ch );
8048 if ( newRow == row )
8049 {
8050 // row < m_numRows , so newrow can't overflow here.
8051 newRow = row + 1;
8052 }
8053
8054 MakeCellVisible( newRow, m_currentCellCoords.GetCol() );
8055 SetCurrentCell( newRow, m_currentCellCoords.GetCol() );
8056
8057 return TRUE;
8058 }
8059
8060 return FALSE;
8061 }
8062
8063 bool wxGrid::MoveCursorUpBlock( bool expandSelection )
8064 {
8065 if ( m_table &&
8066 m_currentCellCoords != wxGridNoCellCoords &&
8067 m_currentCellCoords.GetRow() > 0 )
8068 {
8069 int row = m_currentCellCoords.GetRow();
8070 int col = m_currentCellCoords.GetCol();
8071
8072 if ( m_table->IsEmptyCell(row, col) )
8073 {
8074 // starting in an empty cell: find the next block of
8075 // non-empty cells
8076 //
8077 while ( row > 0 )
8078 {
8079 row-- ;
8080 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8081 }
8082 }
8083 else if ( m_table->IsEmptyCell(row-1, col) )
8084 {
8085 // starting at the top of a block: find the next block
8086 //
8087 row--;
8088 while ( row > 0 )
8089 {
8090 row-- ;
8091 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8092 }
8093 }
8094 else
8095 {
8096 // starting within a block: find the top of the block
8097 //
8098 while ( row > 0 )
8099 {
8100 row-- ;
8101 if ( m_table->IsEmptyCell(row, col) )
8102 {
8103 row++ ;
8104 break;
8105 }
8106 }
8107 }
8108
8109 MakeCellVisible( row, col );
8110 if ( expandSelection )
8111 {
8112 m_selectingKeyboard = wxGridCellCoords( row, col );
8113 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8114 }
8115 else
8116 {
8117 ClearSelection();
8118 SetCurrentCell( row, col );
8119 }
8120 return TRUE;
8121 }
8122
8123 return FALSE;
8124 }
8125
8126 bool wxGrid::MoveCursorDownBlock( bool expandSelection )
8127 {
8128 if ( m_table &&
8129 m_currentCellCoords != wxGridNoCellCoords &&
8130 m_currentCellCoords.GetRow() < m_numRows-1 )
8131 {
8132 int row = m_currentCellCoords.GetRow();
8133 int col = m_currentCellCoords.GetCol();
8134
8135 if ( m_table->IsEmptyCell(row, col) )
8136 {
8137 // starting in an empty cell: find the next block of
8138 // non-empty cells
8139 //
8140 while ( row < m_numRows-1 )
8141 {
8142 row++ ;
8143 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8144 }
8145 }
8146 else if ( m_table->IsEmptyCell(row+1, col) )
8147 {
8148 // starting at the bottom of a block: find the next block
8149 //
8150 row++;
8151 while ( row < m_numRows-1 )
8152 {
8153 row++ ;
8154 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8155 }
8156 }
8157 else
8158 {
8159 // starting within a block: find the bottom of the block
8160 //
8161 while ( row < m_numRows-1 )
8162 {
8163 row++ ;
8164 if ( m_table->IsEmptyCell(row, col) )
8165 {
8166 row-- ;
8167 break;
8168 }
8169 }
8170 }
8171
8172 MakeCellVisible( row, col );
8173 if ( expandSelection )
8174 {
8175 m_selectingKeyboard = wxGridCellCoords( row, col );
8176 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8177 }
8178 else
8179 {
8180 ClearSelection();
8181 SetCurrentCell( row, col );
8182 }
8183
8184 return TRUE;
8185 }
8186
8187 return FALSE;
8188 }
8189
8190 bool wxGrid::MoveCursorLeftBlock( bool expandSelection )
8191 {
8192 if ( m_table &&
8193 m_currentCellCoords != wxGridNoCellCoords &&
8194 m_currentCellCoords.GetCol() > 0 )
8195 {
8196 int row = m_currentCellCoords.GetRow();
8197 int col = m_currentCellCoords.GetCol();
8198
8199 if ( m_table->IsEmptyCell(row, col) )
8200 {
8201 // starting in an empty cell: find the next block of
8202 // non-empty cells
8203 //
8204 while ( col > 0 )
8205 {
8206 col-- ;
8207 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8208 }
8209 }
8210 else if ( m_table->IsEmptyCell(row, col-1) )
8211 {
8212 // starting at the left of a block: find the next block
8213 //
8214 col--;
8215 while ( col > 0 )
8216 {
8217 col-- ;
8218 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8219 }
8220 }
8221 else
8222 {
8223 // starting within a block: find the left of the block
8224 //
8225 while ( col > 0 )
8226 {
8227 col-- ;
8228 if ( m_table->IsEmptyCell(row, col) )
8229 {
8230 col++ ;
8231 break;
8232 }
8233 }
8234 }
8235
8236 MakeCellVisible( row, col );
8237 if ( expandSelection )
8238 {
8239 m_selectingKeyboard = wxGridCellCoords( row, col );
8240 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8241 }
8242 else
8243 {
8244 ClearSelection();
8245 SetCurrentCell( row, col );
8246 }
8247
8248 return TRUE;
8249 }
8250
8251 return FALSE;
8252 }
8253
8254 bool wxGrid::MoveCursorRightBlock( bool expandSelection )
8255 {
8256 if ( m_table &&
8257 m_currentCellCoords != wxGridNoCellCoords &&
8258 m_currentCellCoords.GetCol() < m_numCols-1 )
8259 {
8260 int row = m_currentCellCoords.GetRow();
8261 int col = m_currentCellCoords.GetCol();
8262
8263 if ( m_table->IsEmptyCell(row, col) )
8264 {
8265 // starting in an empty cell: find the next block of
8266 // non-empty cells
8267 //
8268 while ( col < m_numCols-1 )
8269 {
8270 col++ ;
8271 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8272 }
8273 }
8274 else if ( m_table->IsEmptyCell(row, col+1) )
8275 {
8276 // starting at the right of a block: find the next block
8277 //
8278 col++;
8279 while ( col < m_numCols-1 )
8280 {
8281 col++ ;
8282 if ( !(m_table->IsEmptyCell(row, col)) ) break;
8283 }
8284 }
8285 else
8286 {
8287 // starting within a block: find the right of the block
8288 //
8289 while ( col < m_numCols-1 )
8290 {
8291 col++ ;
8292 if ( m_table->IsEmptyCell(row, col) )
8293 {
8294 col-- ;
8295 break;
8296 }
8297 }
8298 }
8299
8300 MakeCellVisible( row, col );
8301 if ( expandSelection )
8302 {
8303 m_selectingKeyboard = wxGridCellCoords( row, col );
8304 HighlightBlock( m_currentCellCoords, m_selectingKeyboard );
8305 }
8306 else
8307 {
8308 ClearSelection();
8309 SetCurrentCell( row, col );
8310 }
8311
8312 return TRUE;
8313 }
8314
8315 return FALSE;
8316 }
8317
8318
8319
8320 //
8321 // ------ Label values and formatting
8322 //
8323
8324 void wxGrid::GetRowLabelAlignment( int *horiz, int *vert )
8325 {
8326 *horiz = m_rowLabelHorizAlign;
8327 *vert = m_rowLabelVertAlign;
8328 }
8329
8330 void wxGrid::GetColLabelAlignment( int *horiz, int *vert )
8331 {
8332 *horiz = m_colLabelHorizAlign;
8333 *vert = m_colLabelVertAlign;
8334 }
8335
8336 int wxGrid::GetColLabelTextOrientation()
8337 {
8338 return m_colLabelTextOrientation;
8339 }
8340
8341 wxString wxGrid::GetRowLabelValue( int row )
8342 {
8343 if ( m_table )
8344 {
8345 return m_table->GetRowLabelValue( row );
8346 }
8347 else
8348 {
8349 wxString s;
8350 s << row;
8351 return s;
8352 }
8353 }
8354
8355 wxString wxGrid::GetColLabelValue( int col )
8356 {
8357 if ( m_table )
8358 {
8359 return m_table->GetColLabelValue( col );
8360 }
8361 else
8362 {
8363 wxString s;
8364 s << col;
8365 return s;
8366 }
8367 }
8368
8369
8370 void wxGrid::SetRowLabelSize( int width )
8371 {
8372 width = wxMax( width, 0 );
8373 if ( width != m_rowLabelWidth )
8374 {
8375 if ( width == 0 )
8376 {
8377 m_rowLabelWin->Show( FALSE );
8378 m_cornerLabelWin->Show( FALSE );
8379 }
8380 else if ( m_rowLabelWidth == 0 )
8381 {
8382 m_rowLabelWin->Show( TRUE );
8383 if ( m_colLabelHeight > 0 ) m_cornerLabelWin->Show( TRUE );
8384 }
8385
8386 m_rowLabelWidth = width;
8387 CalcWindowSizes();
8388 wxScrolledWindow::Refresh( TRUE );
8389 }
8390 }
8391
8392
8393 void wxGrid::SetColLabelSize( int height )
8394 {
8395 height = wxMax( height, 0 );
8396 if ( height != m_colLabelHeight )
8397 {
8398 if ( height == 0 )
8399 {
8400 m_colLabelWin->Show( FALSE );
8401 m_cornerLabelWin->Show( FALSE );
8402 }
8403 else if ( m_colLabelHeight == 0 )
8404 {
8405 m_colLabelWin->Show( TRUE );
8406 if ( m_rowLabelWidth > 0 ) m_cornerLabelWin->Show( TRUE );
8407 }
8408
8409 m_colLabelHeight = height;
8410 CalcWindowSizes();
8411 wxScrolledWindow::Refresh( TRUE );
8412 }
8413 }
8414
8415
8416 void wxGrid::SetLabelBackgroundColour( const wxColour& colour )
8417 {
8418 if ( m_labelBackgroundColour != colour )
8419 {
8420 m_labelBackgroundColour = colour;
8421 m_rowLabelWin->SetBackgroundColour( colour );
8422 m_colLabelWin->SetBackgroundColour( colour );
8423 m_cornerLabelWin->SetBackgroundColour( colour );
8424
8425 if ( !GetBatchCount() )
8426 {
8427 m_rowLabelWin->Refresh();
8428 m_colLabelWin->Refresh();
8429 m_cornerLabelWin->Refresh();
8430 }
8431 }
8432 }
8433
8434 void wxGrid::SetLabelTextColour( const wxColour& colour )
8435 {
8436 if ( m_labelTextColour != colour )
8437 {
8438 m_labelTextColour = colour;
8439 if ( !GetBatchCount() )
8440 {
8441 m_rowLabelWin->Refresh();
8442 m_colLabelWin->Refresh();
8443 }
8444 }
8445 }
8446
8447 void wxGrid::SetLabelFont( const wxFont& font )
8448 {
8449 m_labelFont = font;
8450 if ( !GetBatchCount() )
8451 {
8452 m_rowLabelWin->Refresh();
8453 m_colLabelWin->Refresh();
8454 }
8455 }
8456
8457 void wxGrid::SetRowLabelAlignment( int horiz, int vert )
8458 {
8459 // allow old (incorrect) defs to be used
8460 switch ( horiz )
8461 {
8462 case wxLEFT: horiz = wxALIGN_LEFT; break;
8463 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
8464 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
8465 }
8466
8467 switch ( vert )
8468 {
8469 case wxTOP: vert = wxALIGN_TOP; break;
8470 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
8471 case wxCENTRE: vert = wxALIGN_CENTRE; break;
8472 }
8473
8474 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
8475 {
8476 m_rowLabelHorizAlign = horiz;
8477 }
8478
8479 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
8480 {
8481 m_rowLabelVertAlign = vert;
8482 }
8483
8484 if ( !GetBatchCount() )
8485 {
8486 m_rowLabelWin->Refresh();
8487 }
8488 }
8489
8490 void wxGrid::SetColLabelAlignment( int horiz, int vert )
8491 {
8492 // allow old (incorrect) defs to be used
8493 switch ( horiz )
8494 {
8495 case wxLEFT: horiz = wxALIGN_LEFT; break;
8496 case wxRIGHT: horiz = wxALIGN_RIGHT; break;
8497 case wxCENTRE: horiz = wxALIGN_CENTRE; break;
8498 }
8499
8500 switch ( vert )
8501 {
8502 case wxTOP: vert = wxALIGN_TOP; break;
8503 case wxBOTTOM: vert = wxALIGN_BOTTOM; break;
8504 case wxCENTRE: vert = wxALIGN_CENTRE; break;
8505 }
8506
8507 if ( horiz == wxALIGN_LEFT || horiz == wxALIGN_CENTRE || horiz == wxALIGN_RIGHT )
8508 {
8509 m_colLabelHorizAlign = horiz;
8510 }
8511
8512 if ( vert == wxALIGN_TOP || vert == wxALIGN_CENTRE || vert == wxALIGN_BOTTOM )
8513 {
8514 m_colLabelVertAlign = vert;
8515 }
8516
8517 if ( !GetBatchCount() )
8518 {
8519 m_colLabelWin->Refresh();
8520 }
8521 }
8522
8523 // Note: under MSW, the default column label font must be changed because it
8524 // does not support vertical printing
8525 //
8526 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
8527 // pGrid->SetLabelFont(font);
8528 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
8529 //
8530 void wxGrid::SetColLabelTextOrientation( int textOrientation )
8531 {
8532 if( textOrientation == wxHORIZONTAL || textOrientation == wxVERTICAL )
8533 {
8534 m_colLabelTextOrientation = textOrientation;
8535 }
8536
8537 if ( !GetBatchCount() )
8538 {
8539 m_colLabelWin->Refresh();
8540 }
8541 }
8542
8543 void wxGrid::SetRowLabelValue( int row, const wxString& s )
8544 {
8545 if ( m_table )
8546 {
8547 m_table->SetRowLabelValue( row, s );
8548 if ( !GetBatchCount() )
8549 {
8550 wxRect rect = CellToRect( row, 0);
8551 if ( rect.height > 0 )
8552 {
8553 CalcScrolledPosition(0, rect.y, &rect.x, &rect.y);
8554 rect.x = 0;
8555 rect.width = m_rowLabelWidth;
8556 m_rowLabelWin->Refresh( TRUE, &rect );
8557 }
8558 }
8559 }
8560 }
8561
8562 void wxGrid::SetColLabelValue( int col, const wxString& s )
8563 {
8564 if ( m_table )
8565 {
8566 m_table->SetColLabelValue( col, s );
8567 if ( !GetBatchCount() )
8568 {
8569 wxRect rect = CellToRect( 0, col );
8570 if ( rect.width > 0 )
8571 {
8572 CalcScrolledPosition(rect.x, 0, &rect.x, &rect.y);
8573 rect.y = 0;
8574 rect.height = m_colLabelHeight;
8575 m_colLabelWin->Refresh( TRUE, &rect );
8576 }
8577 }
8578 }
8579 }
8580
8581 void wxGrid::SetGridLineColour( const wxColour& colour )
8582 {
8583 if ( m_gridLineColour != colour )
8584 {
8585 m_gridLineColour = colour;
8586
8587 wxClientDC dc( m_gridWin );
8588 PrepareDC( dc );
8589 DrawAllGridLines( dc, wxRegion() );
8590 }
8591 }
8592
8593
8594 void wxGrid::SetCellHighlightColour( const wxColour& colour )
8595 {
8596 if ( m_cellHighlightColour != colour )
8597 {
8598 m_cellHighlightColour = colour;
8599
8600 wxClientDC dc( m_gridWin );
8601 PrepareDC( dc );
8602 wxGridCellAttr* attr = GetCellAttr(m_currentCellCoords);
8603 DrawCellHighlight(dc, attr);
8604 attr->DecRef();
8605 }
8606 }
8607
8608 void wxGrid::SetCellHighlightPenWidth(int width)
8609 {
8610 if (m_cellHighlightPenWidth != width) {
8611 m_cellHighlightPenWidth = width;
8612
8613 // Just redrawing the cell highlight is not enough since that won't
8614 // make any visible change if the the thickness is getting smaller.
8615 int row = m_currentCellCoords.GetRow();
8616 int col = m_currentCellCoords.GetCol();
8617 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
8618 return;
8619 wxRect rect = CellToRect(row, col);
8620 m_gridWin->Refresh(TRUE, &rect);
8621 }
8622 }
8623
8624 void wxGrid::SetCellHighlightROPenWidth(int width)
8625 {
8626 if (m_cellHighlightROPenWidth != width) {
8627 m_cellHighlightROPenWidth = width;
8628
8629 // Just redrawing the cell highlight is not enough since that won't
8630 // make any visible change if the the thickness is getting smaller.
8631 int row = m_currentCellCoords.GetRow();
8632 int col = m_currentCellCoords.GetCol();
8633 if ( GetColWidth(col) <= 0 || GetRowHeight(row) <= 0 )
8634 return;
8635 wxRect rect = CellToRect(row, col);
8636 m_gridWin->Refresh(TRUE, &rect);
8637 }
8638 }
8639
8640 void wxGrid::EnableGridLines( bool enable )
8641 {
8642 if ( enable != m_gridLinesEnabled )
8643 {
8644 m_gridLinesEnabled = enable;
8645
8646 if ( !GetBatchCount() )
8647 {
8648 if ( enable )
8649 {
8650 wxClientDC dc( m_gridWin );
8651 PrepareDC( dc );
8652 DrawAllGridLines( dc, wxRegion() );
8653 }
8654 else
8655 {
8656 m_gridWin->Refresh();
8657 }
8658 }
8659 }
8660 }
8661
8662
8663 int wxGrid::GetDefaultRowSize()
8664 {
8665 return m_defaultRowHeight;
8666 }
8667
8668 int wxGrid::GetRowSize( int row )
8669 {
8670 wxCHECK_MSG( row >= 0 && row < m_numRows, 0, _T("invalid row index") );
8671
8672 return GetRowHeight(row);
8673 }
8674
8675 int wxGrid::GetDefaultColSize()
8676 {
8677 return m_defaultColWidth;
8678 }
8679
8680 int wxGrid::GetColSize( int col )
8681 {
8682 wxCHECK_MSG( col >= 0 && col < m_numCols, 0, _T("invalid column index") );
8683
8684 return GetColWidth(col);
8685 }
8686
8687 // ============================================================================
8688 // access to the grid attributes: each of them has a default value in the grid
8689 // itself and may be overidden on a per-cell basis
8690 // ============================================================================
8691
8692 // ----------------------------------------------------------------------------
8693 // setting default attributes
8694 // ----------------------------------------------------------------------------
8695
8696 void wxGrid::SetDefaultCellBackgroundColour( const wxColour& col )
8697 {
8698 m_defaultCellAttr->SetBackgroundColour(col);
8699 #ifdef __WXGTK__
8700 m_gridWin->SetBackgroundColour(col);
8701 #endif
8702 }
8703
8704 void wxGrid::SetDefaultCellTextColour( const wxColour& col )
8705 {
8706 m_defaultCellAttr->SetTextColour(col);
8707 }
8708
8709 void wxGrid::SetDefaultCellAlignment( int horiz, int vert )
8710 {
8711 m_defaultCellAttr->SetAlignment(horiz, vert);
8712 }
8713
8714 void wxGrid::SetDefaultCellOverflow( bool allow )
8715 {
8716 m_defaultCellAttr->SetOverflow(allow);
8717 }
8718
8719 void wxGrid::SetDefaultCellFont( const wxFont& font )
8720 {
8721 m_defaultCellAttr->SetFont(font);
8722 }
8723
8724 void wxGrid::SetDefaultRenderer(wxGridCellRenderer *renderer)
8725 {
8726 m_defaultCellAttr->SetRenderer(renderer);
8727 }
8728
8729 void wxGrid::SetDefaultEditor(wxGridCellEditor *editor)
8730 {
8731 m_defaultCellAttr->SetEditor(editor);
8732 }
8733
8734 // ----------------------------------------------------------------------------
8735 // access to the default attrbiutes
8736 // ----------------------------------------------------------------------------
8737
8738 wxColour wxGrid::GetDefaultCellBackgroundColour()
8739 {
8740 return m_defaultCellAttr->GetBackgroundColour();
8741 }
8742
8743 wxColour wxGrid::GetDefaultCellTextColour()
8744 {
8745 return m_defaultCellAttr->GetTextColour();
8746 }
8747
8748 wxFont wxGrid::GetDefaultCellFont()
8749 {
8750 return m_defaultCellAttr->GetFont();
8751 }
8752
8753 void wxGrid::GetDefaultCellAlignment( int *horiz, int *vert )
8754 {
8755 m_defaultCellAttr->GetAlignment(horiz, vert);
8756 }
8757
8758 bool wxGrid::GetDefaultCellOverflow()
8759 {
8760 return m_defaultCellAttr->GetOverflow();
8761 }
8762
8763 wxGridCellRenderer *wxGrid::GetDefaultRenderer() const
8764 {
8765 return m_defaultCellAttr->GetRenderer(NULL, 0, 0);
8766 }
8767
8768 wxGridCellEditor *wxGrid::GetDefaultEditor() const
8769 {
8770 return m_defaultCellAttr->GetEditor(NULL,0,0);
8771 }
8772
8773 // ----------------------------------------------------------------------------
8774 // access to cell attributes
8775 // ----------------------------------------------------------------------------
8776
8777 wxColour wxGrid::GetCellBackgroundColour(int row, int col)
8778 {
8779 wxGridCellAttr *attr = GetCellAttr(row, col);
8780 wxColour colour = attr->GetBackgroundColour();
8781 attr->DecRef();
8782 return colour;
8783 }
8784
8785 wxColour wxGrid::GetCellTextColour( int row, int col )
8786 {
8787 wxGridCellAttr *attr = GetCellAttr(row, col);
8788 wxColour colour = attr->GetTextColour();
8789 attr->DecRef();
8790 return colour;
8791 }
8792
8793 wxFont wxGrid::GetCellFont( int row, int col )
8794 {
8795 wxGridCellAttr *attr = GetCellAttr(row, col);
8796 wxFont font = attr->GetFont();
8797 attr->DecRef();
8798 return font;
8799 }
8800
8801 void wxGrid::GetCellAlignment( int row, int col, int *horiz, int *vert )
8802 {
8803 wxGridCellAttr *attr = GetCellAttr(row, col);
8804 attr->GetAlignment(horiz, vert);
8805 attr->DecRef();
8806 }
8807
8808 bool wxGrid::GetCellOverflow( int row, int col )
8809 {
8810 wxGridCellAttr *attr = GetCellAttr(row, col);
8811 bool allow = attr->GetOverflow();
8812 attr->DecRef();
8813 return allow;
8814 }
8815
8816 void wxGrid::GetCellSize( int row, int col, int *num_rows, int *num_cols )
8817 {
8818 wxGridCellAttr *attr = GetCellAttr(row, col);
8819 attr->GetSize( num_rows, num_cols );
8820 attr->DecRef();
8821 }
8822
8823 wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col)
8824 {
8825 wxGridCellAttr* attr = GetCellAttr(row, col);
8826 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
8827 attr->DecRef();
8828
8829 return renderer;
8830 }
8831
8832 wxGridCellEditor* wxGrid::GetCellEditor(int row, int col)
8833 {
8834 wxGridCellAttr* attr = GetCellAttr(row, col);
8835 wxGridCellEditor* editor = attr->GetEditor(this, row, col);
8836 attr->DecRef();
8837
8838 return editor;
8839 }
8840
8841 bool wxGrid::IsReadOnly(int row, int col) const
8842 {
8843 wxGridCellAttr* attr = GetCellAttr(row, col);
8844 bool isReadOnly = attr->IsReadOnly();
8845 attr->DecRef();
8846 return isReadOnly;
8847 }
8848
8849 // ----------------------------------------------------------------------------
8850 // attribute support: cache, automatic provider creation, ...
8851 // ----------------------------------------------------------------------------
8852
8853 bool wxGrid::CanHaveAttributes()
8854 {
8855 if ( !m_table )
8856 {
8857 return FALSE;
8858 }
8859
8860 return m_table->CanHaveAttributes();
8861 }
8862
8863 void wxGrid::ClearAttrCache()
8864 {
8865 if ( m_attrCache.row != -1 )
8866 {
8867 wxSafeDecRef(m_attrCache.attr);
8868 m_attrCache.attr = NULL;
8869 m_attrCache.row = -1;
8870 }
8871 }
8872
8873 void wxGrid::CacheAttr(int row, int col, wxGridCellAttr *attr) const
8874 {
8875 if ( attr != NULL )
8876 {
8877 wxGrid *self = (wxGrid *)this; // const_cast
8878
8879 self->ClearAttrCache();
8880 self->m_attrCache.row = row;
8881 self->m_attrCache.col = col;
8882 self->m_attrCache.attr = attr;
8883 wxSafeIncRef(attr);
8884 }
8885 }
8886
8887 bool wxGrid::LookupAttr(int row, int col, wxGridCellAttr **attr) const
8888 {
8889 if ( row == m_attrCache.row && col == m_attrCache.col )
8890 {
8891 *attr = m_attrCache.attr;
8892 wxSafeIncRef(m_attrCache.attr);
8893
8894 #ifdef DEBUG_ATTR_CACHE
8895 gs_nAttrCacheHits++;
8896 #endif
8897
8898 return TRUE;
8899 }
8900 else
8901 {
8902 #ifdef DEBUG_ATTR_CACHE
8903 gs_nAttrCacheMisses++;
8904 #endif
8905 return FALSE;
8906 }
8907 }
8908
8909 wxGridCellAttr *wxGrid::GetCellAttr(int row, int col) const
8910 {
8911 wxGridCellAttr *attr = NULL;
8912 // Additional test to avoid looking at the cache e.g. for
8913 // wxNoCellCoords, as this will confuse memory management.
8914 if ( row >= 0 )
8915 {
8916 if ( !LookupAttr(row, col, &attr) )
8917 {
8918 attr = m_table ? m_table->GetAttr(row, col , wxGridCellAttr::Any)
8919 : (wxGridCellAttr *)NULL;
8920 CacheAttr(row, col, attr);
8921 }
8922 }
8923 if (attr)
8924 {
8925 attr->SetDefAttr(m_defaultCellAttr);
8926 }
8927 else
8928 {
8929 attr = m_defaultCellAttr;
8930 attr->IncRef();
8931 }
8932
8933 return attr;
8934 }
8935
8936 wxGridCellAttr *wxGrid::GetOrCreateCellAttr(int row, int col) const
8937 {
8938 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8939
8940 wxCHECK_MSG( m_table, attr,
8941 _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
8942
8943 attr = m_table->GetAttr(row, col, wxGridCellAttr::Cell);
8944 if ( !attr )
8945 {
8946 attr = new wxGridCellAttr(m_defaultCellAttr);
8947
8948 // artificially inc the ref count to match DecRef() in caller
8949 attr->IncRef();
8950 m_table->SetAttr(attr, row, col);
8951 }
8952
8953 return attr;
8954 }
8955
8956 // ----------------------------------------------------------------------------
8957 // setting column attributes (wrappers around SetColAttr)
8958 // ----------------------------------------------------------------------------
8959
8960 void wxGrid::SetColFormatBool(int col)
8961 {
8962 SetColFormatCustom(col, wxGRID_VALUE_BOOL);
8963 }
8964
8965 void wxGrid::SetColFormatNumber(int col)
8966 {
8967 SetColFormatCustom(col, wxGRID_VALUE_NUMBER);
8968 }
8969
8970 void wxGrid::SetColFormatFloat(int col, int width, int precision)
8971 {
8972 wxString typeName = wxGRID_VALUE_FLOAT;
8973 if ( (width != -1) || (precision != -1) )
8974 {
8975 typeName << _T(':') << width << _T(',') << precision;
8976 }
8977
8978 SetColFormatCustom(col, typeName);
8979 }
8980
8981 void wxGrid::SetColFormatCustom(int col, const wxString& typeName)
8982 {
8983 wxGridCellAttr *attr = (wxGridCellAttr *)NULL;
8984
8985 attr = m_table->GetAttr(-1, col, wxGridCellAttr::Col );
8986 if(!attr)
8987 attr = new wxGridCellAttr;
8988 wxGridCellRenderer *renderer = GetDefaultRendererForType(typeName);
8989 attr->SetRenderer(renderer);
8990
8991 SetColAttr(col, attr);
8992
8993 }
8994
8995 // ----------------------------------------------------------------------------
8996 // setting cell attributes: this is forwarded to the table
8997 // ----------------------------------------------------------------------------
8998
8999 void wxGrid::SetAttr(int row, int col, wxGridCellAttr *attr)
9000 {
9001 if ( CanHaveAttributes() )
9002 {
9003 m_table->SetAttr(attr, row, col);
9004 ClearAttrCache();
9005 }
9006 else
9007 {
9008 wxSafeDecRef(attr);
9009 }
9010 }
9011
9012 void wxGrid::SetRowAttr(int row, wxGridCellAttr *attr)
9013 {
9014 if ( CanHaveAttributes() )
9015 {
9016 m_table->SetRowAttr(attr, row);
9017 ClearAttrCache();
9018 }
9019 else
9020 {
9021 wxSafeDecRef(attr);
9022 }
9023 }
9024
9025 void wxGrid::SetColAttr(int col, wxGridCellAttr *attr)
9026 {
9027 if ( CanHaveAttributes() )
9028 {
9029 m_table->SetColAttr(attr, col);
9030 ClearAttrCache();
9031 }
9032 else
9033 {
9034 wxSafeDecRef(attr);
9035 }
9036 }
9037
9038 void wxGrid::SetCellBackgroundColour( int row, int col, const wxColour& colour )
9039 {
9040 if ( CanHaveAttributes() )
9041 {
9042 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9043 attr->SetBackgroundColour(colour);
9044 attr->DecRef();
9045 }
9046 }
9047
9048 void wxGrid::SetCellTextColour( int row, int col, const wxColour& colour )
9049 {
9050 if ( CanHaveAttributes() )
9051 {
9052 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9053 attr->SetTextColour(colour);
9054 attr->DecRef();
9055 }
9056 }
9057
9058 void wxGrid::SetCellFont( int row, int col, const wxFont& font )
9059 {
9060 if ( CanHaveAttributes() )
9061 {
9062 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9063 attr->SetFont(font);
9064 attr->DecRef();
9065 }
9066 }
9067
9068 void wxGrid::SetCellAlignment( int row, int col, int horiz, int vert )
9069 {
9070 if ( CanHaveAttributes() )
9071 {
9072 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9073 attr->SetAlignment(horiz, vert);
9074 attr->DecRef();
9075 }
9076 }
9077
9078 void wxGrid::SetCellOverflow( int row, int col, bool allow )
9079 {
9080 if ( CanHaveAttributes() )
9081 {
9082 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9083 attr->SetOverflow(allow);
9084 attr->DecRef();
9085 }
9086 }
9087
9088 void wxGrid::SetCellSize( int row, int col, int num_rows, int num_cols )
9089 {
9090 if ( CanHaveAttributes() )
9091 {
9092 int cell_rows, cell_cols;
9093
9094 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9095 attr->GetSize(&cell_rows, &cell_cols);
9096 attr->SetSize(num_rows, num_cols);
9097 attr->DecRef();
9098
9099 // Cannot set the size of a cell to 0 or negative values
9100 // While it is perfectly legal to do that, this function cannot
9101 // handle all the possibilies, do it by hand by getting the CellAttr.
9102 // You can only set the size of a cell to 1,1 or greater with this fn
9103 wxASSERT_MSG( !((cell_rows < 1) || (cell_cols < 1)),
9104 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
9105 wxASSERT_MSG( !((num_rows < 1) || (num_cols < 1)),
9106 wxT("wxGrid::SetCellSize setting cell size to < 1"));
9107
9108 // if this was already a multicell then "turn off" the other cells first
9109 if ((cell_rows > 1) || (cell_rows > 1))
9110 {
9111 int i, j;
9112 for (j=row; j<row+cell_rows; j++)
9113 {
9114 for (i=col; i<col+cell_cols; i++)
9115 {
9116 if ((i != col) || (j != row))
9117 {
9118 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9119 attr_stub->SetSize( 1, 1 );
9120 attr_stub->DecRef();
9121 }
9122 }
9123 }
9124 }
9125
9126 // mark the cells that will be covered by this cell to
9127 // negative or zero values to point back at this cell
9128 if (((num_rows > 1) || (num_cols > 1)) && (num_rows >= 1) && (num_cols >= 1))
9129 {
9130 int i, j;
9131 for (j=row; j<row+num_rows; j++)
9132 {
9133 for (i=col; i<col+num_cols; i++)
9134 {
9135 if ((i != col) || (j != row))
9136 {
9137 wxGridCellAttr *attr_stub = GetOrCreateCellAttr(j, i);
9138 attr_stub->SetSize( row-j, col-i );
9139 attr_stub->DecRef();
9140 }
9141 }
9142 }
9143 }
9144 }
9145 }
9146
9147 void wxGrid::SetCellRenderer(int row, int col, wxGridCellRenderer *renderer)
9148 {
9149 if ( CanHaveAttributes() )
9150 {
9151 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9152 attr->SetRenderer(renderer);
9153 attr->DecRef();
9154 }
9155 }
9156
9157 void wxGrid::SetCellEditor(int row, int col, wxGridCellEditor* editor)
9158 {
9159 if ( CanHaveAttributes() )
9160 {
9161 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9162 attr->SetEditor(editor);
9163 attr->DecRef();
9164 }
9165 }
9166
9167 void wxGrid::SetReadOnly(int row, int col, bool isReadOnly)
9168 {
9169 if ( CanHaveAttributes() )
9170 {
9171 wxGridCellAttr *attr = GetOrCreateCellAttr(row, col);
9172 attr->SetReadOnly(isReadOnly);
9173 attr->DecRef();
9174 }
9175 }
9176
9177 // ----------------------------------------------------------------------------
9178 // Data type registration
9179 // ----------------------------------------------------------------------------
9180
9181 void wxGrid::RegisterDataType(const wxString& typeName,
9182 wxGridCellRenderer* renderer,
9183 wxGridCellEditor* editor)
9184 {
9185 m_typeRegistry->RegisterDataType(typeName, renderer, editor);
9186 }
9187
9188
9189 wxGridCellEditor* wxGrid::GetDefaultEditorForCell(int row, int col) const
9190 {
9191 wxString typeName = m_table->GetTypeName(row, col);
9192 return GetDefaultEditorForType(typeName);
9193 }
9194
9195 wxGridCellRenderer* wxGrid::GetDefaultRendererForCell(int row, int col) const
9196 {
9197 wxString typeName = m_table->GetTypeName(row, col);
9198 return GetDefaultRendererForType(typeName);
9199 }
9200
9201 wxGridCellEditor*
9202 wxGrid::GetDefaultEditorForType(const wxString& typeName) const
9203 {
9204 int index = m_typeRegistry->FindOrCloneDataType(typeName);
9205 if ( index == wxNOT_FOUND )
9206 {
9207 wxFAIL_MSG(wxT("Unknown data type name"));
9208
9209 return NULL;
9210 }
9211
9212 return m_typeRegistry->GetEditor(index);
9213 }
9214
9215 wxGridCellRenderer*
9216 wxGrid::GetDefaultRendererForType(const wxString& typeName) const
9217 {
9218 int index = m_typeRegistry->FindOrCloneDataType(typeName);
9219 if ( index == wxNOT_FOUND )
9220 {
9221 wxFAIL_MSG(wxT("Unknown data type name"));
9222
9223 return NULL;
9224 }
9225
9226 return m_typeRegistry->GetRenderer(index);
9227 }
9228
9229
9230 // ----------------------------------------------------------------------------
9231 // row/col size
9232 // ----------------------------------------------------------------------------
9233
9234 void wxGrid::EnableDragRowSize( bool enable )
9235 {
9236 m_canDragRowSize = enable;
9237 }
9238
9239
9240 void wxGrid::EnableDragColSize( bool enable )
9241 {
9242 m_canDragColSize = enable;
9243 }
9244
9245 void wxGrid::EnableDragGridSize( bool enable )
9246 {
9247 m_canDragGridSize = enable;
9248 }
9249
9250
9251 void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows )
9252 {
9253 m_defaultRowHeight = wxMax( height, m_minAcceptableRowHeight );
9254
9255 if ( resizeExistingRows )
9256 {
9257 // since we are resizing all rows to the default row size,
9258 // we can simply clear the row heights and row bottoms
9259 // arrays (which also allows us to take advantage of
9260 // some speed optimisations)
9261 m_rowHeights.Empty();
9262 m_rowBottoms.Empty();
9263 if ( !GetBatchCount() )
9264 CalcDimensions();
9265 }
9266 }
9267
9268 void wxGrid::SetRowSize( int row, int height )
9269 {
9270 wxCHECK_RET( row >= 0 && row < m_numRows, _T("invalid row index") );
9271
9272 // See comment in SetColSize
9273 if ( height < GetRowMinimalAcceptableHeight()) { return; }
9274
9275 if ( m_rowHeights.IsEmpty() )
9276 {
9277 // need to really create the array
9278 InitRowHeights();
9279 }
9280
9281 int h = wxMax( 0, height );
9282 int diff = h - m_rowHeights[row];
9283
9284 m_rowHeights[row] = h;
9285 int i;
9286 for ( i = row; i < m_numRows; i++ )
9287 {
9288 m_rowBottoms[i] += diff;
9289 }
9290 if ( !GetBatchCount() )
9291 CalcDimensions();
9292 }
9293
9294 void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols )
9295 {
9296 m_defaultColWidth = wxMax( width, m_minAcceptableColWidth );
9297
9298 if ( resizeExistingCols )
9299 {
9300 // since we are resizing all columns to the default column size,
9301 // we can simply clear the col widths and col rights
9302 // arrays (which also allows us to take advantage of
9303 // some speed optimisations)
9304 m_colWidths.Empty();
9305 m_colRights.Empty();
9306 if ( !GetBatchCount() )
9307 CalcDimensions();
9308 }
9309 }
9310
9311 void wxGrid::SetColSize( int col, int width )
9312 {
9313 wxCHECK_RET( col >= 0 && col < m_numCols, _T("invalid column index") );
9314
9315 // should we check that it's bigger than GetColMinimalWidth(col) here?
9316 // (VZ)
9317 // No, because it is reasonable to assume the library user know's
9318 // what he is doing. However whe should test against the weaker
9319 // constariant of minimalAcceptableWidth, as this breaks rendering
9320 //
9321 // This test then fixes sf.net bug #645734
9322
9323 if ( width < GetColMinimalAcceptableWidth()) { return; }
9324
9325 if ( m_colWidths.IsEmpty() )
9326 {
9327 // need to really create the array
9328 InitColWidths();
9329 }
9330
9331 // if < 0 calc new width from label
9332 if( width < 0 )
9333 {
9334 long w, h;
9335 wxArrayString lines;
9336 wxClientDC dc(m_colLabelWin);
9337 dc.SetFont(GetLabelFont());
9338 StringToLines(GetColLabelValue(col), lines);
9339 GetTextBoxSize(dc, lines, &w, &h);
9340 width = w + 6;
9341 }
9342 int w = wxMax( 0, width );
9343 int diff = w - m_colWidths[col];
9344 m_colWidths[col] = w;
9345
9346 int i;
9347 for ( i = col; i < m_numCols; i++ )
9348 {
9349 m_colRights[i] += diff;
9350 }
9351 if ( !GetBatchCount() )
9352 CalcDimensions();
9353 }
9354
9355
9356 void wxGrid::SetColMinimalWidth( int col, int width )
9357 {
9358 if (width > GetColMinimalAcceptableWidth()) {
9359 m_colMinWidths.Put(col, width);
9360 }
9361 }
9362
9363 void wxGrid::SetRowMinimalHeight( int row, int width )
9364 {
9365 if (width > GetRowMinimalAcceptableHeight()) {
9366 m_rowMinHeights.Put(row, width);
9367 }
9368 }
9369
9370 int wxGrid::GetColMinimalWidth(int col) const
9371 {
9372 long value = m_colMinWidths.Get(col);
9373 return value != wxNOT_FOUND ? (int)value : m_minAcceptableColWidth;
9374 }
9375
9376 int wxGrid::GetRowMinimalHeight(int row) const
9377 {
9378 long value = m_rowMinHeights.Get(row);
9379 return value != wxNOT_FOUND ? (int)value : m_minAcceptableRowHeight;
9380 }
9381
9382 void wxGrid::SetColMinimalAcceptableWidth( int width )
9383 {
9384 if ( width<1 )
9385 return;
9386 m_minAcceptableColWidth = width;
9387 }
9388
9389 void wxGrid::SetRowMinimalAcceptableHeight( int height )
9390 {
9391 if ( height<1 )
9392 return;
9393 m_minAcceptableRowHeight = height;
9394 };
9395
9396 int wxGrid::GetColMinimalAcceptableWidth() const
9397 {
9398 return m_minAcceptableColWidth;
9399 }
9400
9401 int wxGrid::GetRowMinimalAcceptableHeight() const
9402 {
9403 return m_minAcceptableRowHeight;
9404 }
9405
9406 // ----------------------------------------------------------------------------
9407 // auto sizing
9408 // ----------------------------------------------------------------------------
9409
9410 void wxGrid::AutoSizeColOrRow( int colOrRow, bool setAsMin, bool column )
9411 {
9412 wxClientDC dc(m_gridWin);
9413
9414 // init both of them to avoid compiler warnings, even if weo nly need one
9415 int row = -1,
9416 col = -1;
9417 if ( column )
9418 col = colOrRow;
9419 else
9420 row = colOrRow;
9421
9422 wxCoord extent, extentMax = 0;
9423 int max = column ? m_numRows : m_numCols;
9424 for ( int rowOrCol = 0; rowOrCol < max; rowOrCol++ )
9425 {
9426 if ( column )
9427 row = rowOrCol;
9428 else
9429 col = rowOrCol;
9430
9431 wxGridCellAttr* attr = GetCellAttr(row, col);
9432 wxGridCellRenderer* renderer = attr->GetRenderer(this, row, col);
9433 if ( renderer )
9434 {
9435 wxSize size = renderer->GetBestSize(*this, *attr, dc, row, col);
9436 extent = column ? size.x : size.y;
9437 if ( extent > extentMax )
9438 {
9439 extentMax = extent;
9440 }
9441
9442 renderer->DecRef();
9443 }
9444
9445 attr->DecRef();
9446 }
9447
9448 // now also compare with the column label extent
9449 wxCoord w, h;
9450 dc.SetFont( GetLabelFont() );
9451
9452 if ( column )
9453 {
9454 dc.GetTextExtent( GetColLabelValue(col), &w, &h );
9455 if( GetColLabelTextOrientation() == wxVERTICAL )
9456 w = h;
9457 }
9458 else
9459 dc.GetTextExtent( GetRowLabelValue(row), &w, &h );
9460
9461 extent = column ? w : h;
9462 if ( extent > extentMax )
9463 {
9464 extentMax = extent;
9465 }
9466
9467 if ( !extentMax )
9468 {
9469 // empty column - give default extent (notice that if extentMax is less
9470 // than default extent but != 0, it's ok)
9471 extentMax = column ? m_defaultColWidth : m_defaultRowHeight;
9472 }
9473 else
9474 {
9475 if ( column )
9476 {
9477 // leave some space around text
9478 extentMax += 10;
9479 }
9480 else
9481 {
9482 extentMax += 6;
9483 }
9484 }
9485
9486 if ( column )
9487 {
9488 SetColSize(col, extentMax);
9489 if ( !GetBatchCount() )
9490 {
9491 int cw, ch, dummy;
9492 m_gridWin->GetClientSize( &cw, &ch );
9493 wxRect rect ( CellToRect( 0, col ) );
9494 rect.y = 0;
9495 CalcScrolledPosition(rect.x, 0, &rect.x, &dummy);
9496 rect.width = cw - rect.x;
9497 rect.height = m_colLabelHeight;
9498 m_colLabelWin->Refresh( TRUE, &rect );
9499 }
9500 }
9501 else
9502 {
9503 SetRowSize(row, extentMax);
9504 if ( !GetBatchCount() )
9505 {
9506 int cw, ch, dummy;
9507 m_gridWin->GetClientSize( &cw, &ch );
9508 wxRect rect ( CellToRect( row, 0 ) );
9509 rect.x = 0;
9510 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
9511 rect.width = m_rowLabelWidth;
9512 rect.height = ch - rect.y;
9513 m_rowLabelWin->Refresh( TRUE, &rect );
9514 }
9515 }
9516 if ( setAsMin )
9517 {
9518 if ( column )
9519 SetColMinimalWidth(col, extentMax);
9520 else
9521 SetRowMinimalHeight(row, extentMax);
9522 }
9523 }
9524
9525 int wxGrid::SetOrCalcColumnSizes(bool calcOnly, bool setAsMin)
9526 {
9527 int width = m_rowLabelWidth;
9528
9529 if ( !calcOnly )
9530 BeginBatch();
9531
9532 for ( int col = 0; col < m_numCols; col++ )
9533 {
9534 if ( !calcOnly )
9535 {
9536 AutoSizeColumn(col, setAsMin);
9537 }
9538
9539 width += GetColWidth(col);
9540 }
9541
9542 if ( !calcOnly )
9543 EndBatch();
9544
9545 return width;
9546 }
9547
9548 int wxGrid::SetOrCalcRowSizes(bool calcOnly, bool setAsMin)
9549 {
9550 int height = m_colLabelHeight;
9551
9552 if ( !calcOnly )
9553 BeginBatch();
9554
9555 for ( int row = 0; row < m_numRows; row++ )
9556 {
9557 if ( !calcOnly )
9558 {
9559 AutoSizeRow(row, setAsMin);
9560 }
9561
9562 height += GetRowHeight(row);
9563 }
9564
9565 if ( !calcOnly )
9566 EndBatch();
9567
9568 return height;
9569 }
9570
9571 void wxGrid::AutoSize()
9572 {
9573 BeginBatch();
9574
9575 wxSize size(SetOrCalcColumnSizes(FALSE), SetOrCalcRowSizes(FALSE));
9576
9577 // round up the size to a multiple of scroll step - this ensures that we
9578 // won't get the scrollbars if we're sized exactly to this width
9579 // CalcDimension adds m_extraWidth + 1 etc. to calculate the necessary
9580 // scrollbar steps
9581 wxSize sizeFit(GetScrollX(size.x + m_extraWidth + 1) * GRID_SCROLL_LINE_X,
9582 GetScrollY(size.y + m_extraHeight + 1) * GRID_SCROLL_LINE_Y);
9583
9584 // distribute the extra space between the columns/rows to avoid having
9585 // extra white space
9586
9587 // Remove the extra m_extraWidth + 1 added above
9588 wxCoord diff = sizeFit.x - size.x + (m_extraWidth + 1);
9589 if ( diff && m_numCols )
9590 {
9591 // try to resize the columns uniformly
9592 wxCoord diffPerCol = diff / m_numCols;
9593 if ( diffPerCol )
9594 {
9595 for ( int col = 0; col < m_numCols; col++ )
9596 {
9597 SetColSize(col, GetColWidth(col) + diffPerCol);
9598 }
9599 }
9600
9601 // add remaining amount to the last columns
9602 diff -= diffPerCol * m_numCols;
9603 if ( diff )
9604 {
9605 for ( int col = m_numCols - 1; col >= m_numCols - diff; col-- )
9606 {
9607 SetColSize(col, GetColWidth(col) + 1);
9608 }
9609 }
9610 }
9611
9612 // same for rows
9613 diff = sizeFit.y - size.y - (m_extraHeight + 1);
9614 if ( diff && m_numRows )
9615 {
9616 // try to resize the columns uniformly
9617 wxCoord diffPerRow = diff / m_numRows;
9618 if ( diffPerRow )
9619 {
9620 for ( int row = 0; row < m_numRows; row++ )
9621 {
9622 SetRowSize(row, GetRowHeight(row) + diffPerRow);
9623 }
9624 }
9625
9626 // add remaining amount to the last rows
9627 diff -= diffPerRow * m_numRows;
9628 if ( diff )
9629 {
9630 for ( int row = m_numRows - 1; row >= m_numRows - diff; row-- )
9631 {
9632 SetRowSize(row, GetRowHeight(row) + 1);
9633 }
9634 }
9635 }
9636
9637 EndBatch();
9638
9639 SetClientSize(sizeFit);
9640 }
9641
9642 void wxGrid::AutoSizeRowLabelSize( int row )
9643 {
9644 wxArrayString lines;
9645 long w, h;
9646
9647 // Hide the edit control, so it
9648 // won't interfer with drag-shrinking.
9649 if( IsCellEditControlShown() )
9650 {
9651 HideCellEditControl();
9652 SaveEditControlValue();
9653 }
9654
9655 // autosize row height depending on label text
9656 StringToLines( GetRowLabelValue( row ), lines );
9657 wxClientDC dc( m_rowLabelWin );
9658 GetTextBoxSize( dc, lines, &w, &h);
9659 if( h < m_defaultRowHeight )
9660 h = m_defaultRowHeight;
9661 SetRowSize(row, h);
9662 ForceRefresh();
9663 }
9664
9665 void wxGrid::AutoSizeColLabelSize( int col )
9666 {
9667 wxArrayString lines;
9668 long w, h;
9669
9670 // Hide the edit control, so it
9671 // won't interfer with drag-shrinking.
9672 if( IsCellEditControlShown() )
9673 {
9674 HideCellEditControl();
9675 SaveEditControlValue();
9676 }
9677
9678 // autosize column width depending on label text
9679 StringToLines( GetColLabelValue( col ), lines );
9680 wxClientDC dc( m_colLabelWin );
9681 if( GetColLabelTextOrientation() == wxHORIZONTAL )
9682 GetTextBoxSize( dc, lines, &w, &h);
9683 else
9684 GetTextBoxSize( dc, lines, &h, &w);
9685 if( w < m_defaultColWidth )
9686 w = m_defaultColWidth;
9687 SetColSize(col, w);
9688 ForceRefresh();
9689 }
9690
9691 wxSize wxGrid::DoGetBestSize() const
9692 {
9693 // don't set sizes, only calculate them
9694 wxGrid *self = (wxGrid *)this; // const_cast
9695
9696 int width, height;
9697 width = self->SetOrCalcColumnSizes(TRUE);
9698 height = self->SetOrCalcRowSizes(TRUE);
9699
9700 int maxwidth, maxheight;
9701 wxDisplaySize( & maxwidth, & maxheight );
9702
9703 if ( width > maxwidth ) width = maxwidth;
9704 if ( height > maxheight ) height = maxheight;
9705
9706 return wxSize( width, height );
9707 }
9708
9709 void wxGrid::Fit()
9710 {
9711 AutoSize();
9712 }
9713
9714
9715 wxPen& wxGrid::GetDividerPen() const
9716 {
9717 return wxNullPen;
9718 }
9719
9720 // ----------------------------------------------------------------------------
9721 // cell value accessor functions
9722 // ----------------------------------------------------------------------------
9723
9724 void wxGrid::SetCellValue( int row, int col, const wxString& s )
9725 {
9726 if ( m_table )
9727 {
9728 m_table->SetValue( row, col, s );
9729 if ( !GetBatchCount() )
9730 {
9731 int dummy;
9732 wxRect rect( CellToRect( row, col ) );
9733 rect.x = 0;
9734 rect.width = m_gridWin->GetClientSize().GetWidth();
9735 CalcScrolledPosition(0, rect.y, &dummy, &rect.y);
9736 m_gridWin->Refresh( FALSE, &rect );
9737 }
9738
9739 if ( m_currentCellCoords.GetRow() == row &&
9740 m_currentCellCoords.GetCol() == col &&
9741 IsCellEditControlShown())
9742 // Note: If we are using IsCellEditControlEnabled,
9743 // this interacts badly with calling SetCellValue from
9744 // an EVT_GRID_CELL_CHANGE handler.
9745 {
9746 HideCellEditControl();
9747 ShowCellEditControl(); // will reread data from table
9748 }
9749 }
9750 }
9751
9752
9753 //
9754 // ------ Block, row and col selection
9755 //
9756
9757 void wxGrid::SelectRow( int row, bool addToSelected )
9758 {
9759 if ( IsSelection() && !addToSelected )
9760 ClearSelection();
9761
9762 if ( m_selection )
9763 m_selection->SelectRow( row, FALSE, addToSelected );
9764 }
9765
9766
9767 void wxGrid::SelectCol( int col, bool addToSelected )
9768 {
9769 if ( IsSelection() && !addToSelected )
9770 ClearSelection();
9771
9772 if ( m_selection )
9773 m_selection->SelectCol( col, FALSE, addToSelected );
9774 }
9775
9776
9777 void wxGrid::SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
9778 bool addToSelected )
9779 {
9780 if ( IsSelection() && !addToSelected )
9781 ClearSelection();
9782
9783 if ( m_selection )
9784 m_selection->SelectBlock( topRow, leftCol, bottomRow, rightCol,
9785 FALSE, addToSelected );
9786 }
9787
9788
9789 void wxGrid::SelectAll()
9790 {
9791 if ( m_numRows > 0 && m_numCols > 0 )
9792 {
9793 if ( m_selection )
9794 m_selection->SelectBlock( 0, 0, m_numRows-1, m_numCols-1 );
9795 }
9796 }
9797
9798 //
9799 // ------ Cell, row and col deselection
9800 //
9801
9802 void wxGrid::DeselectRow( int row )
9803 {
9804 if ( !m_selection )
9805 return;
9806
9807 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectRows )
9808 {
9809 if ( m_selection->IsInSelection(row, 0 ) )
9810 m_selection->ToggleCellSelection( row, 0);
9811 }
9812 else
9813 {
9814 int nCols = GetNumberCols();
9815 for ( int i = 0; i < nCols ; i++ )
9816 {
9817 if ( m_selection->IsInSelection(row, i ) )
9818 m_selection->ToggleCellSelection( row, i);
9819 }
9820 }
9821 }
9822
9823 void wxGrid::DeselectCol( int col )
9824 {
9825 if ( !m_selection )
9826 return;
9827
9828 if ( m_selection->GetSelectionMode() == wxGrid::wxGridSelectColumns )
9829 {
9830 if ( m_selection->IsInSelection(0, col ) )
9831 m_selection->ToggleCellSelection( 0, col);
9832 }
9833 else
9834 {
9835 int nRows = GetNumberRows();
9836 for ( int i = 0; i < nRows ; i++ )
9837 {
9838 if ( m_selection->IsInSelection(i, col ) )
9839 m_selection->ToggleCellSelection(i, col);
9840 }
9841 }
9842 }
9843
9844 void wxGrid::DeselectCell( int row, int col )
9845 {
9846 if ( m_selection && m_selection->IsInSelection(row, col) )
9847 m_selection->ToggleCellSelection(row, col);
9848 }
9849
9850 bool wxGrid::IsSelection()
9851 {
9852 return ( m_selection && (m_selection->IsSelection() ||
9853 ( m_selectingTopLeft != wxGridNoCellCoords &&
9854 m_selectingBottomRight != wxGridNoCellCoords) ) );
9855 }
9856
9857 bool wxGrid::IsInSelection( int row, int col ) const
9858 {
9859 return ( m_selection && (m_selection->IsInSelection( row, col ) ||
9860 ( row >= m_selectingTopLeft.GetRow() &&
9861 col >= m_selectingTopLeft.GetCol() &&
9862 row <= m_selectingBottomRight.GetRow() &&
9863 col <= m_selectingBottomRight.GetCol() )) );
9864 }
9865
9866 wxGridCellCoordsArray wxGrid::GetSelectedCells() const
9867 {
9868 if (!m_selection) { wxGridCellCoordsArray a; return a; }
9869 return m_selection->m_cellSelection;
9870 }
9871 wxGridCellCoordsArray wxGrid::GetSelectionBlockTopLeft() const
9872 {
9873 if (!m_selection) { wxGridCellCoordsArray a; return a; }
9874 return m_selection->m_blockSelectionTopLeft;
9875 }
9876 wxGridCellCoordsArray wxGrid::GetSelectionBlockBottomRight() const
9877 {
9878 if (!m_selection) { wxGridCellCoordsArray a; return a; }
9879 return m_selection->m_blockSelectionBottomRight;
9880 }
9881 wxArrayInt wxGrid::GetSelectedRows() const
9882 {
9883 if (!m_selection) { wxArrayInt a; return a; }
9884 return m_selection->m_rowSelection;
9885 }
9886 wxArrayInt wxGrid::GetSelectedCols() const
9887 {
9888 if (!m_selection) { wxArrayInt a; return a; }
9889 return m_selection->m_colSelection;
9890 }
9891
9892
9893 void wxGrid::ClearSelection()
9894 {
9895 m_selectingTopLeft = wxGridNoCellCoords;
9896 m_selectingBottomRight = wxGridNoCellCoords;
9897 if ( m_selection )
9898 m_selection->ClearSelection();
9899 }
9900
9901
9902 // This function returns the rectangle that encloses the given block
9903 // in device coords clipped to the client size of the grid window.
9904 //
9905 wxRect wxGrid::BlockToDeviceRect( const wxGridCellCoords &topLeft,
9906 const wxGridCellCoords &bottomRight )
9907 {
9908 wxRect rect( wxGridNoCellRect );
9909 wxRect cellRect;
9910
9911 cellRect = CellToRect( topLeft );
9912 if ( cellRect != wxGridNoCellRect )
9913 {
9914 rect = cellRect;
9915 }
9916 else
9917 {
9918 rect = wxRect( 0, 0, 0, 0 );
9919 }
9920
9921 cellRect = CellToRect( bottomRight );
9922 if ( cellRect != wxGridNoCellRect )
9923 {
9924 rect += cellRect;
9925 }
9926 else
9927 {
9928 return wxGridNoCellRect;
9929 }
9930
9931 int i, j;
9932 int left = rect.GetLeft();
9933 int top = rect.GetTop();
9934 int right = rect.GetRight();
9935 int bottom = rect.GetBottom();
9936
9937 int leftCol = topLeft.GetCol();
9938 int topRow = topLeft.GetRow();
9939 int rightCol = bottomRight.GetCol();
9940 int bottomRow = bottomRight.GetRow();
9941
9942 if (left > right)
9943 {
9944 i = left;
9945 left = right;
9946 right = i;
9947 i = leftCol;
9948 leftCol=rightCol;
9949 rightCol = i;
9950 }
9951
9952 if (top > bottom)
9953 {
9954 i = top;
9955 top = bottom;
9956 bottom = i;
9957 i = topRow;
9958 topRow = bottomRow;
9959 bottomRow = i;
9960 }
9961
9962
9963 for ( j = topRow; j <= bottomRow; j++ )
9964 {
9965 for ( i = leftCol; i <= rightCol; i++ )
9966 {
9967 if ((j==topRow) || (j==bottomRow) || (i==leftCol) || (i==rightCol))
9968 {
9969 cellRect = CellToRect( j, i );
9970
9971 if (cellRect.x < left)
9972 left = cellRect.x;
9973 if (cellRect.y < top)
9974 top = cellRect.y;
9975 if (cellRect.x + cellRect.width > right)
9976 right = cellRect.x + cellRect.width;
9977 if (cellRect.y + cellRect.height > bottom)
9978 bottom = cellRect.y + cellRect.height;
9979 }
9980 else i = rightCol; // jump over inner cells.
9981 }
9982 }
9983
9984 // convert to scrolled coords
9985 //
9986 CalcScrolledPosition( left, top, &left, &top );
9987 CalcScrolledPosition( right, bottom, &right, &bottom );
9988
9989 int cw, ch;
9990 m_gridWin->GetClientSize( &cw, &ch );
9991
9992 if (right < 0 || bottom < 0 || left > cw || top > ch)
9993 return wxRect( 0, 0, 0, 0);
9994
9995 rect.SetLeft( wxMax(0, left) );
9996 rect.SetTop( wxMax(0, top) );
9997 rect.SetRight( wxMin(cw, right) );
9998 rect.SetBottom( wxMin(ch, bottom) );
9999
10000 return rect;
10001 }
10002
10003 //
10004 // ------ Grid event classes
10005 //
10006
10007 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent, wxNotifyEvent )
10008
10009 wxGridEvent::wxGridEvent( int id, wxEventType type, wxObject* obj,
10010 int row, int col, int x, int y, bool sel,
10011 bool control, bool shift, bool alt, bool meta )
10012 : wxNotifyEvent( type, id )
10013 {
10014 m_row = row;
10015 m_col = col;
10016 m_x = x;
10017 m_y = y;
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( wxGridSizeEvent, wxNotifyEvent )
10029
10030 wxGridSizeEvent::wxGridSizeEvent( int id, wxEventType type, wxObject* obj,
10031 int rowOrCol, int x, int y,
10032 bool control, bool shift, bool alt, bool meta )
10033 : wxNotifyEvent( type, id )
10034 {
10035 m_rowOrCol = rowOrCol;
10036 m_x = x;
10037 m_y = y;
10038 m_control = control;
10039 m_shift = shift;
10040 m_alt = alt;
10041 m_meta = meta;
10042
10043 SetEventObject(obj);
10044 }
10045
10046
10047 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent, wxNotifyEvent )
10048
10049 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id, wxEventType type, wxObject* obj,
10050 const wxGridCellCoords& topLeft,
10051 const wxGridCellCoords& bottomRight,
10052 bool sel, bool control,
10053 bool shift, bool alt, bool meta )
10054 : wxNotifyEvent( type, id )
10055 {
10056 m_topLeft = topLeft;
10057 m_bottomRight = bottomRight;
10058 m_selecting = sel;
10059 m_control = control;
10060 m_shift = shift;
10061 m_alt = alt;
10062 m_meta = meta;
10063
10064 SetEventObject(obj);
10065 }
10066
10067
10068 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent, wxCommandEvent)
10069
10070 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id, wxEventType type,
10071 wxObject* obj, int row,
10072 int col, wxControl* ctrl)
10073 : wxCommandEvent(type, id)
10074 {
10075 SetEventObject(obj);
10076 m_row = row;
10077 m_col = col;
10078 m_ctrl = ctrl;
10079 }
10080
10081 #endif // wxUSE_GRID
10082
wxWidgets (Impactor)