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
8 // Copyright: (c) Michael Bedward (mbedward@ozemail.com.au)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation "grid.h"
24 // For compilers that support precompilatixon, includes "wx/wx.h".
25 #include "wx/wxprec.h"
37 #include "wx/dcclient.h"
38 #include "wx/settings.h"
40 #include "wx/textctrl.h"
41 #include "wx/checkbox.h"
42 #include "wx/combobox.h"
43 #include "wx/valtext.h"
46 #include "wx/textfile.h"
47 #include "wx/spinctrl.h"
48 #include "wx/tokenzr.h"
51 #include "wx/generic/gridsel.h"
53 #if defined(__WXMOTIF__)
54 #define WXUNUSED_MOTIF(identifier) WXUNUSED(identifier)
56 #define WXUNUSED_MOTIF(identifier) identifier
59 #if defined(__WXGTK__)
60 #define WXUNUSED_GTK(identifier) WXUNUSED(identifier)
62 #define WXUNUSED_GTK(identifier) identifier
65 // Required for wxIs... functions
68 // ----------------------------------------------------------------------------
70 // ----------------------------------------------------------------------------
72 WX_DEFINE_EXPORTED_ARRAY_NO_PTR(wxGridCellAttr
*, wxArrayAttrs
);
74 struct wxGridCellWithAttr
76 wxGridCellWithAttr(int row
, int col
, wxGridCellAttr
*attr_
)
77 : coords(row
, col
), attr(attr_
)
86 wxGridCellCoords coords
;
90 // DECLARE_NO_COPY_CLASS(wxGridCellWithAttr)
91 // without rewriting the macros, which require a public copy constructor.
94 WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr
, wxGridCellWithAttrArray
);
96 #include "wx/arrimpl.cpp"
98 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray
)
99 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray
)
101 // ----------------------------------------------------------------------------
103 // ----------------------------------------------------------------------------
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
)
122 // ----------------------------------------------------------------------------
124 // ----------------------------------------------------------------------------
126 class WXDLLIMPEXP_ADV wxGridRowLabelWindow
: public wxWindow
129 wxGridRowLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
130 wxGridRowLabelWindow( wxGrid
*parent
, wxWindowID id
,
131 const wxPoint
&pos
, const wxSize
&size
);
136 void OnPaint( wxPaintEvent
& event
);
137 void OnMouseEvent( wxMouseEvent
& event
);
138 void OnMouseWheel( wxMouseEvent
& event
);
139 void OnKeyDown( wxKeyEvent
& event
);
140 void OnKeyUp( wxKeyEvent
& );
142 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow
)
143 DECLARE_EVENT_TABLE()
144 DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow
)
148 class WXDLLIMPEXP_ADV wxGridColLabelWindow
: public wxWindow
151 wxGridColLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
152 wxGridColLabelWindow( wxGrid
*parent
, wxWindowID id
,
153 const wxPoint
&pos
, const wxSize
&size
);
158 void OnPaint( wxPaintEvent
&event
);
159 void OnMouseEvent( wxMouseEvent
& event
);
160 void OnMouseWheel( wxMouseEvent
& event
);
161 void OnKeyDown( wxKeyEvent
& event
);
162 void OnKeyUp( wxKeyEvent
& );
164 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow
)
165 DECLARE_EVENT_TABLE()
166 DECLARE_NO_COPY_CLASS(wxGridColLabelWindow
)
170 class WXDLLIMPEXP_ADV wxGridCornerLabelWindow
: public wxWindow
173 wxGridCornerLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
174 wxGridCornerLabelWindow( wxGrid
*parent
, wxWindowID id
,
175 const wxPoint
&pos
, const wxSize
&size
);
180 void OnMouseEvent( wxMouseEvent
& event
);
181 void OnMouseWheel( wxMouseEvent
& event
);
182 void OnKeyDown( wxKeyEvent
& event
);
183 void OnKeyUp( wxKeyEvent
& );
184 void OnPaint( wxPaintEvent
& event
);
186 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow
)
187 DECLARE_EVENT_TABLE()
188 DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow
)
191 class WXDLLIMPEXP_ADV wxGridWindow
: public wxWindow
196 m_owner
= (wxGrid
*)NULL
;
197 m_rowLabelWin
= (wxGridRowLabelWindow
*)NULL
;
198 m_colLabelWin
= (wxGridColLabelWindow
*)NULL
;
201 wxGridWindow( wxGrid
*parent
,
202 wxGridRowLabelWindow
*rowLblWin
,
203 wxGridColLabelWindow
*colLblWin
,
204 wxWindowID id
, const wxPoint
&pos
, const wxSize
&size
);
207 void ScrollWindow( int dx
, int dy
, const wxRect
*rect
);
209 wxGrid
* GetOwner() { return m_owner
; }
213 wxGridRowLabelWindow
*m_rowLabelWin
;
214 wxGridColLabelWindow
*m_colLabelWin
;
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
& );
224 DECLARE_DYNAMIC_CLASS(wxGridWindow
)
225 DECLARE_EVENT_TABLE()
226 DECLARE_NO_COPY_CLASS(wxGridWindow
)
231 class wxGridCellEditorEvtHandler
: public wxEvtHandler
234 wxGridCellEditorEvtHandler()
235 : m_grid(0), m_editor(0)
237 wxGridCellEditorEvtHandler(wxGrid
* grid
, wxGridCellEditor
* editor
)
238 : m_grid(grid
), m_editor(editor
)
241 void OnKeyDown(wxKeyEvent
& event
);
242 void OnChar(wxKeyEvent
& event
);
246 wxGridCellEditor
* m_editor
;
247 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler
)
248 DECLARE_EVENT_TABLE()
249 DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler
)
253 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler
, wxEvtHandler
)
254 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler
, wxEvtHandler
)
255 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown
)
256 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar
)
261 // ----------------------------------------------------------------------------
262 // the internal data representation used by wxGridCellAttrProvider
263 // ----------------------------------------------------------------------------
265 // this class stores attributes set for cells
266 class WXDLLIMPEXP_ADV wxGridCellAttrData
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
);
275 // searches for the attr for given cell, returns wxNOT_FOUND if not found
276 int FindIndex(int row
, int col
) const;
278 wxGridCellWithAttrArray m_attrs
;
281 // this class stores attributes set for rows or columns
282 class WXDLLIMPEXP_ADV wxGridRowOrColAttrData
285 // empty ctor to suppress warnings
286 wxGridRowOrColAttrData() { }
287 ~wxGridRowOrColAttrData();
289 void SetAttr(wxGridCellAttr
*attr
, int rowOrCol
);
290 wxGridCellAttr
*GetAttr(int rowOrCol
) const;
291 void UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
);
294 wxArrayInt m_rowsOrCols
;
295 wxArrayAttrs m_attrs
;
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 WXDLLIMPEXP_ADV wxGridCellAttrProviderData
303 wxGridCellAttrData m_cellAttrs
;
304 wxGridRowOrColAttrData m_rowAttrs
,
309 // ----------------------------------------------------------------------------
310 // data structures used for the data type registry
311 // ----------------------------------------------------------------------------
313 struct wxGridDataTypeInfo
315 wxGridDataTypeInfo(const wxString
& typeName
,
316 wxGridCellRenderer
* renderer
,
317 wxGridCellEditor
* editor
)
318 : m_typeName(typeName
), m_renderer(renderer
), m_editor(editor
)
321 ~wxGridDataTypeInfo()
323 wxSafeDecRef(m_renderer
);
324 wxSafeDecRef(m_editor
);
328 wxGridCellRenderer
* m_renderer
;
329 wxGridCellEditor
* m_editor
;
331 DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo
)
335 WX_DEFINE_EXPORTED_ARRAY_NO_PTR(wxGridDataTypeInfo
*, wxGridDataTypeInfoArray
);
338 class WXDLLIMPEXP_ADV wxGridTypeRegistry
341 wxGridTypeRegistry() {}
342 ~wxGridTypeRegistry();
344 void RegisterDataType(const wxString
& typeName
,
345 wxGridCellRenderer
* renderer
,
346 wxGridCellEditor
* editor
);
348 // find one of already registered data types
349 int FindRegisteredDataType(const wxString
& typeName
);
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
);
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
);
360 wxGridCellRenderer
* GetRenderer(int index
);
361 wxGridCellEditor
* GetEditor(int index
);
364 wxGridDataTypeInfoArray m_typeinfo
;
367 // ----------------------------------------------------------------------------
368 // conditional compilation
369 // ----------------------------------------------------------------------------
371 #ifndef WXGRID_DRAW_LINES
372 #define WXGRID_DRAW_LINES 1
375 // ----------------------------------------------------------------------------
377 // ----------------------------------------------------------------------------
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
385 // ----------------------------------------------------------------------------
387 // ----------------------------------------------------------------------------
389 wxGridCellCoords
wxGridNoCellCoords( -1, -1 );
390 wxRect
wxGridNoCellRect( -1, -1, -1, -1 );
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
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!!!
401 // Well, it's still seriously broken so it might be better but needs
404 static const size_t GRID_SCROLL_LINE_X
= 15; // 1;
405 static const size_t GRID_SCROLL_LINE_Y
= GRID_SCROLL_LINE_X
;
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;
411 // ----------------------------------------------------------------------------
413 // ----------------------------------------------------------------------------
415 static inline int GetScrollX(int x
)
417 return (x
+ GRID_SCROLL_LINE_X
- 1) / GRID_SCROLL_LINE_X
;
420 static inline int GetScrollY(int y
)
422 return (y
+ GRID_SCROLL_LINE_Y
- 1) / GRID_SCROLL_LINE_Y
;
425 // ============================================================================
427 // ============================================================================
429 // ----------------------------------------------------------------------------
431 // ----------------------------------------------------------------------------
433 wxGridCellEditor::wxGridCellEditor()
440 wxGridCellEditor::~wxGridCellEditor()
445 void wxGridCellEditor::Create(wxWindow
* WXUNUSED(parent
),
446 wxWindowID
WXUNUSED(id
),
447 wxEvtHandler
* evtHandler
)
450 m_control
->PushEventHandler(evtHandler
);
453 void wxGridCellEditor::PaintBackground(const wxRect
& rectCell
,
454 wxGridCellAttr
*attr
)
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
);
460 gridWindow
->GetOwner()->PrepareDC(dc
);
462 dc
.SetPen(*wxTRANSPARENT_PEN
);
463 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
464 dc
.DrawRectangle(rectCell
);
466 // redraw the control we just painted over
467 m_control
->Refresh();
470 void wxGridCellEditor::Destroy()
474 m_control
->PopEventHandler(TRUE
/* delete it*/);
476 m_control
->Destroy();
481 void wxGridCellEditor::Show(bool show
, wxGridCellAttr
*attr
)
483 wxASSERT_MSG(m_control
,
484 wxT("The wxGridCellEditor must be Created first!"));
485 m_control
->Show(show
);
489 // set the colours/fonts if we have any
492 m_colFgOld
= m_control
->GetForegroundColour();
493 m_control
->SetForegroundColour(attr
->GetTextColour());
495 m_colBgOld
= m_control
->GetBackgroundColour();
496 m_control
->SetBackgroundColour(attr
->GetBackgroundColour());
498 m_fontOld
= m_control
->GetFont();
499 m_control
->SetFont(attr
->GetFont());
501 // can't do anything more in the base class version, the other
502 // attributes may only be used by the derived classes
507 // restore the standard colours fonts
508 if ( m_colFgOld
.Ok() )
510 m_control
->SetForegroundColour(m_colFgOld
);
511 m_colFgOld
= wxNullColour
;
514 if ( m_colBgOld
.Ok() )
516 m_control
->SetBackgroundColour(m_colBgOld
);
517 m_colBgOld
= wxNullColour
;
520 if ( m_fontOld
.Ok() )
522 m_control
->SetFont(m_fontOld
);
523 m_fontOld
= wxNullFont
;
528 void wxGridCellEditor::SetSize(const wxRect
& rect
)
530 wxASSERT_MSG(m_control
,
531 wxT("The wxGridCellEditor must be Created first!"));
532 m_control
->SetSize(rect
, wxSIZE_ALLOW_MINUS_ONE
);
535 void wxGridCellEditor::HandleReturn(wxKeyEvent
& event
)
540 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent
& event
)
542 // accept the simple key presses, not anything with Ctrl/Alt/Meta
543 return !(event
.ControlDown() || event
.AltDown());
546 void wxGridCellEditor::StartingKey(wxKeyEvent
& event
)
551 void wxGridCellEditor::StartingClick()
557 // ----------------------------------------------------------------------------
558 // wxGridCellTextEditor
559 // ----------------------------------------------------------------------------
561 wxGridCellTextEditor::wxGridCellTextEditor()
566 void wxGridCellTextEditor::Create(wxWindow
* parent
,
568 wxEvtHandler
* evtHandler
)
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
578 // set max length allowed in the textctrl, if the parameter was set
581 ((wxTextCtrl
*)m_control
)->SetMaxLength(m_maxChars
);
584 wxGridCellEditor::Create(parent
, id
, evtHandler
);
587 void wxGridCellTextEditor::PaintBackground(const wxRect
& WXUNUSED(rectCell
),
588 wxGridCellAttr
* WXUNUSED(attr
))
590 // as we fill the entire client area, don't do anything here to minimize
594 void wxGridCellTextEditor::SetSize(const wxRect
& rectOrig
)
596 wxRect
rect(rectOrig
);
598 // Make the edit control large enough to allow for internal
601 // TODO: remove this if the text ctrl sizing is improved esp. for
604 #if defined(__WXGTK__)
613 int extra_x
= ( rect
.x
> 2 )? 2 : 1;
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__)
620 int extra_y
= ( rect
.y
> 2 )? 2 : 1;
623 #if defined(__WXMOTIF__)
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
);
633 wxGridCellEditor::SetSize(rect
);
636 void wxGridCellTextEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
638 wxASSERT_MSG(m_control
,
639 wxT("The wxGridCellEditor must be Created first!"));
641 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
643 DoBeginEdit(m_startValue
);
646 void wxGridCellTextEditor::DoBeginEdit(const wxString
& startValue
)
648 Text()->SetValue(startValue
);
649 Text()->SetInsertionPointEnd();
650 Text()->SetSelection(-1,-1);
654 bool wxGridCellTextEditor::EndEdit(int row
, int col
,
657 wxASSERT_MSG(m_control
,
658 wxT("The wxGridCellEditor must be Created first!"));
660 bool changed
= FALSE
;
661 wxString value
= Text()->GetValue();
662 if (value
!= m_startValue
)
666 grid
->GetTable()->SetValue(row
, col
, value
);
668 m_startValue
= wxEmptyString
;
669 Text()->SetValue(m_startValue
);
675 void wxGridCellTextEditor::Reset()
677 wxASSERT_MSG(m_control
,
678 wxT("The wxGridCellEditor must be Created first!"));
680 DoReset(m_startValue
);
683 void wxGridCellTextEditor::DoReset(const wxString
& startValue
)
685 Text()->SetValue(startValue
);
686 Text()->SetInsertionPointEnd();
689 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent
& event
)
691 if ( wxGridCellEditor::IsAcceptedKey(event
) )
693 int keycode
= event
.GetKeyCode();
707 case WXK_NUMPAD_MULTIPLY
:
711 case WXK_NUMPAD_SUBTRACT
:
713 case WXK_NUMPAD_DECIMAL
:
715 case WXK_NUMPAD_DIVIDE
:
719 // accept 8 bit chars too if isprint() agrees
720 if ( (keycode
< 255) && (wxIsprint(keycode
)) )
728 void wxGridCellTextEditor::StartingKey(wxKeyEvent
& event
)
730 if ( !Text()->EmulateKeyPress(event
) )
736 void wxGridCellTextEditor::HandleReturn( wxKeyEvent
&
737 WXUNUSED_GTK(WXUNUSED_MOTIF(event
)) )
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
);
745 Text()->SetInsertionPoint( pos
);
747 // the other ports can handle a Return key press
753 void wxGridCellTextEditor::SetParameters(const wxString
& params
)
763 if ( !params
.ToLong(&tmp
) )
765 wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params
.c_str());
769 m_maxChars
= (size_t)tmp
;
774 // return the value in the text control
775 wxString
wxGridCellTextEditor::GetValue() const
777 return Text()->GetValue();
780 // ----------------------------------------------------------------------------
781 // wxGridCellNumberEditor
782 // ----------------------------------------------------------------------------
784 wxGridCellNumberEditor::wxGridCellNumberEditor(int min
, int max
)
790 void wxGridCellNumberEditor::Create(wxWindow
* parent
,
792 wxEvtHandler
* evtHandler
)
796 // create a spin ctrl
797 m_control
= new wxSpinCtrl(parent
, -1, wxEmptyString
,
798 wxDefaultPosition
, wxDefaultSize
,
802 wxGridCellEditor::Create(parent
, id
, evtHandler
);
806 // just a text control
807 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
810 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
811 #endif // wxUSE_VALIDATORS
815 void wxGridCellNumberEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
817 // first get the value
818 wxGridTableBase
*table
= grid
->GetTable();
819 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
821 m_valueOld
= table
->GetValueAsLong(row
, col
);
826 wxString sValue
= table
->GetValue(row
, col
);
827 if (! sValue
.ToLong(&m_valueOld
) && ! sValue
.IsEmpty())
829 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
836 Spin()->SetValue((int)m_valueOld
);
841 DoBeginEdit(GetString());
845 bool wxGridCellNumberEditor::EndEdit(int row
, int col
,
854 value
= Spin()->GetValue();
855 changed
= value
!= m_valueOld
;
857 text
= wxString::Format(wxT("%ld"), value
);
861 text
= Text()->GetValue();
862 changed
= (text
.IsEmpty() || text
.ToLong(&value
)) && (value
!= m_valueOld
);
867 if (grid
->GetTable()->CanSetValueAs(row
, col
, wxGRID_VALUE_NUMBER
))
868 grid
->GetTable()->SetValueAsLong(row
, col
, value
);
870 grid
->GetTable()->SetValue(row
, col
, text
);
876 void wxGridCellNumberEditor::Reset()
880 Spin()->SetValue((int)m_valueOld
);
884 DoReset(GetString());
888 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent
& event
)
890 if ( wxGridCellEditor::IsAcceptedKey(event
) )
892 int keycode
= event
.GetKeyCode();
908 case WXK_NUMPAD_SUBTRACT
:
914 if ( (keycode
< 128) && wxIsdigit(keycode
) )
922 void wxGridCellNumberEditor::StartingKey(wxKeyEvent
& event
)
926 int keycode
= event
.GetKeyCode();
927 if ( wxIsdigit(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
)
943 wxGridCellTextEditor::StartingKey(event
);
953 void wxGridCellNumberEditor::SetParameters(const wxString
& params
)
964 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
968 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
972 // skip the error message below
977 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params
.c_str());
981 // return the value in the spin control if it is there (the text control otherwise)
982 wxString
wxGridCellNumberEditor::GetValue() const
988 long value
= Spin()->GetValue();
989 s
.Printf(wxT("%ld"), value
);
993 s
= Text()->GetValue();
998 // ----------------------------------------------------------------------------
999 // wxGridCellFloatEditor
1000 // ----------------------------------------------------------------------------
1002 wxGridCellFloatEditor::wxGridCellFloatEditor(int width
, int precision
)
1005 m_precision
= precision
;
1008 void wxGridCellFloatEditor::Create(wxWindow
* parent
,
1010 wxEvtHandler
* evtHandler
)
1012 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
1014 #if wxUSE_VALIDATORS
1015 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
1016 #endif // wxUSE_VALIDATORS
1019 void wxGridCellFloatEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1021 // first get the value
1022 wxGridTableBase
*table
= grid
->GetTable();
1023 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
1025 m_valueOld
= table
->GetValueAsDouble(row
, col
);
1030 wxString sValue
= table
->GetValue(row
, col
);
1031 if (! sValue
.ToDouble(&m_valueOld
) && ! sValue
.IsEmpty())
1033 wxFAIL_MSG( _T("this cell doesn't have float value") );
1038 DoBeginEdit(GetString());
1041 bool wxGridCellFloatEditor::EndEdit(int row
, int col
,
1045 wxString
text(Text()->GetValue());
1047 if ( (text
.IsEmpty() || text
.ToDouble(&value
)) && (value
!= m_valueOld
) )
1049 if (grid
->GetTable()->CanSetValueAs(row
, col
, wxGRID_VALUE_FLOAT
))
1050 grid
->GetTable()->SetValueAsDouble(row
, col
, value
);
1052 grid
->GetTable()->SetValue(row
, col
, text
);
1059 void wxGridCellFloatEditor::Reset()
1061 DoReset(GetString());
1064 void wxGridCellFloatEditor::StartingKey(wxKeyEvent
& event
)
1066 int keycode
= event
.GetKeyCode();
1067 if ( wxIsdigit(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
)
1083 wxGridCellTextEditor::StartingKey(event
);
1085 // skip Skip() below
1092 void wxGridCellFloatEditor::SetParameters(const wxString
& params
)
1103 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
1107 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
1109 m_precision
= (int)tmp
;
1111 // skip the error message below
1116 wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params
.c_str());
1120 wxString
wxGridCellFloatEditor::GetString() const
1123 if ( m_width
== -1 )
1125 // default width/precision
1128 else if ( m_precision
== -1 )
1130 // default precision
1131 fmt
.Printf(_T("%%%d.f"), m_width
);
1135 fmt
.Printf(_T("%%%d.%df"), m_width
, m_precision
);
1138 return wxString::Format(fmt
, m_valueOld
);
1141 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent
& event
)
1143 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1145 int keycode
= event
.GetKeyCode();
1159 case WXK_NUMPAD_ADD
:
1161 case WXK_NUMPAD_SUBTRACT
:
1163 case WXK_NUMPAD_DECIMAL
:
1167 // additionally accept 'e' as in '1e+6'
1168 if ( (keycode
< 128) &&
1169 (wxIsdigit(keycode
) || tolower(keycode
) == 'e') )
1177 #endif // wxUSE_TEXTCTRL
1181 // ----------------------------------------------------------------------------
1182 // wxGridCellBoolEditor
1183 // ----------------------------------------------------------------------------
1185 void wxGridCellBoolEditor::Create(wxWindow
* parent
,
1187 wxEvtHandler
* evtHandler
)
1189 m_control
= new wxCheckBox(parent
, id
, wxEmptyString
,
1190 wxDefaultPosition
, wxDefaultSize
,
1193 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1196 void wxGridCellBoolEditor::SetSize(const wxRect
& r
)
1198 bool resize
= FALSE
;
1199 wxSize size
= m_control
->GetSize();
1200 wxCoord minSize
= wxMin(r
.width
, r
.height
);
1202 // check if the checkbox is not too big/small for this cell
1203 wxSize sizeBest
= m_control
->GetBestSize();
1204 if ( !(size
== sizeBest
) )
1206 // reset to default size if it had been made smaller
1212 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
1214 // leave 1 pixel margin
1215 size
.x
= size
.y
= minSize
- 2;
1222 m_control
->SetSize(size
);
1225 // position it in the centre of the rectangle (TODO: support alignment?)
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
1231 #elif defined(__WXMSW__)
1232 // here too, but in other way
1237 int hAlign
= wxALIGN_CENTRE
;
1238 int vAlign
= wxALIGN_CENTRE
;
1240 GetCellAttr()->GetAlignment(& hAlign
, & vAlign
);
1243 if (hAlign
== wxALIGN_LEFT
)
1249 y
= r
.y
+ r
.height
/2 - size
.y
/2;
1251 else if (hAlign
== wxALIGN_RIGHT
)
1253 x
= r
.x
+ r
.width
- size
.x
- 2;
1254 y
= r
.y
+ r
.height
/2 - size
.y
/2;
1256 else if (hAlign
== wxALIGN_CENTRE
)
1258 x
= r
.x
+ r
.width
/2 - size
.x
/2;
1259 y
= r
.y
+ r
.height
/2 - size
.y
/2;
1262 m_control
->Move(x
, y
);
1265 void wxGridCellBoolEditor::Show(bool show
, wxGridCellAttr
*attr
)
1267 m_control
->Show(show
);
1271 wxColour colBg
= attr
? attr
->GetBackgroundColour() : *wxLIGHT_GREY
;
1272 CBox()->SetBackgroundColour(colBg
);
1276 void wxGridCellBoolEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1278 wxASSERT_MSG(m_control
,
1279 wxT("The wxGridCellEditor must be Created first!"));
1281 if (grid
->GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
))
1282 m_startValue
= grid
->GetTable()->GetValueAsBool(row
, col
);
1285 wxString
cellval( grid
->GetTable()->GetValue(row
, col
) );
1286 m_startValue
= !( !cellval
|| (cellval
== wxT("0")) );
1288 CBox()->SetValue(m_startValue
);
1292 bool wxGridCellBoolEditor::EndEdit(int row
, int col
,
1295 wxASSERT_MSG(m_control
,
1296 wxT("The wxGridCellEditor must be Created first!"));
1298 bool changed
= FALSE
;
1299 bool value
= CBox()->GetValue();
1300 if ( value
!= m_startValue
)
1305 if (grid
->GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
))
1306 grid
->GetTable()->SetValueAsBool(row
, col
, value
);
1308 grid
->GetTable()->SetValue(row
, col
, value
? _T("1") : wxEmptyString
);
1314 void wxGridCellBoolEditor::Reset()
1316 wxASSERT_MSG(m_control
,
1317 wxT("The wxGridCellEditor must be Created first!"));
1319 CBox()->SetValue(m_startValue
);
1322 void wxGridCellBoolEditor::StartingClick()
1324 CBox()->SetValue(!CBox()->GetValue());
1327 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent
& event
)
1329 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1331 int keycode
= event
.GetKeyCode();
1335 case WXK_NUMPAD_MULTIPLY
:
1337 case WXK_NUMPAD_ADD
:
1339 case WXK_NUMPAD_SUBTRACT
:
1350 // return the value as "1" for true and the empty string for false
1351 wxString
wxGridCellBoolEditor::GetValue() const
1353 bool bSet
= CBox()->GetValue();
1354 return bSet
? _T("1") : wxEmptyString
;
1357 #endif // wxUSE_CHECKBOX
1361 // ----------------------------------------------------------------------------
1362 // wxGridCellChoiceEditor
1363 // ----------------------------------------------------------------------------
1365 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count
,
1366 const wxString choices
[],
1368 : m_allowOthers(allowOthers
)
1372 m_choices
.Alloc(count
);
1373 for ( size_t n
= 0; n
< count
; n
++ )
1375 m_choices
.Add(choices
[n
]);
1380 wxGridCellEditor
*wxGridCellChoiceEditor::Clone() const
1382 wxGridCellChoiceEditor
*editor
= new wxGridCellChoiceEditor
;
1383 editor
->m_allowOthers
= m_allowOthers
;
1384 editor
->m_choices
= m_choices
;
1389 void wxGridCellChoiceEditor::Create(wxWindow
* parent
,
1391 wxEvtHandler
* evtHandler
)
1393 size_t count
= m_choices
.GetCount();
1394 wxString
*choices
= new wxString
[count
];
1395 for ( size_t n
= 0; n
< count
; n
++ )
1397 choices
[n
] = m_choices
[n
];
1400 m_control
= new wxComboBox(parent
, id
, wxEmptyString
,
1401 wxDefaultPosition
, wxDefaultSize
,
1403 m_allowOthers
? 0 : wxCB_READONLY
);
1407 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1410 void wxGridCellChoiceEditor::PaintBackground(const wxRect
& rectCell
,
1411 wxGridCellAttr
* attr
)
1413 // as we fill the entire client area, don't do anything here to minimize
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
);
1422 void wxGridCellChoiceEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1424 wxASSERT_MSG(m_control
,
1425 wxT("The wxGridCellEditor must be Created first!"));
1427 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
1430 Combo()->SetValue(m_startValue
);
1433 // find the right position, or default to the first if not found
1434 int pos
= Combo()->FindString(m_startValue
);
1437 Combo()->SetSelection(pos
);
1439 Combo()->SetInsertionPointEnd();
1440 Combo()->SetFocus();
1443 bool wxGridCellChoiceEditor::EndEdit(int row
, int col
,
1446 wxString value
= Combo()->GetValue();
1447 bool changed
= value
!= m_startValue
;
1450 grid
->GetTable()->SetValue(row
, col
, value
);
1452 m_startValue
= wxEmptyString
;
1454 Combo()->SetValue(m_startValue
);
1456 Combo()->SetSelection(0);
1461 void wxGridCellChoiceEditor::Reset()
1463 Combo()->SetValue(m_startValue
);
1464 Combo()->SetInsertionPointEnd();
1467 void wxGridCellChoiceEditor::SetParameters(const wxString
& params
)
1477 wxStringTokenizer
tk(params
, _T(','));
1478 while ( tk
.HasMoreTokens() )
1480 m_choices
.Add(tk
.GetNextToken());
1484 // return the value in the text control
1485 wxString
wxGridCellChoiceEditor::GetValue() const
1487 return Combo()->GetValue();
1490 #endif // wxUSE_COMBOBOX
1492 // ----------------------------------------------------------------------------
1493 // wxGridCellEditorEvtHandler
1494 // ----------------------------------------------------------------------------
1496 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent
& event
)
1498 switch ( event
.GetKeyCode() )
1502 m_grid
->DisableCellEditControl();
1506 m_grid
->GetEventHandler()->ProcessEvent( event
);
1510 case WXK_NUMPAD_ENTER
:
1511 if (!m_grid
->GetEventHandler()->ProcessEvent(event
))
1512 m_editor
->HandleReturn(event
);
1521 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent
& event
)
1523 switch ( event
.GetKeyCode() )
1528 case WXK_NUMPAD_ENTER
:
1536 // ----------------------------------------------------------------------------
1537 // wxGridCellWorker is an (almost) empty common base class for
1538 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1539 // ----------------------------------------------------------------------------
1541 void wxGridCellWorker::SetParameters(const wxString
& WXUNUSED(params
))
1546 wxGridCellWorker::~wxGridCellWorker()
1550 // ============================================================================
1552 // ============================================================================
1554 // ----------------------------------------------------------------------------
1555 // wxGridCellRenderer
1556 // ----------------------------------------------------------------------------
1558 void wxGridCellRenderer::Draw(wxGrid
& grid
,
1559 wxGridCellAttr
& attr
,
1562 int WXUNUSED(row
), int WXUNUSED(col
),
1565 dc
.SetBackgroundMode( wxSOLID
);
1567 // grey out fields if the grid is disabled
1568 if( grid
.IsEnabled() )
1572 dc
.SetBrush( wxBrush(grid
.GetSelectionBackground(), wxSOLID
) );
1576 dc
.SetBrush( wxBrush(attr
.GetBackgroundColour(), wxSOLID
) );
1581 dc
.SetBrush(wxBrush(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE
), wxSOLID
));
1584 dc
.SetPen( *wxTRANSPARENT_PEN
);
1585 dc
.DrawRectangle(rect
);
1588 // ----------------------------------------------------------------------------
1589 // wxGridCellStringRenderer
1590 // ----------------------------------------------------------------------------
1592 void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid
& grid
,
1593 wxGridCellAttr
& attr
,
1597 dc
.SetBackgroundMode( wxTRANSPARENT
);
1599 // TODO some special colours for attr.IsReadOnly() case?
1601 // different coloured text when the grid is disabled
1602 if( grid
.IsEnabled() )
1606 dc
.SetTextBackground( grid
.GetSelectionBackground() );
1607 dc
.SetTextForeground( grid
.GetSelectionForeground() );
1611 dc
.SetTextBackground( attr
.GetBackgroundColour() );
1612 dc
.SetTextForeground( attr
.GetTextColour() );
1617 dc
.SetTextBackground(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE
));
1618 dc
.SetTextForeground(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_GRAYTEXT
));
1621 dc
.SetFont( attr
.GetFont() );
1624 wxSize
wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr
& attr
,
1626 const wxString
& text
)
1628 wxCoord x
= 0, y
= 0, max_x
= 0;
1629 dc
.SetFont(attr
.GetFont());
1630 wxStringTokenizer
tk(text
, _T('\n'));
1631 while ( tk
.HasMoreTokens() )
1633 dc
.GetTextExtent(tk
.GetNextToken(), &x
, &y
);
1634 max_x
= wxMax(max_x
, x
);
1637 y
*= 1 + text
.Freq(wxT('\n')); // multiply by the number of lines.
1639 return wxSize(max_x
, y
);
1642 wxSize
wxGridCellStringRenderer::GetBestSize(wxGrid
& grid
,
1643 wxGridCellAttr
& attr
,
1647 return DoGetBestSize(attr
, dc
, grid
.GetCellValue(row
, col
));
1650 void wxGridCellStringRenderer::Draw(wxGrid
& grid
,
1651 wxGridCellAttr
& attr
,
1653 const wxRect
& rectCell
,
1657 wxRect rect
= rectCell
;
1660 // erase only this cells background, overflow cells should have been erased
1661 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1664 attr
.GetAlignment(&hAlign
, &vAlign
);
1666 int overflowCols
= 0;
1668 if (attr
.GetOverflow())
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())
1676 int i
, c_cols
, c_rows
;
1677 for (i
= col
+cell_cols
; i
< cols
; i
++)
1679 bool is_empty
= TRUE
;
1680 for (int j
=row
; j
<row
+cell_rows
; j
++)
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
))
1692 rect
.width
+= grid
.GetColSize(i
);
1698 if (rect
.width
>= best_width
) break;
1700 overflowCols
= i
- col
- cell_cols
+ 1;
1701 if (overflowCols
>= cols
) overflowCols
= cols
- 1;
1704 if (overflowCols
> 0) // redraw overflow cells w/ proper hilight
1706 hAlign
= wxALIGN_LEFT
; // if oveflowed then it's left aligned
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
++)
1715 clip
.width
= grid
.GetColSize(i
) - 1;
1716 dc
.DestroyClippingRegion();
1717 dc
.SetClippingRegion(clip
);
1719 SetTextColoursAndFont(grid
, attr
, dc
,
1720 grid
.IsInSelection(row
,i
));
1722 grid
.DrawTextRectangle(dc
, grid
.GetCellValue(row
, col
),
1723 rect
, hAlign
, vAlign
);
1724 clip
.x
+= grid
.GetColSize(i
) - 1;
1730 dc
.DestroyClippingRegion();
1734 // now we only have to draw the text
1735 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
1737 grid
.DrawTextRectangle(dc
, grid
.GetCellValue(row
, col
),
1738 rect
, hAlign
, vAlign
);
1741 // ----------------------------------------------------------------------------
1742 // wxGridCellNumberRenderer
1743 // ----------------------------------------------------------------------------
1745 wxString
wxGridCellNumberRenderer::GetString(wxGrid
& grid
, int row
, int col
)
1747 wxGridTableBase
*table
= grid
.GetTable();
1749 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
1751 text
.Printf(_T("%ld"), table
->GetValueAsLong(row
, col
));
1755 text
= table
->GetValue(row
, col
);
1761 void wxGridCellNumberRenderer::Draw(wxGrid
& grid
,
1762 wxGridCellAttr
& attr
,
1764 const wxRect
& rectCell
,
1768 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1770 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
1772 // draw the text right aligned by default
1774 attr
.GetAlignment(&hAlign
, &vAlign
);
1775 hAlign
= wxALIGN_RIGHT
;
1777 wxRect rect
= rectCell
;
1780 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
1783 wxSize
wxGridCellNumberRenderer::GetBestSize(wxGrid
& grid
,
1784 wxGridCellAttr
& attr
,
1788 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
1791 // ----------------------------------------------------------------------------
1792 // wxGridCellFloatRenderer
1793 // ----------------------------------------------------------------------------
1795 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width
, int precision
)
1798 SetPrecision(precision
);
1801 wxGridCellRenderer
*wxGridCellFloatRenderer::Clone() const
1803 wxGridCellFloatRenderer
*renderer
= new wxGridCellFloatRenderer
;
1804 renderer
->m_width
= m_width
;
1805 renderer
->m_precision
= m_precision
;
1806 renderer
->m_format
= m_format
;
1811 wxString
wxGridCellFloatRenderer::GetString(wxGrid
& grid
, int row
, int col
)
1813 wxGridTableBase
*table
= grid
.GetTable();
1818 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
1820 val
= table
->GetValueAsDouble(row
, col
);
1825 text
= table
->GetValue(row
, col
);
1826 hasDouble
= text
.ToDouble(&val
);
1833 if ( m_width
== -1 )
1835 if ( m_precision
== -1 )
1837 // default width/precision
1838 m_format
= _T("%f");
1842 m_format
.Printf(_T("%%.%df"), m_precision
);
1845 else if ( m_precision
== -1 )
1847 // default precision
1848 m_format
.Printf(_T("%%%d.f"), m_width
);
1852 m_format
.Printf(_T("%%%d.%df"), m_width
, m_precision
);
1856 text
.Printf(m_format
, val
);
1859 //else: text already contains the string
1864 void wxGridCellFloatRenderer::Draw(wxGrid
& grid
,
1865 wxGridCellAttr
& attr
,
1867 const wxRect
& rectCell
,
1871 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1873 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
1875 // draw the text right aligned by default
1877 attr
.GetAlignment(&hAlign
, &vAlign
);
1878 hAlign
= wxALIGN_RIGHT
;
1880 wxRect rect
= rectCell
;
1883 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
1886 wxSize
wxGridCellFloatRenderer::GetBestSize(wxGrid
& grid
,
1887 wxGridCellAttr
& attr
,
1891 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
1894 void wxGridCellFloatRenderer::SetParameters(const wxString
& params
)
1898 // reset to defaults
1904 wxString tmp
= params
.BeforeFirst(_T(','));
1908 if ( tmp
.ToLong(&width
) )
1910 SetWidth((int)width
);
1914 wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params
.c_str());
1918 tmp
= params
.AfterFirst(_T(','));
1922 if ( tmp
.ToLong(&precision
) )
1924 SetPrecision((int)precision
);
1928 wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params
.c_str());
1936 // ----------------------------------------------------------------------------
1937 // wxGridCellBoolRenderer
1938 // ----------------------------------------------------------------------------
1940 wxSize
wxGridCellBoolRenderer::ms_sizeCheckMark
;
1942 // FIXME these checkbox size calculations are really ugly...
1944 // between checkmark and box
1945 static const wxCoord wxGRID_CHECKMARK_MARGIN
= 2;
1947 wxSize
wxGridCellBoolRenderer::GetBestSize(wxGrid
& grid
,
1948 wxGridCellAttr
& WXUNUSED(attr
),
1953 // compute it only once (no locks for MT safeness in GUI thread...)
1954 if ( !ms_sizeCheckMark
.x
)
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
;
1962 // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
1963 #if defined(__WXGTK__) || defined(__WXMOTIF__)
1964 checkSize
-= size
.y
/ 2;
1969 ms_sizeCheckMark
.x
= ms_sizeCheckMark
.y
= checkSize
;
1972 return ms_sizeCheckMark
;
1975 void wxGridCellBoolRenderer::Draw(wxGrid
& grid
,
1976 wxGridCellAttr
& attr
,
1982 wxGridCellRenderer::Draw(grid
, attr
, dc
, rect
, row
, col
, isSelected
);
1984 // draw a check mark in the centre (ignoring alignment - TODO)
1985 wxSize size
= GetBestSize(grid
, attr
, dc
, row
, col
);
1987 // don't draw outside the cell
1988 wxCoord minSize
= wxMin(rect
.width
, rect
.height
);
1989 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
1991 // and even leave (at least) 1 pixel margin
1992 size
.x
= size
.y
= minSize
- 2;
1995 // draw a border around checkmark
1997 attr
.GetAlignment(& hAlign
, &vAlign
);
2000 if (hAlign
== wxALIGN_CENTRE
)
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
;
2007 else if (hAlign
== wxALIGN_LEFT
)
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
;
2014 else if (hAlign
== wxALIGN_RIGHT
)
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
;
2023 if ( grid
.GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
) )
2024 value
= grid
.GetTable()->GetValueAsBool(row
, col
);
2027 wxString
cellval( grid
.GetTable()->GetValue(row
, col
) );
2028 value
= !( !cellval
|| (cellval
== wxT("0")) );
2033 wxRect rectMark
= rectBorder
;
2035 // MSW DrawCheckMark() is weird (and should probably be changed...)
2036 rectMark
.Inflate(-wxGRID_CHECKMARK_MARGIN
/2);
2040 rectMark
.Inflate(-wxGRID_CHECKMARK_MARGIN
);
2043 dc
.SetTextForeground(attr
.GetTextColour());
2044 dc
.DrawCheckMark(rectMark
);
2047 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
2048 dc
.SetPen(wxPen(attr
.GetTextColour(), 1, wxSOLID
));
2049 dc
.DrawRectangle(rectBorder
);
2052 // ----------------------------------------------------------------------------
2054 // ----------------------------------------------------------------------------
2056 void wxGridCellAttr::Init(wxGridCellAttr
*attrDefault
)
2060 m_isReadOnly
= Unset
;
2065 m_attrkind
= wxGridCellAttr::Cell
;
2067 m_sizeRows
= m_sizeCols
= 1;
2068 m_overflow
= UnsetOverflow
;
2070 SetDefAttr(attrDefault
);
2073 wxGridCellAttr
*wxGridCellAttr::Clone() const
2075 wxGridCellAttr
*attr
= new wxGridCellAttr(m_defGridAttr
);
2077 if ( HasTextColour() )
2078 attr
->SetTextColour(GetTextColour());
2079 if ( HasBackgroundColour() )
2080 attr
->SetBackgroundColour(GetBackgroundColour());
2082 attr
->SetFont(GetFont());
2083 if ( HasAlignment() )
2084 attr
->SetAlignment(m_hAlign
, m_vAlign
);
2086 attr
->SetSize( m_sizeRows
, m_sizeCols
);
2090 attr
->SetRenderer(m_renderer
);
2091 m_renderer
->IncRef();
2095 attr
->SetEditor(m_editor
);
2100 attr
->SetReadOnly();
2102 attr
->SetKind( m_attrkind
);
2107 void wxGridCellAttr::MergeWith(wxGridCellAttr
*mergefrom
)
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() ){
2117 mergefrom
->GetAlignment( &hAlign
, &vAlign
);
2118 SetAlignment(hAlign
, vAlign
);
2121 mergefrom
->GetSize( &m_sizeRows
, &m_sizeCols
);
2123 // Directly access member functions as GetRender/Editor don't just return
2124 // m_renderer/m_editor
2126 // Maybe add support for merge of Render and Editor?
2127 if (!HasRenderer() && mergefrom
->HasRenderer() )
2129 m_renderer
= mergefrom
->m_renderer
;
2130 m_renderer
->IncRef();
2132 if ( !HasEditor() && mergefrom
->HasEditor() )
2134 m_editor
= mergefrom
->m_editor
;
2137 if ( !HasReadWriteMode() && mergefrom
->HasReadWriteMode() )
2138 SetReadOnly(mergefrom
->IsReadOnly());
2140 if (!HasOverflowMode() && mergefrom
->HasOverflowMode() )
2141 SetOverflow(mergefrom
->GetOverflow());
2143 SetDefAttr(mergefrom
->m_defGridAttr
);
2146 void wxGridCellAttr::SetSize(int num_rows
, int num_cols
)
2148 // The size of a cell is normally 1,1
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.
2156 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
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"));
2163 m_sizeRows
= num_rows
;
2164 m_sizeCols
= num_cols
;
2167 const wxColour
& wxGridCellAttr::GetTextColour() const
2169 if (HasTextColour())
2173 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2175 return m_defGridAttr
->GetTextColour();
2179 wxFAIL_MSG(wxT("Missing default cell attribute"));
2180 return wxNullColour
;
2185 const wxColour
& wxGridCellAttr::GetBackgroundColour() const
2187 if (HasBackgroundColour())
2189 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2190 return m_defGridAttr
->GetBackgroundColour();
2193 wxFAIL_MSG(wxT("Missing default cell attribute"));
2194 return wxNullColour
;
2199 const wxFont
& wxGridCellAttr::GetFont() const
2203 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2204 return m_defGridAttr
->GetFont();
2207 wxFAIL_MSG(wxT("Missing default cell attribute"));
2213 void wxGridCellAttr::GetAlignment(int *hAlign
, int *vAlign
) const
2217 if ( hAlign
) *hAlign
= m_hAlign
;
2218 if ( vAlign
) *vAlign
= m_vAlign
;
2220 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2221 m_defGridAttr
->GetAlignment(hAlign
, vAlign
);
2224 wxFAIL_MSG(wxT("Missing default cell attribute"));
2228 void wxGridCellAttr::GetSize( int *num_rows
, int *num_cols
) const
2230 if ( num_rows
) *num_rows
= m_sizeRows
;
2231 if ( num_cols
) *num_cols
= m_sizeCols
;
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.
2241 wxGridCellRenderer
* wxGridCellAttr::GetRenderer(wxGrid
* grid
, int row
, int col
) const
2243 wxGridCellRenderer
*renderer
;
2245 if ( m_renderer
&& this != m_defGridAttr
)
2247 // use the cells renderer if it has one
2248 renderer
= m_renderer
;
2251 else // no non default cell renderer
2253 // get default renderer for the data type
2256 // GetDefaultRendererForCell() will do IncRef() for us
2257 renderer
= grid
->GetDefaultRendererForCell(row
, col
);
2266 if (m_defGridAttr
&& this != m_defGridAttr
)
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);
2272 else // default grid attr
2274 // use m_renderer which we had decided not to use initially
2275 renderer
= m_renderer
;
2282 // we're supposed to always find something
2283 wxASSERT_MSG(renderer
, wxT("Missing default cell renderer"));
2288 // same as above, except for s/renderer/editor/g
2289 wxGridCellEditor
* wxGridCellAttr::GetEditor(wxGrid
* grid
, int row
, int col
) const
2291 wxGridCellEditor
*editor
;
2293 if ( m_editor
&& this != m_defGridAttr
)
2295 // use the cells editor if it has one
2299 else // no non default cell editor
2301 // get default editor for the data type
2304 // GetDefaultEditorForCell() will do IncRef() for us
2305 editor
= grid
->GetDefaultEditorForCell(row
, col
);
2314 if ( m_defGridAttr
&& this != m_defGridAttr
)
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);
2320 else // default grid attr
2322 // use m_editor which we had decided not to use initially
2330 // we're supposed to always find something
2331 wxASSERT_MSG(editor
, wxT("Missing default cell editor"));
2336 // ----------------------------------------------------------------------------
2337 // wxGridCellAttrData
2338 // ----------------------------------------------------------------------------
2340 void wxGridCellAttrData::SetAttr(wxGridCellAttr
*attr
, int row
, int col
)
2342 int n
= FindIndex(row
, col
);
2343 if ( n
== wxNOT_FOUND
)
2345 // add the attribute
2346 m_attrs
.Add(new wxGridCellWithAttr(row
, col
, attr
));
2350 // free the old attribute
2351 m_attrs
[(size_t)n
].attr
->DecRef();
2355 // change the attribute
2356 m_attrs
[(size_t)n
].attr
= attr
;
2360 // remove this attribute
2361 m_attrs
.RemoveAt((size_t)n
);
2366 wxGridCellAttr
*wxGridCellAttrData::GetAttr(int row
, int col
) const
2368 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2370 int n
= FindIndex(row
, col
);
2371 if ( n
!= wxNOT_FOUND
)
2373 attr
= m_attrs
[(size_t)n
].attr
;
2380 void wxGridCellAttrData::UpdateAttrRows( size_t pos
, int numRows
)
2382 size_t count
= m_attrs
.GetCount();
2383 for ( size_t n
= 0; n
< count
; n
++ )
2385 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2386 wxCoord row
= coords
.GetRow();
2387 if ((size_t)row
>= pos
)
2391 // If rows inserted, include row counter where necessary
2392 coords
.SetRow(row
+ numRows
);
2394 else if (numRows
< 0)
2396 // If rows deleted ...
2397 if ((size_t)row
>= pos
- numRows
)
2399 // ...either decrement row counter (if row still exists)...
2400 coords
.SetRow(row
+ numRows
);
2404 // ...or remove the attribute
2405 m_attrs
.RemoveAt((size_t)n
);
2413 void wxGridCellAttrData::UpdateAttrCols( size_t pos
, int numCols
)
2415 size_t count
= m_attrs
.GetCount();
2416 for ( size_t n
= 0; n
< count
; n
++ )
2418 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2419 wxCoord col
= coords
.GetCol();
2420 if ( (size_t)col
>= pos
)
2424 // If rows inserted, include row counter where necessary
2425 coords
.SetCol(col
+ numCols
);
2427 else if (numCols
< 0)
2429 // If rows deleted ...
2430 if ((size_t)col
>= pos
- numCols
)
2432 // ...either decrement row counter (if row still exists)...
2433 coords
.SetCol(col
+ numCols
);
2437 // ...or remove the attribute
2438 m_attrs
.RemoveAt((size_t)n
);
2446 int wxGridCellAttrData::FindIndex(int row
, int col
) const
2448 size_t count
= m_attrs
.GetCount();
2449 for ( size_t n
= 0; n
< count
; n
++ )
2451 const wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2452 if ( (coords
.GetRow() == row
) && (coords
.GetCol() == col
) )
2461 // ----------------------------------------------------------------------------
2462 // wxGridRowOrColAttrData
2463 // ----------------------------------------------------------------------------
2465 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2467 size_t count
= m_attrs
.Count();
2468 for ( size_t n
= 0; n
< count
; n
++ )
2470 m_attrs
[n
]->DecRef();
2474 wxGridCellAttr
*wxGridRowOrColAttrData::GetAttr(int rowOrCol
) const
2476 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2478 int n
= m_rowsOrCols
.Index(rowOrCol
);
2479 if ( n
!= wxNOT_FOUND
)
2481 attr
= m_attrs
[(size_t)n
];
2488 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr
*attr
, int rowOrCol
)
2490 int i
= m_rowsOrCols
.Index(rowOrCol
);
2491 if ( i
== wxNOT_FOUND
)
2493 // add the attribute
2494 m_rowsOrCols
.Add(rowOrCol
);
2499 size_t n
= (size_t)i
;
2502 // change the attribute
2503 m_attrs
[n
]->DecRef();
2508 // remove this attribute
2509 m_attrs
[n
]->DecRef();
2510 m_rowsOrCols
.RemoveAt(n
);
2511 m_attrs
.RemoveAt(n
);
2516 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
)
2518 size_t count
= m_attrs
.GetCount();
2519 for ( size_t n
= 0; n
< count
; n
++ )
2521 int & rowOrCol
= m_rowsOrCols
[n
];
2522 if ( (size_t)rowOrCol
>= pos
)
2524 if ( numRowsOrCols
> 0 )
2526 // If rows inserted, include row counter where necessary
2527 rowOrCol
+= numRowsOrCols
;
2529 else if ( numRowsOrCols
< 0)
2531 // If rows deleted, either decrement row counter (if row still exists)
2532 if ((size_t)rowOrCol
>= pos
- numRowsOrCols
)
2533 rowOrCol
+= numRowsOrCols
;
2536 m_rowsOrCols
.RemoveAt((size_t)n
);
2537 m_attrs
.RemoveAt((size_t)n
);
2545 // ----------------------------------------------------------------------------
2546 // wxGridCellAttrProvider
2547 // ----------------------------------------------------------------------------
2549 wxGridCellAttrProvider::wxGridCellAttrProvider()
2551 m_data
= (wxGridCellAttrProviderData
*)NULL
;
2554 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2559 void wxGridCellAttrProvider::InitData()
2561 m_data
= new wxGridCellAttrProviderData
;
2564 wxGridCellAttr
*wxGridCellAttrProvider::GetAttr(int row
, int col
,
2565 wxGridCellAttr::wxAttrKind kind
) const
2567 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
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);
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
;
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
);
2588 if((attrcell
!= attrrow
) && (attrrow
!=attrcol
) && (attrcell
!= attrcol
)){
2589 // Two or move are non NULL
2590 attr
= new wxGridCellAttr
;
2591 attr
->SetKind(wxGridCellAttr::Merged
);
2595 attr
->MergeWith(attrcell
);
2599 attr
->MergeWith(attrcol
);
2603 attr
->MergeWith(attrrow
);
2606 //store merge attr if cache implemented
2608 //m_data->m_mergeAttr.SetAttr(attr, row, col);
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
;
2619 case (wxGridCellAttr::Cell
):
2620 attr
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2622 case (wxGridCellAttr::Col
):
2623 attr
= m_data
->m_colAttrs
.GetAttr(col
);
2625 case (wxGridCellAttr::Row
):
2626 attr
= m_data
->m_rowAttrs
.GetAttr(row
);
2630 // (wxGridCellAttr::Default):
2631 // (wxGridCellAttr::Merged):
2638 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr
*attr
,
2644 m_data
->m_cellAttrs
.SetAttr(attr
, row
, col
);
2647 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2652 m_data
->m_rowAttrs
.SetAttr(attr
, row
);
2655 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr
*attr
, int col
)
2660 m_data
->m_colAttrs
.SetAttr(attr
, col
);
2663 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos
, int numRows
)
2667 m_data
->m_cellAttrs
.UpdateAttrRows( pos
, numRows
);
2669 m_data
->m_rowAttrs
.UpdateAttrRowsOrCols( pos
, numRows
);
2673 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos
, int numCols
)
2677 m_data
->m_cellAttrs
.UpdateAttrCols( pos
, numCols
);
2679 m_data
->m_colAttrs
.UpdateAttrRowsOrCols( pos
, numCols
);
2683 // ----------------------------------------------------------------------------
2684 // wxGridTypeRegistry
2685 // ----------------------------------------------------------------------------
2687 wxGridTypeRegistry::~wxGridTypeRegistry()
2689 size_t count
= m_typeinfo
.Count();
2690 for ( size_t i
= 0; i
< count
; i
++ )
2691 delete m_typeinfo
[i
];
2695 void wxGridTypeRegistry::RegisterDataType(const wxString
& typeName
,
2696 wxGridCellRenderer
* renderer
,
2697 wxGridCellEditor
* editor
)
2699 wxGridDataTypeInfo
* info
= new wxGridDataTypeInfo(typeName
, renderer
, editor
);
2701 // is it already registered?
2702 int loc
= FindRegisteredDataType(typeName
);
2703 if ( loc
!= wxNOT_FOUND
)
2705 delete m_typeinfo
[loc
];
2706 m_typeinfo
[loc
] = info
;
2710 m_typeinfo
.Add(info
);
2714 int wxGridTypeRegistry::FindRegisteredDataType(const wxString
& typeName
)
2716 size_t count
= m_typeinfo
.GetCount();
2717 for ( size_t i
= 0; i
< count
; i
++ )
2719 if ( typeName
== m_typeinfo
[i
]->m_typeName
)
2728 int wxGridTypeRegistry::FindDataType(const wxString
& typeName
)
2730 int index
= FindRegisteredDataType(typeName
);
2731 if ( index
== wxNOT_FOUND
)
2733 // check whether this is one of the standard ones, in which case
2734 // register it "on the fly"
2736 if ( typeName
== wxGRID_VALUE_STRING
)
2738 RegisterDataType(wxGRID_VALUE_STRING
,
2739 new wxGridCellStringRenderer
,
2740 new wxGridCellTextEditor
);
2742 #endif // wxUSE_TEXTCTRL
2744 if ( typeName
== wxGRID_VALUE_BOOL
)
2746 RegisterDataType(wxGRID_VALUE_BOOL
,
2747 new wxGridCellBoolRenderer
,
2748 new wxGridCellBoolEditor
);
2750 #endif // wxUSE_CHECKBOX
2752 if ( typeName
== wxGRID_VALUE_NUMBER
)
2754 RegisterDataType(wxGRID_VALUE_NUMBER
,
2755 new wxGridCellNumberRenderer
,
2756 new wxGridCellNumberEditor
);
2758 else if ( typeName
== wxGRID_VALUE_FLOAT
)
2760 RegisterDataType(wxGRID_VALUE_FLOAT
,
2761 new wxGridCellFloatRenderer
,
2762 new wxGridCellFloatEditor
);
2764 #endif // wxUSE_TEXTCTRL
2766 if ( typeName
== wxGRID_VALUE_CHOICE
)
2768 RegisterDataType(wxGRID_VALUE_CHOICE
,
2769 new wxGridCellStringRenderer
,
2770 new wxGridCellChoiceEditor
);
2772 #endif // wxUSE_COMBOBOX
2777 // we get here only if just added the entry for this type, so return
2779 index
= m_typeinfo
.GetCount() - 1;
2785 int wxGridTypeRegistry::FindOrCloneDataType(const wxString
& typeName
)
2787 int index
= FindDataType(typeName
);
2788 if ( index
== wxNOT_FOUND
)
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
)
2798 wxGridCellRenderer
*renderer
= GetRenderer(index
);
2799 wxGridCellRenderer
*rendererOld
= renderer
;
2800 renderer
= renderer
->Clone();
2801 rendererOld
->DecRef();
2803 wxGridCellEditor
*editor
= GetEditor(index
);
2804 wxGridCellEditor
*editorOld
= editor
;
2805 editor
= editor
->Clone();
2806 editorOld
->DecRef();
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
);
2813 // register the new typename
2814 RegisterDataType(typeName
, renderer
, editor
);
2816 // we just registered it, it's the last one
2817 index
= m_typeinfo
.GetCount() - 1;
2823 wxGridCellRenderer
* wxGridTypeRegistry::GetRenderer(int index
)
2825 wxGridCellRenderer
* renderer
= m_typeinfo
[index
]->m_renderer
;
2831 wxGridCellEditor
* wxGridTypeRegistry::GetEditor(int index
)
2833 wxGridCellEditor
* editor
= m_typeinfo
[index
]->m_editor
;
2839 // ----------------------------------------------------------------------------
2841 // ----------------------------------------------------------------------------
2843 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase
, wxObject
)
2846 wxGridTableBase::wxGridTableBase()
2848 m_view
= (wxGrid
*) NULL
;
2849 m_attrProvider
= (wxGridCellAttrProvider
*) NULL
;
2852 wxGridTableBase::~wxGridTableBase()
2854 delete m_attrProvider
;
2857 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider
*attrProvider
)
2859 delete m_attrProvider
;
2860 m_attrProvider
= attrProvider
;
2863 bool wxGridTableBase::CanHaveAttributes()
2865 if ( ! GetAttrProvider() )
2867 // use the default attr provider by default
2868 SetAttrProvider(new wxGridCellAttrProvider
);
2873 wxGridCellAttr
*wxGridTableBase::GetAttr(int row
, int col
, wxGridCellAttr::wxAttrKind kind
)
2875 if ( m_attrProvider
)
2876 return m_attrProvider
->GetAttr(row
, col
, kind
);
2878 return (wxGridCellAttr
*)NULL
;
2881 void wxGridTableBase::SetAttr(wxGridCellAttr
* attr
, int row
, int col
)
2883 if ( m_attrProvider
)
2885 attr
->SetKind(wxGridCellAttr::Cell
);
2886 m_attrProvider
->SetAttr(attr
, row
, col
);
2890 // as we take ownership of the pointer and don't store it, we must
2896 void wxGridTableBase::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2898 if ( m_attrProvider
)
2900 attr
->SetKind(wxGridCellAttr::Row
);
2901 m_attrProvider
->SetRowAttr(attr
, row
);
2905 // as we take ownership of the pointer and don't store it, we must
2911 void wxGridTableBase::SetColAttr(wxGridCellAttr
*attr
, int col
)
2913 if ( m_attrProvider
)
2915 attr
->SetKind(wxGridCellAttr::Col
);
2916 m_attrProvider
->SetColAttr(attr
, col
);
2920 // as we take ownership of the pointer and don't store it, we must
2926 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos
),
2927 size_t WXUNUSED(numRows
) )
2929 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2934 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows
) )
2936 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2941 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos
),
2942 size_t WXUNUSED(numRows
) )
2944 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2949 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos
),
2950 size_t WXUNUSED(numCols
) )
2952 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2957 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols
) )
2959 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
2964 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos
),
2965 size_t WXUNUSED(numCols
) )
2967 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
2973 wxString
wxGridTableBase::GetRowLabelValue( int row
)
2976 s
<< row
+ 1; // RD: Starting the rows at zero confuses users, no matter
2977 // how much it makes sense to us geeks.
2981 wxString
wxGridTableBase::GetColLabelValue( int col
)
2983 // default col labels are:
2984 // cols 0 to 25 : A-Z
2985 // cols 26 to 675 : AA-ZZ
2990 for ( n
= 1; ; n
++ )
2992 s
+= (_T('A') + (wxChar
)( col%26
));
2994 if ( col
< 0 ) break;
2997 // reverse the string...
2999 for ( i
= 0; i
< n
; i
++ )
3008 wxString
wxGridTableBase::GetTypeName( int WXUNUSED(row
), int WXUNUSED(col
) )
3010 return wxGRID_VALUE_STRING
;
3013 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row
), int WXUNUSED(col
),
3014 const wxString
& typeName
)
3016 return typeName
== wxGRID_VALUE_STRING
;
3019 bool wxGridTableBase::CanSetValueAs( int row
, int col
, const wxString
& typeName
)
3021 return CanGetValueAs(row
, col
, typeName
);
3024 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
) )
3029 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
) )
3034 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
) )
3039 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
),
3040 long WXUNUSED(value
) )
3044 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
),
3045 double WXUNUSED(value
) )
3049 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
),
3050 bool WXUNUSED(value
) )
3055 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3056 const wxString
& WXUNUSED(typeName
) )
3061 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3062 const wxString
& WXUNUSED(typeName
),
3063 void* WXUNUSED(value
) )
3067 //////////////////////////////////////////////////////////////////////
3069 // Message class for the grid table to send requests and notifications
3073 wxGridTableMessage::wxGridTableMessage()
3075 m_table
= (wxGridTableBase
*) NULL
;
3081 wxGridTableMessage::wxGridTableMessage( wxGridTableBase
*table
, int id
,
3082 int commandInt1
, int commandInt2
)
3086 m_comInt1
= commandInt1
;
3087 m_comInt2
= commandInt2
;
3092 //////////////////////////////////////////////////////////////////////
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.
3098 WX_DEFINE_OBJARRAY(wxGridStringArray
)
3100 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable
, wxGridTableBase
)
3102 wxGridStringTable::wxGridStringTable()
3107 wxGridStringTable::wxGridStringTable( int numRows
, int numCols
)
3110 m_data
.Alloc( numRows
);
3113 sa
.Alloc( numCols
);
3114 sa
.Add( wxEmptyString
, numCols
);
3116 m_data
.Add( sa
, numRows
);
3119 wxGridStringTable::~wxGridStringTable()
3123 int wxGridStringTable::GetNumberRows()
3125 return m_data
.GetCount();
3128 int wxGridStringTable::GetNumberCols()
3130 if ( m_data
.GetCount() > 0 )
3131 return m_data
[0].GetCount();
3136 wxString
wxGridStringTable::GetValue( int row
, int col
)
3138 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3139 _T("invalid row or column index in wxGridStringTable") );
3141 return m_data
[row
][col
];
3144 void wxGridStringTable::SetValue( int row
, int col
, const wxString
& value
)
3146 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3147 _T("invalid row or column index in wxGridStringTable") );
3149 m_data
[row
][col
] = value
;
3152 bool wxGridStringTable::IsEmptyCell( int row
, int col
)
3154 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3155 _T("invalid row or column index in wxGridStringTable") );
3157 return (m_data
[row
][col
] == wxEmptyString
);
3160 void wxGridStringTable::Clear()
3163 int numRows
, numCols
;
3165 numRows
= m_data
.GetCount();
3168 numCols
= m_data
[0].GetCount();
3170 for ( row
= 0; row
< numRows
; row
++ )
3172 for ( col
= 0; col
< numCols
; col
++ )
3174 m_data
[row
][col
] = wxEmptyString
;
3181 bool wxGridStringTable::InsertRows( size_t pos
, size_t numRows
)
3183 size_t curNumRows
= m_data
.GetCount();
3184 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3185 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3187 if ( pos
>= curNumRows
)
3189 return AppendRows( numRows
);
3193 sa
.Alloc( curNumCols
);
3194 sa
.Add( wxEmptyString
, curNumCols
);
3195 m_data
.Insert( sa
, pos
, numRows
);
3198 wxGridTableMessage
msg( this,
3199 wxGRIDTABLE_NOTIFY_ROWS_INSERTED
,
3203 GetView()->ProcessTableMessage( msg
);
3209 bool wxGridStringTable::AppendRows( size_t numRows
)
3211 size_t curNumRows
= m_data
.GetCount();
3212 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3213 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3216 if ( curNumCols
> 0 )
3218 sa
.Alloc( curNumCols
);
3219 sa
.Add( wxEmptyString
, curNumCols
);
3222 m_data
.Add( sa
, numRows
);
3226 wxGridTableMessage
msg( this,
3227 wxGRIDTABLE_NOTIFY_ROWS_APPENDED
,
3230 GetView()->ProcessTableMessage( msg
);
3236 bool wxGridStringTable::DeleteRows( size_t pos
, size_t numRows
)
3238 size_t curNumRows
= m_data
.GetCount();
3240 if ( pos
>= curNumRows
)
3242 wxFAIL_MSG( wxString::Format
3244 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
3246 (unsigned long)numRows
,
3247 (unsigned long)curNumRows
3253 if ( numRows
> curNumRows
- pos
)
3255 numRows
= curNumRows
- pos
;
3258 if ( numRows
>= curNumRows
)
3264 m_data
.RemoveAt( pos
, numRows
);
3268 wxGridTableMessage
msg( this,
3269 wxGRIDTABLE_NOTIFY_ROWS_DELETED
,
3273 GetView()->ProcessTableMessage( msg
);
3279 bool wxGridStringTable::InsertCols( size_t pos
, size_t numCols
)
3283 size_t curNumRows
= m_data
.GetCount();
3284 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3285 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3287 if ( pos
>= curNumCols
)
3289 return AppendCols( numCols
);
3292 for ( row
= 0; row
< curNumRows
; row
++ )
3294 for ( col
= pos
; col
< pos
+ numCols
; col
++ )
3296 m_data
[row
].Insert( wxEmptyString
, col
);
3301 wxGridTableMessage
msg( this,
3302 wxGRIDTABLE_NOTIFY_COLS_INSERTED
,
3306 GetView()->ProcessTableMessage( msg
);
3312 bool wxGridStringTable::AppendCols( size_t numCols
)
3316 size_t curNumRows
= m_data
.GetCount();
3320 // TODO: something better than this ?
3322 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3327 for ( row
= 0; row
< curNumRows
; row
++ )
3329 m_data
[row
].Add( wxEmptyString
, numCols
);
3334 wxGridTableMessage
msg( this,
3335 wxGRIDTABLE_NOTIFY_COLS_APPENDED
,
3338 GetView()->ProcessTableMessage( msg
);
3344 bool wxGridStringTable::DeleteCols( size_t pos
, size_t numCols
)
3348 size_t curNumRows
= m_data
.GetCount();
3349 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3350 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3352 if ( pos
>= curNumCols
)
3354 wxFAIL_MSG( wxString::Format
3356 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
3358 (unsigned long)numCols
,
3359 (unsigned long)curNumCols
3364 if ( numCols
> curNumCols
- pos
)
3366 numCols
= curNumCols
- pos
;
3369 for ( row
= 0; row
< curNumRows
; row
++ )
3371 if ( numCols
>= curNumCols
)
3373 m_data
[row
].Clear();
3377 m_data
[row
].RemoveAt( pos
, numCols
);
3382 wxGridTableMessage
msg( this,
3383 wxGRIDTABLE_NOTIFY_COLS_DELETED
,
3387 GetView()->ProcessTableMessage( msg
);
3393 wxString
wxGridStringTable::GetRowLabelValue( int row
)
3395 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3397 // using default label
3399 return wxGridTableBase::GetRowLabelValue( row
);
3403 return m_rowLabels
[ row
];
3407 wxString
wxGridStringTable::GetColLabelValue( int col
)
3409 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3411 // using default label
3413 return wxGridTableBase::GetColLabelValue( col
);
3417 return m_colLabels
[ col
];
3421 void wxGridStringTable::SetRowLabelValue( int row
, const wxString
& value
)
3423 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3425 int n
= m_rowLabels
.GetCount();
3427 for ( i
= n
; i
<= row
; i
++ )
3429 m_rowLabels
.Add( wxGridTableBase::GetRowLabelValue(i
) );
3433 m_rowLabels
[row
] = value
;
3436 void wxGridStringTable::SetColLabelValue( int col
, const wxString
& value
)
3438 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3440 int n
= m_colLabels
.GetCount();
3442 for ( i
= n
; i
<= col
; i
++ )
3444 m_colLabels
.Add( wxGridTableBase::GetColLabelValue(i
) );
3448 m_colLabels
[col
] = value
;
3453 //////////////////////////////////////////////////////////////////////
3454 //////////////////////////////////////////////////////////////////////
3456 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow
, wxWindow
)
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
)
3466 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid
*parent
,
3468 const wxPoint
&pos
, const wxSize
&size
)
3469 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
|wxBORDER_NONE
)
3474 void wxGridRowLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
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
3482 // m_owner->PrepareDC( dc );
3485 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3486 dc
.SetDeviceOrigin( 0, -y
);
3488 wxArrayInt rows
= m_owner
->CalcRowLabelsExposed( GetUpdateRegion() );
3489 m_owner
->DrawRowLabels( dc
, rows
);
3493 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3495 m_owner
->ProcessRowLabelMouseEvent( event
);
3499 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3501 m_owner
->GetEventHandler()->ProcessEvent(event
);
3505 // This seems to be required for wxMotif otherwise the mouse
3506 // cursor must be in the cell edit control to get key events
3508 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3510 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3513 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3515 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3520 //////////////////////////////////////////////////////////////////////
3522 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow
, wxWindow
)
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
)
3532 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid
*parent
,
3534 const wxPoint
&pos
, const wxSize
&size
)
3535 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
|wxBORDER_NONE
)
3540 void wxGridColLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
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
3548 // m_owner->PrepareDC( dc );
3551 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3552 dc
.SetDeviceOrigin( -x
, 0 );
3554 wxArrayInt cols
= m_owner
->CalcColLabelsExposed( GetUpdateRegion() );
3555 m_owner
->DrawColLabels( dc
, cols
);
3559 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3561 m_owner
->ProcessColLabelMouseEvent( event
);
3564 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3566 m_owner
->GetEventHandler()->ProcessEvent(event
);
3570 // This seems to be required for wxMotif otherwise the mouse
3571 // cursor must be in the cell edit control to get key events
3573 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3575 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3578 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3580 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3585 //////////////////////////////////////////////////////////////////////
3587 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow
, wxWindow
)
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
)
3597 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid
*parent
,
3599 const wxPoint
&pos
, const wxSize
&size
)
3600 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
|wxBORDER_NONE
)
3605 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3609 int client_height
= 0;
3610 int client_width
= 0;
3611 GetClientSize( &client_width
, &client_height
);
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
);
3619 dc
.SetPen( *wxWHITE_PEN
);
3620 dc
.DrawLine( 1, 1, client_width
-1, 1 );
3621 dc
.DrawLine( 1, 1, 1, client_height
-1 );
3625 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3627 m_owner
->ProcessCornerLabelMouseEvent( event
);
3631 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3633 m_owner
->GetEventHandler()->ProcessEvent(event
);
3636 // This seems to be required for wxMotif otherwise the mouse
3637 // cursor must be in the cell edit control to get key events
3639 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3641 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3644 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3646 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3651 //////////////////////////////////////////////////////////////////////
3653 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow
, wxWindow
)
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
)
3664 wxGridWindow::wxGridWindow( wxGrid
*parent
,
3665 wxGridRowLabelWindow
*rowLblWin
,
3666 wxGridColLabelWindow
*colLblWin
,
3669 const wxSize
&size
)
3670 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
| wxBORDER_NONE
| wxCLIP_CHILDREN
,
3671 wxT("grid window") )
3675 m_rowLabelWin
= rowLblWin
;
3676 m_colLabelWin
= colLblWin
;
3677 SetBackgroundColour(_T("WHITE"));
3681 wxGridWindow::~wxGridWindow()
3686 void wxGridWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
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
);
3696 m_owner
->DrawGridSpace( dc
);
3697 m_owner
->DrawHighlight( dc
, DirtyCells
);
3701 void wxGridWindow::ScrollWindow( int dx
, int dy
, const wxRect
*rect
)
3703 wxWindow::ScrollWindow( dx
, dy
, rect
);
3704 m_rowLabelWin
->ScrollWindow( 0, dy
, rect
);
3705 m_colLabelWin
->ScrollWindow( dx
, 0, rect
);
3709 void wxGridWindow::OnMouseEvent( wxMouseEvent
& event
)
3711 m_owner
->ProcessGridCellMouseEvent( event
);
3714 void wxGridWindow::OnMouseWheel( wxMouseEvent
& event
)
3716 m_owner
->GetEventHandler()->ProcessEvent(event
);
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
3722 void wxGridWindow::OnKeyDown( wxKeyEvent
& event
)
3724 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3727 void wxGridWindow::OnKeyUp( wxKeyEvent
& event
)
3729 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3732 void wxGridWindow::OnEraseBackground( wxEraseEvent
& WXUNUSED(event
) )
3737 //////////////////////////////////////////////////////////////////////
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!
3744 // Internal helper macros for simpler use of that function
3746 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
3747 const wxArrayInt
& BorderArray
, int nMax
,
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 /////////////////////////////////////////////////////////////////////
3758 IMPLEMENT_DYNAMIC_CLASS( wxGrid
, wxScrolledWindow
)
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
)
3768 wxGrid::wxGrid( wxWindow
*parent
,
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
)
3784 // Must do this or ~wxScrollHelper will pop the wrong event handler
3785 SetTargetWindow(this);
3787 wxSafeDecRef(m_defaultCellAttr
);
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);
3800 delete m_typeRegistry
;
3806 // ----- internal init and update functions
3809 void wxGrid::Create()
3811 m_created
= FALSE
; // set to TRUE by CreateGrid
3813 m_table
= (wxGridTableBase
*) NULL
;
3816 m_cellEditCtrlEnabled
= FALSE
;
3818 m_defaultCellAttr
= new wxGridCellAttr();
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
);
3835 m_currentCellCoords
= wxGridNoCellCoords
;
3837 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
3838 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
3840 // create the type registry
3841 m_typeRegistry
= new wxGridTypeRegistry
;
3844 // subwindow components that make up the wxGrid
3845 m_cornerLabelWin
= new wxGridCornerLabelWindow( this,
3850 m_rowLabelWin
= new wxGridRowLabelWindow( this,
3855 m_colLabelWin
= new wxGridColLabelWindow( this,
3860 m_gridWin
= new wxGridWindow( this,
3867 SetTargetWindow( m_gridWin
);
3873 bool wxGrid::CreateGrid( int numRows
, int numCols
,
3874 wxGrid::wxGridSelectionModes selmode
)
3876 wxCHECK_MSG( !m_created
,
3878 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3880 m_numRows
= numRows
;
3881 m_numCols
= numCols
;
3883 m_table
= new wxGridStringTable( m_numRows
, m_numCols
);
3884 m_table
->SetView( this );
3886 m_selection
= new wxGridSelection( this, selmode
);
3895 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode
)
3897 wxCHECK_RET( m_created
,
3898 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3900 m_selection
->SetSelectionMode( selmode
);
3903 wxGrid::wxGridSelectionModes
wxGrid::GetSelectionMode() const
3905 wxCHECK_MSG( m_created
, wxGrid::wxGridSelectCells
,
3906 wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
3908 return m_selection
->GetSelectionMode();
3911 bool wxGrid::SetTable( wxGridTableBase
*table
, bool takeOwnership
,
3912 wxGrid::wxGridSelectionModes selmode
)
3916 // stop all processing
3921 wxGridTableBase
*t
=m_table
;
3934 m_numRows
= table
->GetNumberRows();
3935 m_numCols
= table
->GetNumberCols();
3938 m_table
->SetView( this );
3941 m_selection
= new wxGridSelection( this, selmode
);
3954 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
3955 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
3957 if ( m_rowLabelWin
)
3959 m_labelBackgroundColour
= m_rowLabelWin
->GetBackgroundColour();
3963 m_labelBackgroundColour
= wxColour( _T("WHITE") );
3966 m_labelTextColour
= wxColour( _T("BLACK") );
3969 m_attrCache
.row
= -1;
3970 m_attrCache
.col
= -1;
3971 m_attrCache
.attr
= NULL
;
3973 // TODO: something better than this ?
3975 m_labelFont
= this->GetFont();
3976 m_labelFont
.SetWeight( wxBOLD
);
3978 m_rowLabelHorizAlign
= wxALIGN_CENTRE
;
3979 m_rowLabelVertAlign
= wxALIGN_CENTRE
;
3981 m_colLabelHorizAlign
= wxALIGN_CENTRE
;
3982 m_colLabelVertAlign
= wxALIGN_CENTRE
;
3983 m_colLabelTextOrientation
= wxHORIZONTAL
;
3985 m_defaultColWidth
= WXGRID_DEFAULT_COL_WIDTH
;
3986 m_defaultRowHeight
= m_gridWin
->GetCharHeight();
3988 m_minAcceptableColWidth
= WXGRID_MIN_COL_WIDTH
;
3989 m_minAcceptableRowHeight
= WXGRID_MIN_ROW_HEIGHT
;
3991 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
3992 m_defaultRowHeight
+= 8;
3994 m_defaultRowHeight
+= 4;
3997 m_gridLineColour
= wxColour( 192,192,192 );
3998 m_gridLinesEnabled
= TRUE
;
3999 m_cellHighlightColour
= *wxBLACK
;
4000 m_cellHighlightPenWidth
= 2;
4001 m_cellHighlightROPenWidth
= 1;
4003 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
4004 m_winCapture
= (wxWindow
*)NULL
;
4005 m_canDragRowSize
= TRUE
;
4006 m_canDragColSize
= TRUE
;
4007 m_canDragGridSize
= TRUE
;
4009 m_dragRowOrCol
= -1;
4010 m_isDragging
= FALSE
;
4011 m_startDragPos
= wxDefaultPosition
;
4013 m_waitForSlowClick
= FALSE
;
4015 m_rowResizeCursor
= wxCursor( wxCURSOR_SIZENS
);
4016 m_colResizeCursor
= wxCursor( wxCURSOR_SIZEWE
);
4018 m_currentCellCoords
= wxGridNoCellCoords
;
4020 m_selectingTopLeft
= wxGridNoCellCoords
;
4021 m_selectingBottomRight
= wxGridNoCellCoords
;
4022 m_selectionBackground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
4023 m_selectionForeground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
4025 m_editable
= TRUE
; // default for whole grid
4027 m_inOnKeyDown
= FALSE
;
4034 // ----------------------------------------------------------------------------
4035 // the idea is to call these functions only when necessary because they create
4036 // quite big arrays which eat memory mostly unnecessary - in particular, if
4037 // default widths/heights are used for all rows/columns, we may not use these
4040 // with some extra code, it should be possible to only store the
4041 // widths/heights different from default ones but this will be done later...
4042 // ----------------------------------------------------------------------------
4044 void wxGrid::InitRowHeights()
4046 m_rowHeights
.Empty();
4047 m_rowBottoms
.Empty();
4049 m_rowHeights
.Alloc( m_numRows
);
4050 m_rowBottoms
.Alloc( m_numRows
);
4054 m_rowHeights
.Add( m_defaultRowHeight
, m_numRows
);
4056 for ( int i
= 0; i
< m_numRows
; i
++ )
4058 rowBottom
+= m_defaultRowHeight
;
4059 m_rowBottoms
.Add( rowBottom
);
4063 void wxGrid::InitColWidths()
4065 m_colWidths
.Empty();
4066 m_colRights
.Empty();
4068 m_colWidths
.Alloc( m_numCols
);
4069 m_colRights
.Alloc( m_numCols
);
4072 m_colWidths
.Add( m_defaultColWidth
, m_numCols
);
4074 for ( int i
= 0; i
< m_numCols
; i
++ )
4076 colRight
+= m_defaultColWidth
;
4077 m_colRights
.Add( colRight
);
4081 int wxGrid::GetColWidth(int col
) const
4083 return m_colWidths
.IsEmpty() ? m_defaultColWidth
: m_colWidths
[col
];
4086 int wxGrid::GetColLeft(int col
) const
4088 return m_colRights
.IsEmpty() ? col
* m_defaultColWidth
4089 : m_colRights
[col
] - m_colWidths
[col
];
4092 int wxGrid::GetColRight(int col
) const
4094 return m_colRights
.IsEmpty() ? (col
+ 1) * m_defaultColWidth
4098 int wxGrid::GetRowHeight(int row
) const
4100 return m_rowHeights
.IsEmpty() ? m_defaultRowHeight
: m_rowHeights
[row
];
4103 int wxGrid::GetRowTop(int row
) const
4105 return m_rowBottoms
.IsEmpty() ? row
* m_defaultRowHeight
4106 : m_rowBottoms
[row
] - m_rowHeights
[row
];
4109 int wxGrid::GetRowBottom(int row
) const
4111 return m_rowBottoms
.IsEmpty() ? (row
+ 1) * m_defaultRowHeight
4112 : m_rowBottoms
[row
];
4115 void wxGrid::CalcDimensions()
4118 GetClientSize( &cw
, &ch
);
4120 if ( m_rowLabelWin
->IsShown() )
4121 cw
-= m_rowLabelWidth
;
4122 if ( m_colLabelWin
->IsShown() )
4123 ch
-= m_colLabelHeight
;
4126 int w
= m_numCols
> 0 ? GetColRight(m_numCols
- 1) + m_extraWidth
+ 1 : 0;
4127 int h
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) + m_extraHeight
+ 1 : 0;
4129 // take into account editor if shown
4130 if( IsCellEditControlShown() )
4133 int r
= m_currentCellCoords
.GetRow();
4134 int c
= m_currentCellCoords
.GetCol();
4135 int x
= GetColLeft(c
);
4136 int y
= GetRowTop(r
);
4138 // how big is the editor
4139 wxGridCellAttr
* attr
= GetCellAttr(r
, c
);
4140 wxGridCellEditor
* editor
= attr
->GetEditor(this, r
, c
);
4141 editor
->GetControl()->GetSize(&w2
, &h2
);
4144 if( w2
> w
) w
= w2
;
4145 if( h2
> h
) h
= h2
;
4150 // preserve (more or less) the previous position
4152 GetViewStart( &x
, &y
);
4154 // maybe we don't need scrollbars at all?
4156 // also adjust the position to be valid for the new scroll rangs
4177 // do set scrollbar parameters
4178 SetScrollbars( GRID_SCROLL_LINE_X
, GRID_SCROLL_LINE_Y
,
4179 GetScrollX(w
), GetScrollY(h
), x
, y
,
4180 GetBatchCount() != 0);
4182 // if our OnSize() hadn't been called (it would if we have scrollbars), we
4183 // still must reposition the children
4188 void wxGrid::CalcWindowSizes()
4191 GetClientSize( &cw
, &ch
);
4193 if ( m_cornerLabelWin
->IsShown() )
4194 m_cornerLabelWin
->SetSize( 0, 0, m_rowLabelWidth
, m_colLabelHeight
);
4196 if ( m_colLabelWin
->IsShown() )
4197 m_colLabelWin
->SetSize( m_rowLabelWidth
, 0, cw
-m_rowLabelWidth
, m_colLabelHeight
);
4199 if ( m_rowLabelWin
->IsShown() )
4200 m_rowLabelWin
->SetSize( 0, m_colLabelHeight
, m_rowLabelWidth
, ch
-m_colLabelHeight
);
4202 if ( m_gridWin
->IsShown() )
4203 m_gridWin
->SetSize( m_rowLabelWidth
, m_colLabelHeight
, cw
-m_rowLabelWidth
, ch
-m_colLabelHeight
);
4207 // this is called when the grid table sends a message to say that it
4208 // has been redimensioned
4210 bool wxGrid::Redimension( wxGridTableMessage
& msg
)
4213 bool result
= FALSE
;
4215 // Clear the attribute cache as the attribute might refer to a different
4216 // cell than stored in the cache after adding/removing rows/columns.
4218 // By the same reasoning, the editor should be dismissed if columns are
4219 // added or removed. And for consistency, it should IMHO always be
4220 // removed, not only if the cell "underneath" it actually changes.
4221 // For now, I intentionally do not save the editor's content as the
4222 // cell it might want to save that stuff to might no longer exist.
4223 HideCellEditControl();
4225 // if we were using the default widths/heights so far, we must change them
4227 if ( m_colWidths
.IsEmpty() )
4232 if ( m_rowHeights
.IsEmpty() )
4238 switch ( msg
.GetId() )
4240 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
4242 size_t pos
= msg
.GetCommandInt();
4243 int numRows
= msg
.GetCommandInt2();
4245 m_numRows
+= numRows
;
4247 if ( !m_rowHeights
.IsEmpty() )
4249 m_rowHeights
.Insert( m_defaultRowHeight
, pos
, numRows
);
4250 m_rowBottoms
.Insert( 0, pos
, numRows
);
4253 if ( pos
> 0 ) bottom
= m_rowBottoms
[pos
-1];
4255 for ( i
= pos
; i
< m_numRows
; i
++ )
4257 bottom
+= m_rowHeights
[i
];
4258 m_rowBottoms
[i
] = bottom
;
4261 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4263 // if we have just inserted cols into an empty grid the current
4264 // cell will be undefined...
4266 SetCurrentCell( 0, 0 );
4270 m_selection
->UpdateRows( pos
, numRows
);
4271 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4273 attrProvider
->UpdateAttrRows( pos
, numRows
);
4275 if ( !GetBatchCount() )
4278 m_rowLabelWin
->Refresh();
4284 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
4286 int numRows
= msg
.GetCommandInt();
4287 int oldNumRows
= m_numRows
;
4288 m_numRows
+= numRows
;
4290 if ( !m_rowHeights
.IsEmpty() )
4292 m_rowHeights
.Add( m_defaultRowHeight
, numRows
);
4293 m_rowBottoms
.Add( 0, numRows
);
4296 if ( oldNumRows
> 0 ) bottom
= m_rowBottoms
[oldNumRows
-1];
4298 for ( i
= oldNumRows
; i
< m_numRows
; i
++ )
4300 bottom
+= m_rowHeights
[i
];
4301 m_rowBottoms
[i
] = bottom
;
4304 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4306 // if we have just inserted cols into an empty grid the current
4307 // cell will be undefined...
4309 SetCurrentCell( 0, 0 );
4311 if ( !GetBatchCount() )
4314 m_rowLabelWin
->Refresh();
4320 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
4322 size_t pos
= msg
.GetCommandInt();
4323 int numRows
= msg
.GetCommandInt2();
4324 m_numRows
-= numRows
;
4326 if ( !m_rowHeights
.IsEmpty() )
4328 m_rowHeights
.RemoveAt( pos
, numRows
);
4329 m_rowBottoms
.RemoveAt( pos
, numRows
);
4332 for ( i
= 0; i
< m_numRows
; i
++ )
4334 h
+= m_rowHeights
[i
];
4335 m_rowBottoms
[i
] = h
;
4340 m_currentCellCoords
= wxGridNoCellCoords
;
4344 if ( m_currentCellCoords
.GetRow() >= m_numRows
)
4345 m_currentCellCoords
.Set( 0, 0 );
4349 m_selection
->UpdateRows( pos
, -((int)numRows
) );
4350 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4352 attrProvider
->UpdateAttrRows( pos
, -((int)numRows
) );
4353 // ifdef'd out following patch from Paul Gammans
4355 // No need to touch column attributes, unless we
4356 // removed _all_ rows, in this case, we remove
4357 // all column attributes.
4358 // I hate to do this here, but the
4359 // needed data is not available inside UpdateAttrRows.
4360 if ( !GetNumberRows() )
4361 attrProvider
->UpdateAttrCols( 0, -GetNumberCols() );
4364 if ( !GetBatchCount() )
4367 m_rowLabelWin
->Refresh();
4373 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
4375 size_t pos
= msg
.GetCommandInt();
4376 int numCols
= msg
.GetCommandInt2();
4377 m_numCols
+= numCols
;
4379 if ( !m_colWidths
.IsEmpty() )
4381 m_colWidths
.Insert( m_defaultColWidth
, pos
, numCols
);
4382 m_colRights
.Insert( 0, pos
, numCols
);
4385 if ( pos
> 0 ) right
= m_colRights
[pos
-1];
4387 for ( i
= pos
; i
< m_numCols
; i
++ )
4389 right
+= m_colWidths
[i
];
4390 m_colRights
[i
] = right
;
4393 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4395 // if we have just inserted cols into an empty grid the current
4396 // cell will be undefined...
4398 SetCurrentCell( 0, 0 );
4402 m_selection
->UpdateCols( pos
, numCols
);
4403 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4405 attrProvider
->UpdateAttrCols( pos
, numCols
);
4406 if ( !GetBatchCount() )
4409 m_colLabelWin
->Refresh();
4416 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
4418 int numCols
= msg
.GetCommandInt();
4419 int oldNumCols
= m_numCols
;
4420 m_numCols
+= numCols
;
4421 if ( !m_colWidths
.IsEmpty() )
4423 m_colWidths
.Add( m_defaultColWidth
, numCols
);
4424 m_colRights
.Add( 0, numCols
);
4427 if ( oldNumCols
> 0 ) right
= m_colRights
[oldNumCols
-1];
4429 for ( i
= oldNumCols
; i
< m_numCols
; i
++ )
4431 right
+= m_colWidths
[i
];
4432 m_colRights
[i
] = right
;
4435 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4437 // if we have just inserted cols into an empty grid the current
4438 // cell will be undefined...
4440 SetCurrentCell( 0, 0 );
4442 if ( !GetBatchCount() )
4445 m_colLabelWin
->Refresh();
4451 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
4453 size_t pos
= msg
.GetCommandInt();
4454 int numCols
= msg
.GetCommandInt2();
4455 m_numCols
-= numCols
;
4457 if ( !m_colWidths
.IsEmpty() )
4459 m_colWidths
.RemoveAt( pos
, numCols
);
4460 m_colRights
.RemoveAt( pos
, numCols
);
4463 for ( i
= 0; i
< m_numCols
; i
++ )
4465 w
+= m_colWidths
[i
];
4471 m_currentCellCoords
= wxGridNoCellCoords
;
4475 if ( m_currentCellCoords
.GetCol() >= m_numCols
)
4476 m_currentCellCoords
.Set( 0, 0 );
4480 m_selection
->UpdateCols( pos
, -((int)numCols
) );
4481 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4483 attrProvider
->UpdateAttrCols( pos
, -((int)numCols
) );
4484 // ifdef'd out following patch from Paul Gammans
4486 // No need to touch row attributes, unless we
4487 // removed _all_ columns, in this case, we remove
4488 // all row attributes.
4489 // I hate to do this here, but the
4490 // needed data is not available inside UpdateAttrCols.
4491 if ( !GetNumberCols() )
4492 attrProvider
->UpdateAttrRows( 0, -GetNumberRows() );
4495 if ( !GetBatchCount() )
4498 m_colLabelWin
->Refresh();
4505 if (result
&& !GetBatchCount() )
4506 m_gridWin
->Refresh();
4511 wxArrayInt
wxGrid::CalcRowLabelsExposed( const wxRegion
& reg
)
4513 wxRegionIterator
iter( reg
);
4516 wxArrayInt rowlabels
;
4523 // TODO: remove this when we can...
4524 // There is a bug in wxMotif that gives garbage update
4525 // rectangles if you jump-scroll a long way by clicking the
4526 // scrollbar with middle button. This is a work-around
4528 #if defined(__WXMOTIF__)
4530 m_gridWin
->GetClientSize( &cw
, &ch
);
4531 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
4532 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
4535 // logical bounds of update region
4538 CalcUnscrolledPosition( 0, r
.GetTop(), &dummy
, &top
);
4539 CalcUnscrolledPosition( 0, r
.GetBottom(), &dummy
, &bottom
);
4541 // find the row labels within these bounds
4544 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
4546 if ( GetRowBottom(row
) < top
)
4549 if ( GetRowTop(row
) > bottom
)
4552 rowlabels
.Add( row
);
4562 wxArrayInt
wxGrid::CalcColLabelsExposed( const wxRegion
& reg
)
4564 wxRegionIterator
iter( reg
);
4567 wxArrayInt colLabels
;
4574 // TODO: remove this when we can...
4575 // There is a bug in wxMotif that gives garbage update
4576 // rectangles if you jump-scroll a long way by clicking the
4577 // scrollbar with middle button. This is a work-around
4579 #if defined(__WXMOTIF__)
4581 m_gridWin
->GetClientSize( &cw
, &ch
);
4582 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
4583 r
.SetRight( wxMin( r
.GetRight(), cw
) );
4586 // logical bounds of update region
4589 CalcUnscrolledPosition( r
.GetLeft(), 0, &left
, &dummy
);
4590 CalcUnscrolledPosition( r
.GetRight(), 0, &right
, &dummy
);
4592 // find the cells within these bounds
4595 for ( col
= internalXToCol(left
); col
< m_numCols
; col
++ )
4597 if ( GetColRight(col
) < left
)
4600 if ( GetColLeft(col
) > right
)
4603 colLabels
.Add( col
);
4612 wxGridCellCoordsArray
wxGrid::CalcCellsExposed( const wxRegion
& reg
)
4614 wxRegionIterator
iter( reg
);
4617 wxGridCellCoordsArray cellsExposed
;
4619 int left
, top
, right
, bottom
;
4624 // TODO: remove this when we can...
4625 // There is a bug in wxMotif that gives garbage update
4626 // rectangles if you jump-scroll a long way by clicking the
4627 // scrollbar with middle button. This is a work-around
4629 #if defined(__WXMOTIF__)
4631 m_gridWin
->GetClientSize( &cw
, &ch
);
4632 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
4633 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
4634 r
.SetRight( wxMin( r
.GetRight(), cw
) );
4635 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
4638 // logical bounds of update region
4640 CalcUnscrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
4641 CalcUnscrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
4643 // find the cells within these bounds
4646 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
4648 if ( GetRowBottom(row
) <= top
)
4651 if ( GetRowTop(row
) > bottom
)
4654 for ( col
= internalXToCol(left
); col
< m_numCols
; col
++ )
4656 if ( GetColRight(col
) <= left
)
4659 if ( GetColLeft(col
) > right
)
4662 cellsExposed
.Add( wxGridCellCoords( row
, col
) );
4669 return cellsExposed
;
4673 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent
& event
)
4676 wxPoint
pos( event
.GetPosition() );
4677 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
4679 if ( event
.Dragging() )
4683 m_isDragging
= TRUE
;
4684 m_rowLabelWin
->CaptureMouse();
4687 if ( event
.LeftIsDown() )
4689 switch( m_cursorMode
)
4691 case WXGRID_CURSOR_RESIZE_ROW
:
4693 int cw
, ch
, left
, dummy
;
4694 m_gridWin
->GetClientSize( &cw
, &ch
);
4695 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
4697 wxClientDC
dc( m_gridWin
);
4700 GetRowTop(m_dragRowOrCol
) +
4701 GetRowMinimalHeight(m_dragRowOrCol
) );
4702 dc
.SetLogicalFunction(wxINVERT
);
4703 if ( m_dragLastPos
>= 0 )
4705 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
4707 dc
.DrawLine( left
, y
, left
+cw
, y
);
4712 case WXGRID_CURSOR_SELECT_ROW
:
4713 if ( (row
= YToRow( y
)) >= 0 )
4717 m_selection
->SelectRow( row
,
4718 event
.ControlDown(),
4725 // default label to suppress warnings about "enumeration value
4726 // 'xxx' not handled in switch
4734 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
4739 if (m_rowLabelWin
->HasCapture()) m_rowLabelWin
->ReleaseMouse();
4740 m_isDragging
= FALSE
;
4743 // ------------ Entering or leaving the window
4745 if ( event
.Entering() || event
.Leaving() )
4747 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
4751 // ------------ Left button pressed
4753 else if ( event
.LeftDown() )
4755 // don't send a label click event for a hit on the
4756 // edge of the row label - this is probably the user
4757 // wanting to resize the row
4759 if ( YToEdgeOfRow(y
) < 0 )
4763 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, row
, -1, event
) )
4765 if ( !event
.ShiftDown() && !event
.ControlDown() )
4769 if ( event
.ShiftDown() )
4771 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
4774 GetNumberCols() - 1,
4775 event
.ControlDown(),
4782 m_selection
->SelectRow( row
,
4783 event
.ControlDown(),
4790 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW
, m_rowLabelWin
);
4795 // starting to drag-resize a row
4797 if ( CanDragRowSize() )
4798 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
);
4803 // ------------ Left double click
4805 else if (event
.LeftDClick() )
4807 int row
= YToEdgeOfRow(y
);
4812 !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, row
, -1, event
) )
4814 // no default action at the moment
4819 // adjust row height depending on label text
4820 AutoSizeRowLabelSize( row
);
4822 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
4828 // ------------ Left button released
4830 else if ( event
.LeftUp() )
4832 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
4834 DoEndDragResizeRow();
4836 // Note: we are ending the event *after* doing
4837 // default processing in this case
4839 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
4842 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
4847 // ------------ Right button down
4849 else if ( event
.RightDown() )
4853 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, row
, -1, event
) )
4855 // no default action at the moment
4860 // ------------ Right double click
4862 else if ( event
.RightDClick() )
4866 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, row
, -1, event
) )
4868 // no default action at the moment
4873 // ------------ No buttons down and mouse moving
4875 else if ( event
.Moving() )
4877 m_dragRowOrCol
= YToEdgeOfRow( y
);
4878 if ( m_dragRowOrCol
>= 0 )
4880 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4882 // don't capture the mouse yet
4883 if ( CanDragRowSize() )
4884 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
, FALSE
);
4887 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
4889 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
, FALSE
);
4895 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent
& event
)
4898 wxPoint
pos( event
.GetPosition() );
4899 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
4901 if ( event
.Dragging() )
4905 m_isDragging
= TRUE
;
4906 m_colLabelWin
->CaptureMouse();
4909 if ( event
.LeftIsDown() )
4911 switch( m_cursorMode
)
4913 case WXGRID_CURSOR_RESIZE_COL
:
4915 int cw
, ch
, dummy
, top
;
4916 m_gridWin
->GetClientSize( &cw
, &ch
);
4917 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
4919 wxClientDC
dc( m_gridWin
);
4922 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
4923 GetColMinimalWidth(m_dragRowOrCol
));
4924 dc
.SetLogicalFunction(wxINVERT
);
4925 if ( m_dragLastPos
>= 0 )
4927 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
4929 dc
.DrawLine( x
, top
, x
, top
+ch
);
4934 case WXGRID_CURSOR_SELECT_COL
:
4935 if ( (col
= XToCol( x
)) >= 0 )
4939 m_selection
->SelectCol( col
,
4940 event
.ControlDown(),
4947 // default label to suppress warnings about "enumeration value
4948 // 'xxx' not handled in switch
4956 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
4961 if (m_colLabelWin
->HasCapture()) m_colLabelWin
->ReleaseMouse();
4962 m_isDragging
= FALSE
;
4965 // ------------ Entering or leaving the window
4967 if ( event
.Entering() || event
.Leaving() )
4969 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
4973 // ------------ Left button pressed
4975 else if ( event
.LeftDown() )
4977 // don't send a label click event for a hit on the
4978 // edge of the col label - this is probably the user
4979 // wanting to resize the col
4981 if ( XToEdgeOfCol(x
) < 0 )
4985 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, col
, event
) )
4987 if ( !event
.ShiftDown() && !event
.ControlDown() )
4991 if ( event
.ShiftDown() )
4993 m_selection
->SelectBlock( 0,
4994 m_currentCellCoords
.GetCol(),
4995 GetNumberRows() - 1, col
,
4996 event
.ControlDown(),
5003 m_selection
->SelectCol( col
,
5004 event
.ControlDown(),
5011 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL
, m_colLabelWin
);
5016 // starting to drag-resize a col
5018 if ( CanDragColSize() )
5019 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
);
5024 // ------------ Left double click
5026 if ( event
.LeftDClick() )
5028 int col
= XToEdgeOfCol(x
);
5033 ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, col
, event
) )
5035 // no default action at the moment
5040 // adjust column width depending on label text
5041 AutoSizeColLabelSize( col
);
5043 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5049 // ------------ Left button released
5051 else if ( event
.LeftUp() )
5053 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
5055 DoEndDragResizeCol();
5057 // Note: we are ending the event *after* doing
5058 // default processing in this case
5060 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
5063 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5068 // ------------ Right button down
5070 else if ( event
.RightDown() )
5074 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, col
, event
) )
5076 // no default action at the moment
5081 // ------------ Right double click
5083 else if ( event
.RightDClick() )
5087 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, col
, event
) )
5089 // no default action at the moment
5094 // ------------ No buttons down and mouse moving
5096 else if ( event
.Moving() )
5098 m_dragRowOrCol
= XToEdgeOfCol( x
);
5099 if ( m_dragRowOrCol
>= 0 )
5101 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5103 // don't capture the cursor yet
5104 if ( CanDragColSize() )
5105 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
, FALSE
);
5108 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5110 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
, FALSE
);
5116 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent
& event
)
5118 if ( event
.LeftDown() )
5120 // indicate corner label by having both row and
5123 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, -1, event
) )
5129 else if ( event
.LeftDClick() )
5131 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, -1, event
);
5134 else if ( event
.RightDown() )
5136 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, -1, event
) )
5138 // no default action at the moment
5142 else if ( event
.RightDClick() )
5144 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, -1, event
) )
5146 // no default action at the moment
5151 void wxGrid::ChangeCursorMode(CursorMode mode
,
5156 static const wxChar
*cursorModes
[] =
5165 wxLogTrace(_T("grid"),
5166 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
5167 win
== m_colLabelWin
? _T("colLabelWin")
5168 : win
? _T("rowLabelWin")
5170 cursorModes
[m_cursorMode
], cursorModes
[mode
]);
5171 #endif // __WXDEBUG__
5173 if ( mode
== m_cursorMode
&&
5174 win
== m_winCapture
&&
5175 captureMouse
== (m_winCapture
!= NULL
))
5180 // by default use the grid itself
5186 if (m_winCapture
->HasCapture()) m_winCapture
->ReleaseMouse();
5187 m_winCapture
= (wxWindow
*)NULL
;
5190 m_cursorMode
= mode
;
5192 switch ( m_cursorMode
)
5194 case WXGRID_CURSOR_RESIZE_ROW
:
5195 win
->SetCursor( m_rowResizeCursor
);
5198 case WXGRID_CURSOR_RESIZE_COL
:
5199 win
->SetCursor( m_colResizeCursor
);
5203 win
->SetCursor( *wxSTANDARD_CURSOR
);
5206 // we need to capture mouse when resizing
5207 bool resize
= m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
||
5208 m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
;
5210 if ( captureMouse
&& resize
)
5212 win
->CaptureMouse();
5217 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent
& event
)
5220 wxPoint
pos( event
.GetPosition() );
5221 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5223 wxGridCellCoords coords
;
5224 XYToCell( x
, y
, coords
);
5226 int cell_rows
, cell_cols
;
5227 GetCellSize( coords
.GetRow(), coords
.GetCol(), &cell_rows
, &cell_cols
);
5228 if ((cell_rows
< 0) || (cell_cols
< 0))
5230 coords
.SetRow(coords
.GetRow() + cell_rows
);
5231 coords
.SetCol(coords
.GetCol() + cell_cols
);
5234 if ( event
.Dragging() )
5236 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
5238 // Don't start doing anything until the mouse has been drug at
5239 // least 3 pixels in any direction...
5242 if (m_startDragPos
== wxDefaultPosition
)
5244 m_startDragPos
= pos
;
5247 if (abs(m_startDragPos
.x
- pos
.x
) < 4 && abs(m_startDragPos
.y
- pos
.y
) < 4)
5251 m_isDragging
= TRUE
;
5252 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5254 // Hide the edit control, so it
5255 // won't interfer with drag-shrinking.
5256 if ( IsCellEditControlShown() )
5258 HideCellEditControl();
5259 SaveEditControlValue();
5262 // Have we captured the mouse yet?
5265 m_winCapture
= m_gridWin
;
5266 m_winCapture
->CaptureMouse();
5269 if ( coords
!= wxGridNoCellCoords
)
5271 if ( event
.ControlDown() )
5273 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
5274 m_selectingKeyboard
= coords
;
5275 HighlightBlock ( m_selectingKeyboard
, coords
);
5279 if ( !IsSelection() )
5281 HighlightBlock( coords
, coords
);
5285 HighlightBlock( m_currentCellCoords
, coords
);
5289 if (! IsVisible(coords
))
5291 MakeCellVisible(coords
);
5292 // TODO: need to introduce a delay or something here. The
5293 // scrolling is way to fast, at least on MSW - also on GTK.
5297 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
5299 int cw
, ch
, left
, dummy
;
5300 m_gridWin
->GetClientSize( &cw
, &ch
);
5301 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
5303 wxClientDC
dc( m_gridWin
);
5305 y
= wxMax( y
, GetRowTop(m_dragRowOrCol
) +
5306 GetRowMinimalHeight(m_dragRowOrCol
) );
5307 dc
.SetLogicalFunction(wxINVERT
);
5308 if ( m_dragLastPos
>= 0 )
5310 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
5312 dc
.DrawLine( left
, y
, left
+cw
, y
);
5315 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
5317 int cw
, ch
, dummy
, top
;
5318 m_gridWin
->GetClientSize( &cw
, &ch
);
5319 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
5321 wxClientDC
dc( m_gridWin
);
5323 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
5324 GetColMinimalWidth(m_dragRowOrCol
) );
5325 dc
.SetLogicalFunction(wxINVERT
);
5326 if ( m_dragLastPos
>= 0 )
5328 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
5330 dc
.DrawLine( x
, top
, x
, top
+ch
);
5337 m_isDragging
= FALSE
;
5338 m_startDragPos
= wxDefaultPosition
;
5340 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
5341 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
5344 if ( event
.Entering() || event
.Leaving() )
5346 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5347 m_gridWin
->SetCursor( *wxSTANDARD_CURSOR
);
5352 // ------------ Left button pressed
5354 if ( event
.LeftDown() && coords
!= wxGridNoCellCoords
)
5356 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK
,
5361 if ( !event
.ControlDown() )
5363 if ( event
.ShiftDown() )
5367 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
5368 m_currentCellCoords
.GetCol(),
5371 event
.ControlDown(),
5377 else if ( XToEdgeOfCol(x
) < 0 &&
5378 YToEdgeOfRow(y
) < 0 )
5380 DisableCellEditControl();
5381 MakeCellVisible( coords
);
5383 if ( event
.ControlDown() )
5387 m_selection
->ToggleCellSelection( coords
.GetRow(),
5389 event
.ControlDown(),
5394 m_selectingTopLeft
= wxGridNoCellCoords
;
5395 m_selectingBottomRight
= wxGridNoCellCoords
;
5396 m_selectingKeyboard
= coords
;
5400 m_waitForSlowClick
= m_currentCellCoords
== coords
&& coords
!= wxGridNoCellCoords
;
5401 SetCurrentCell( coords
);
5404 if ( m_selection
->GetSelectionMode() !=
5405 wxGrid::wxGridSelectCells
)
5407 HighlightBlock( coords
, coords
);
5416 // ------------ Left double click
5418 else if ( event
.LeftDClick() && coords
!= wxGridNoCellCoords
)
5420 DisableCellEditControl();
5422 if ( XToEdgeOfCol(x
) < 0 && YToEdgeOfRow(y
) < 0 )
5424 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK
,
5432 // ------------ Left button released
5434 else if ( event
.LeftUp() )
5436 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5440 if (m_winCapture
->HasCapture()) m_winCapture
->ReleaseMouse();
5441 m_winCapture
= NULL
;
5444 if ( coords
== m_currentCellCoords
&& m_waitForSlowClick
&& CanEnableCellControl())
5447 EnableCellEditControl();
5449 wxGridCellAttr
* attr
= GetCellAttr(coords
);
5450 wxGridCellEditor
*editor
= attr
->GetEditor(this, coords
.GetRow(), coords
.GetCol());
5451 editor
->StartingClick();
5455 m_waitForSlowClick
= FALSE
;
5457 else if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
5458 m_selectingBottomRight
!= wxGridNoCellCoords
)
5462 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
5463 m_selectingTopLeft
.GetCol(),
5464 m_selectingBottomRight
.GetRow(),
5465 m_selectingBottomRight
.GetCol(),
5466 event
.ControlDown(),
5472 m_selectingTopLeft
= wxGridNoCellCoords
;
5473 m_selectingBottomRight
= wxGridNoCellCoords
;
5475 // Show the edit control, if it has been hidden for
5477 ShowCellEditControl();
5480 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
5482 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5483 DoEndDragResizeRow();
5485 // Note: we are ending the event *after* doing
5486 // default processing in this case
5488 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
5490 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
5492 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5493 DoEndDragResizeCol();
5495 // Note: we are ending the event *after* doing
5496 // default processing in this case
5498 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
5505 // ------------ Right button down
5507 else if ( event
.RightDown() && coords
!= wxGridNoCellCoords
)
5509 DisableCellEditControl();
5510 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK
,
5515 // no default action at the moment
5520 // ------------ Right double click
5522 else if ( event
.RightDClick() && coords
!= wxGridNoCellCoords
)
5524 DisableCellEditControl();
5525 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK
,
5530 // no default action at the moment
5534 // ------------ Moving and no button action
5536 else if ( event
.Moving() && !event
.IsButton() )
5538 if( coords
.GetRow() < 0 || coords
.GetCol() < 0 )
5540 // out of grid cell area
5541 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5545 int dragRow
= YToEdgeOfRow( y
);
5546 int dragCol
= XToEdgeOfCol( x
);
5548 // Dragging on the corner of a cell to resize in both
5549 // directions is not implemented yet...
5551 if ( dragRow
>= 0 && dragCol
>= 0 )
5553 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5559 m_dragRowOrCol
= dragRow
;
5561 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5563 if ( CanDragRowSize() && CanDragGridSize() )
5564 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
);
5569 m_dragRowOrCol
= dragCol
;
5577 m_dragRowOrCol
= dragCol
;
5579 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5581 if ( CanDragColSize() && CanDragGridSize() )
5582 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
);
5588 // Neither on a row or col edge
5590 if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5592 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5598 void wxGrid::DoEndDragResizeRow()
5600 if ( m_dragLastPos
>= 0 )
5602 // erase the last line and resize the row
5604 int cw
, ch
, left
, dummy
;
5605 m_gridWin
->GetClientSize( &cw
, &ch
);
5606 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
5608 wxClientDC
dc( m_gridWin
);
5610 dc
.SetLogicalFunction( wxINVERT
);
5611 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
5612 HideCellEditControl();
5613 SaveEditControlValue();
5615 int rowTop
= GetRowTop(m_dragRowOrCol
);
5616 SetRowSize( m_dragRowOrCol
,
5617 wxMax( m_dragLastPos
- rowTop
, m_minAcceptableRowHeight
) );
5619 if ( !GetBatchCount() )
5621 // Only needed to get the correct rect.y:
5622 wxRect
rect ( CellToRect( m_dragRowOrCol
, 0 ) );
5624 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
5625 rect
.width
= m_rowLabelWidth
;
5626 rect
.height
= ch
- rect
.y
;
5627 m_rowLabelWin
->Refresh( TRUE
, &rect
);
5629 // if there is a multicell block, paint all of it
5632 int i
, cell_rows
, cell_cols
, subtract_rows
= 0;
5633 int leftCol
= XToCol(left
);
5634 int rightCol
= internalXToCol(left
+cw
);
5637 for (i
=leftCol
; i
<rightCol
; i
++)
5639 GetCellSize(m_dragRowOrCol
, i
, &cell_rows
, &cell_cols
);
5640 if (cell_rows
< subtract_rows
)
5641 subtract_rows
= cell_rows
;
5643 rect
.y
= GetRowTop(m_dragRowOrCol
+ subtract_rows
);
5644 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
5645 rect
.height
= ch
- rect
.y
;
5648 m_gridWin
->Refresh( FALSE
, &rect
);
5651 ShowCellEditControl();
5656 void wxGrid::DoEndDragResizeCol()
5658 if ( m_dragLastPos
>= 0 )
5660 // erase the last line and resize the col
5662 int cw
, ch
, dummy
, top
;
5663 m_gridWin
->GetClientSize( &cw
, &ch
);
5664 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
5666 wxClientDC
dc( m_gridWin
);
5668 dc
.SetLogicalFunction( wxINVERT
);
5669 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
5670 HideCellEditControl();
5671 SaveEditControlValue();
5673 int colLeft
= GetColLeft(m_dragRowOrCol
);
5674 SetColSize( m_dragRowOrCol
,
5675 wxMax( m_dragLastPos
- colLeft
,
5676 GetColMinimalWidth(m_dragRowOrCol
) ) );
5678 if ( !GetBatchCount() )
5680 // Only needed to get the correct rect.x:
5681 wxRect
rect ( CellToRect( 0, m_dragRowOrCol
) );
5683 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
5684 rect
.width
= cw
- rect
.x
;
5685 rect
.height
= m_colLabelHeight
;
5686 m_colLabelWin
->Refresh( TRUE
, &rect
);
5688 // if there is a multicell block, paint all of it
5691 int i
, cell_rows
, cell_cols
, subtract_cols
= 0;
5692 int topRow
= YToRow(top
);
5693 int bottomRow
= internalYToRow(top
+cw
);
5696 for (i
=topRow
; i
<bottomRow
; i
++)
5698 GetCellSize(i
, m_dragRowOrCol
, &cell_rows
, &cell_cols
);
5699 if (cell_cols
< subtract_cols
)
5700 subtract_cols
= cell_cols
;
5702 rect
.x
= GetColLeft(m_dragRowOrCol
+ subtract_cols
);
5703 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
5704 rect
.width
= cw
- rect
.x
;
5707 m_gridWin
->Refresh( FALSE
, &rect
);
5710 ShowCellEditControl();
5717 // ------ interaction with data model
5719 bool wxGrid::ProcessTableMessage( wxGridTableMessage
& msg
)
5721 switch ( msg
.GetId() )
5723 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES
:
5724 return GetModelValues();
5726 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES
:
5727 return SetModelValues();
5729 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
5730 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
5731 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
5732 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
5733 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
5734 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
5735 return Redimension( msg
);
5744 // The behaviour of this function depends on the grid table class
5745 // Clear() function. For the default wxGridStringTable class the
5746 // behavious is to replace all cell contents with wxEmptyString but
5747 // not to change the number of rows or cols.
5749 void wxGrid::ClearGrid()
5753 if (IsCellEditControlEnabled())
5754 DisableCellEditControl();
5757 if ( !GetBatchCount() ) m_gridWin
->Refresh();
5762 bool wxGrid::InsertRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
5764 // TODO: something with updateLabels flag
5768 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5774 if (IsCellEditControlEnabled())
5775 DisableCellEditControl();
5777 bool done
= m_table
->InsertRows( pos
, numRows
);
5780 // the table will have sent the results of the insert row
5781 // operation to this view object as a grid table message
5787 bool wxGrid::AppendRows( int numRows
, bool WXUNUSED(updateLabels
) )
5789 // TODO: something with updateLabels flag
5793 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5799 bool done
= m_table
&& m_table
->AppendRows( numRows
);
5801 // the table will have sent the results of the append row
5802 // operation to this view object as a grid table message
5808 bool wxGrid::DeleteRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
5810 // TODO: something with updateLabels flag
5814 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5820 if (IsCellEditControlEnabled())
5821 DisableCellEditControl();
5823 bool done
= m_table
->DeleteRows( pos
, numRows
);
5825 // the table will have sent the results of the delete row
5826 // operation to this view object as a grid table message
5832 bool wxGrid::InsertCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
5834 // TODO: something with updateLabels flag
5838 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5844 if (IsCellEditControlEnabled())
5845 DisableCellEditControl();
5847 bool done
= m_table
->InsertCols( pos
, numCols
);
5849 // the table will have sent the results of the insert col
5850 // operation to this view object as a grid table message
5856 bool wxGrid::AppendCols( int numCols
, bool WXUNUSED(updateLabels
) )
5858 // TODO: something with updateLabels flag
5862 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5868 bool done
= m_table
->AppendCols( numCols
);
5870 // the table will have sent the results of the append col
5871 // operation to this view object as a grid table message
5877 bool wxGrid::DeleteCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
5879 // TODO: something with updateLabels flag
5883 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5889 if (IsCellEditControlEnabled())
5890 DisableCellEditControl();
5892 bool done
= m_table
->DeleteCols( pos
, numCols
);
5894 // the table will have sent the results of the delete col
5895 // operation to this view object as a grid table message
5903 // ----- event handlers
5906 // Generate a grid event based on a mouse event and
5907 // return the result of ProcessEvent()
5909 int wxGrid::SendEvent( const wxEventType type
,
5911 wxMouseEvent
& mouseEv
)
5916 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
5918 int rowOrCol
= (row
== -1 ? col
: row
);
5920 wxGridSizeEvent
gridEvt( GetId(),
5924 mouseEv
.GetX() + GetRowLabelSize(),
5925 mouseEv
.GetY() + GetColLabelSize(),
5926 mouseEv
.ControlDown(),
5927 mouseEv
.ShiftDown(),
5929 mouseEv
.MetaDown() );
5931 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5932 vetoed
= !gridEvt
.IsAllowed();
5934 else if ( type
== wxEVT_GRID_RANGE_SELECT
)
5936 // Right now, it should _never_ end up here!
5937 wxGridRangeSelectEvent
gridEvt( GetId(),
5941 m_selectingBottomRight
,
5943 mouseEv
.ControlDown(),
5944 mouseEv
.ShiftDown(),
5946 mouseEv
.MetaDown() );
5948 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5949 vetoed
= !gridEvt
.IsAllowed();
5953 wxGridEvent
gridEvt( GetId(),
5957 mouseEv
.GetX() + GetRowLabelSize(),
5958 mouseEv
.GetY() + GetColLabelSize(),
5960 mouseEv
.ControlDown(),
5961 mouseEv
.ShiftDown(),
5963 mouseEv
.MetaDown() );
5964 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5965 vetoed
= !gridEvt
.IsAllowed();
5968 // A Veto'd event may not be `claimed' so test this first
5969 if (vetoed
) return -1;
5970 return claimed
? 1 : 0;
5974 // Generate a grid event of specified type and return the result
5975 // of ProcessEvent().
5977 int wxGrid::SendEvent( const wxEventType type
,
5983 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
5985 int rowOrCol
= (row
== -1 ? col
: row
);
5987 wxGridSizeEvent
gridEvt( GetId(),
5992 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5993 vetoed
= !gridEvt
.IsAllowed();
5997 wxGridEvent
gridEvt( GetId(),
6002 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6003 vetoed
= !gridEvt
.IsAllowed();
6006 // A Veto'd event may not be `claimed' so test this first
6007 if (vetoed
) return -1;
6008 return claimed
? 1 : 0;
6012 void wxGrid::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
6014 wxPaintDC
dc(this); // needed to prevent zillions of paint events on MSW
6017 void wxGrid::Refresh(bool eraseb
, const wxRect
* rect
)
6019 // Don't do anything if between Begin/EndBatch...
6020 // EndBatch() will do all this on the last nested one anyway.
6021 if (! GetBatchCount())
6023 // Refresh to get correct scrolled position:
6024 wxScrolledWindow::Refresh(eraseb
,rect
);
6028 int rect_x
, rect_y
, rectWidth
, rectHeight
;
6029 int width_label
, width_cell
, height_label
, height_cell
;
6032 //Copy rectangle can get scroll offsets..
6033 rect_x
= rect
->GetX();
6034 rect_y
= rect
->GetY();
6035 rectWidth
= rect
->GetWidth();
6036 rectHeight
= rect
->GetHeight();
6038 width_label
= m_rowLabelWidth
- rect_x
;
6039 if (width_label
> rectWidth
) width_label
= rectWidth
;
6041 height_label
= m_colLabelHeight
- rect_y
;
6042 if (height_label
> rectHeight
) height_label
= rectHeight
;
6044 if (rect_x
> m_rowLabelWidth
)
6046 x
= rect_x
- m_rowLabelWidth
;
6047 width_cell
= rectWidth
;
6052 width_cell
= rectWidth
- (m_rowLabelWidth
- rect_x
);
6055 if (rect_y
> m_colLabelHeight
)
6057 y
= rect_y
- m_colLabelHeight
;
6058 height_cell
= rectHeight
;
6063 height_cell
= rectHeight
- (m_colLabelHeight
- rect_y
);
6066 // Paint corner label part intersecting rect.
6067 if ( width_label
> 0 && height_label
> 0 )
6069 wxRect
anotherrect(rect_x
, rect_y
, width_label
, height_label
);
6070 m_cornerLabelWin
->Refresh(eraseb
, &anotherrect
);
6073 // Paint col labels part intersecting rect.
6074 if ( width_cell
> 0 && height_label
> 0 )
6076 wxRect
anotherrect(x
, rect_y
, width_cell
, height_label
);
6077 m_colLabelWin
->Refresh(eraseb
, &anotherrect
);
6080 // Paint row labels part intersecting rect.
6081 if ( width_label
> 0 && height_cell
> 0 )
6083 wxRect
anotherrect(rect_x
, y
, width_label
, height_cell
);
6084 m_rowLabelWin
->Refresh(eraseb
, &anotherrect
);
6087 // Paint cell area part intersecting rect.
6088 if ( width_cell
> 0 && height_cell
> 0 )
6090 wxRect
anotherrect(x
, y
, width_cell
, height_cell
);
6091 m_gridWin
->Refresh(eraseb
, &anotherrect
);
6096 m_cornerLabelWin
->Refresh(eraseb
, NULL
);
6097 m_colLabelWin
->Refresh(eraseb
, NULL
);
6098 m_rowLabelWin
->Refresh(eraseb
, NULL
);
6099 m_gridWin
->Refresh(eraseb
, NULL
);
6104 void wxGrid::OnSize( wxSizeEvent
& event
)
6106 // position the child windows
6109 // don't call CalcDimensions() from here, the base class handles the size
6115 void wxGrid::OnKeyDown( wxKeyEvent
& event
)
6117 if ( m_inOnKeyDown
)
6119 // shouldn't be here - we are going round in circles...
6121 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
6124 m_inOnKeyDown
= TRUE
;
6126 // propagate the event up and see if it gets processed
6128 wxWindow
*parent
= GetParent();
6129 wxKeyEvent
keyEvt( event
);
6130 keyEvt
.SetEventObject( parent
);
6132 if ( !parent
->GetEventHandler()->ProcessEvent( keyEvt
) )
6135 // try local handlers
6137 switch ( event
.GetKeyCode() )
6140 if ( event
.ControlDown() )
6142 MoveCursorUpBlock( event
.ShiftDown() );
6146 MoveCursorUp( event
.ShiftDown() );
6151 if ( event
.ControlDown() )
6153 MoveCursorDownBlock( event
.ShiftDown() );
6157 MoveCursorDown( event
.ShiftDown() );
6162 if ( event
.ControlDown() )
6164 MoveCursorLeftBlock( event
.ShiftDown() );
6168 MoveCursorLeft( event
.ShiftDown() );
6173 if ( event
.ControlDown() )
6175 MoveCursorRightBlock( event
.ShiftDown() );
6179 MoveCursorRight( event
.ShiftDown() );
6184 case WXK_NUMPAD_ENTER
:
6185 if ( event
.ControlDown() )
6187 event
.Skip(); // to let the edit control have the return
6191 if ( GetGridCursorRow() < GetNumberRows()-1 )
6193 MoveCursorDown( event
.ShiftDown() );
6197 // at the bottom of a column
6198 HideCellEditControl();
6199 SaveEditControlValue();
6209 if (event
.ShiftDown())
6211 if ( GetGridCursorCol() > 0 )
6213 MoveCursorLeft( FALSE
);
6218 HideCellEditControl();
6219 SaveEditControlValue();
6224 if ( GetGridCursorCol() < GetNumberCols()-1 )
6226 MoveCursorRight( FALSE
);
6231 HideCellEditControl();
6232 SaveEditControlValue();
6238 if ( event
.ControlDown() )
6240 MakeCellVisible( 0, 0 );
6241 SetCurrentCell( 0, 0 );
6250 if ( event
.ControlDown() )
6252 MakeCellVisible( m_numRows
-1, m_numCols
-1 );
6253 SetCurrentCell( m_numRows
-1, m_numCols
-1 );
6270 if ( event
.ControlDown() )
6274 m_selection
->ToggleCellSelection( m_currentCellCoords
.GetRow(),
6275 m_currentCellCoords
.GetCol(),
6276 event
.ControlDown(),
6283 if ( !IsEditable() )
6285 MoveCursorRight( FALSE
);
6288 // Otherwise fall through to default
6291 // is it possible to edit the current cell at all?
6292 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
6294 // yes, now check whether the cells editor accepts the key
6295 int row
= m_currentCellCoords
.GetRow();
6296 int col
= m_currentCellCoords
.GetCol();
6297 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6298 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
6300 // <F2> is special and will always start editing, for
6301 // other keys - ask the editor itself
6302 if ( (event
.GetKeyCode() == WXK_F2
&& !event
.HasModifiers())
6303 || editor
->IsAcceptedKey(event
) )
6305 // ensure cell is visble
6306 MakeCellVisible(row
, col
);
6307 EnableCellEditControl();
6309 // a problem can arise if the cell is not completely
6310 // visible (even after calling MakeCellVisible the
6311 // control is not created and calling StartingKey will
6313 if( editor
->IsCreated() && m_cellEditCtrlEnabled
) editor
->StartingKey(event
);
6325 // let others process char events with modifiers or all
6326 // char events for readonly cells
6333 m_inOnKeyDown
= FALSE
;
6336 void wxGrid::OnKeyUp( wxKeyEvent
& event
)
6338 // try local handlers
6340 if ( event
.GetKeyCode() == WXK_SHIFT
)
6342 if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
6343 m_selectingBottomRight
!= wxGridNoCellCoords
)
6347 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
6348 m_selectingTopLeft
.GetCol(),
6349 m_selectingBottomRight
.GetRow(),
6350 m_selectingBottomRight
.GetCol(),
6351 event
.ControlDown(),
6358 m_selectingTopLeft
= wxGridNoCellCoords
;
6359 m_selectingBottomRight
= wxGridNoCellCoords
;
6360 m_selectingKeyboard
= wxGridNoCellCoords
;
6364 void wxGrid::OnEraseBackground(wxEraseEvent
&)
6368 void wxGrid::SetCurrentCell( const wxGridCellCoords
& coords
)
6370 if ( SendEvent( wxEVT_GRID_SELECT_CELL
, coords
.GetRow(), coords
.GetCol() ) )
6372 // the event has been intercepted - do nothing
6376 wxClientDC
dc(m_gridWin
);
6379 if ( m_currentCellCoords
!= wxGridNoCellCoords
)
6381 HideCellEditControl();
6382 DisableCellEditControl();
6384 if ( IsVisible( m_currentCellCoords
, FALSE
) )
6387 r
= BlockToDeviceRect(m_currentCellCoords
, m_currentCellCoords
);
6388 if ( !m_gridLinesEnabled
)
6396 wxGridCellCoordsArray cells
= CalcCellsExposed( r
);
6398 // Otherwise refresh redraws the highlight!
6399 m_currentCellCoords
= coords
;
6401 DrawGridCellArea(dc
,cells
);
6402 DrawAllGridLines( dc
, r
);
6406 m_currentCellCoords
= coords
;
6408 wxGridCellAttr
* attr
= GetCellAttr(coords
);
6409 DrawCellHighlight(dc
, attr
);
6414 void wxGrid::HighlightBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
)
6417 wxGridCellCoords updateTopLeft
, updateBottomRight
;
6421 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
6424 rightCol
= GetNumberCols() - 1;
6426 else if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
6429 bottomRow
= GetNumberRows() - 1;
6433 if ( topRow
> bottomRow
)
6440 if ( leftCol
> rightCol
)
6447 updateTopLeft
= wxGridCellCoords( topRow
, leftCol
);
6448 updateBottomRight
= wxGridCellCoords( bottomRow
, rightCol
);
6450 // First the case that we selected a completely new area
6451 if ( m_selectingTopLeft
== wxGridNoCellCoords
||
6452 m_selectingBottomRight
== wxGridNoCellCoords
)
6455 rect
= BlockToDeviceRect( wxGridCellCoords ( topRow
, leftCol
),
6456 wxGridCellCoords ( bottomRow
, rightCol
) );
6457 m_gridWin
->Refresh( FALSE
, &rect
);
6459 // Now handle changing an existing selection area.
6460 else if ( m_selectingTopLeft
!= updateTopLeft
||
6461 m_selectingBottomRight
!= updateBottomRight
)
6463 // Compute two optimal update rectangles:
6464 // Either one rectangle is a real subset of the
6465 // other, or they are (almost) disjoint!
6467 bool need_refresh
[4];
6471 need_refresh
[3] = FALSE
;
6474 // Store intermediate values
6475 wxCoord oldLeft
= m_selectingTopLeft
.GetCol();
6476 wxCoord oldTop
= m_selectingTopLeft
.GetRow();
6477 wxCoord oldRight
= m_selectingBottomRight
.GetCol();
6478 wxCoord oldBottom
= m_selectingBottomRight
.GetRow();
6480 // Determine the outer/inner coordinates.
6481 if (oldLeft
> leftCol
)
6487 if (oldTop
> topRow
)
6493 if (oldRight
< rightCol
)
6496 oldRight
= rightCol
;
6499 if (oldBottom
< bottomRow
)
6502 oldBottom
= bottomRow
;
6506 // Now, either the stuff marked old is the outer
6507 // rectangle or we don't have a situation where one
6508 // is contained in the other.
6510 if ( oldLeft
< leftCol
)
6512 // Refresh the newly selected or deselected
6513 // area to the left of the old or new selection.
6514 need_refresh
[0] = TRUE
;
6515 rect
[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
6517 wxGridCellCoords ( oldBottom
,
6521 if ( oldTop
< topRow
)
6523 // Refresh the newly selected or deselected
6524 // area above the old or new selection.
6525 need_refresh
[1] = TRUE
;
6526 rect
[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
6528 wxGridCellCoords ( topRow
- 1,
6532 if ( oldRight
> rightCol
)
6534 // Refresh the newly selected or deselected
6535 // area to the right of the old or new selection.
6536 need_refresh
[2] = TRUE
;
6537 rect
[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
6539 wxGridCellCoords ( oldBottom
,
6543 if ( oldBottom
> bottomRow
)
6545 // Refresh the newly selected or deselected
6546 // area below the old or new selection.
6547 need_refresh
[3] = TRUE
;
6548 rect
[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow
+ 1,
6550 wxGridCellCoords ( oldBottom
,
6554 // various Refresh() calls
6555 for (i
= 0; i
< 4; i
++ )
6556 if ( need_refresh
[i
] && rect
[i
] != wxGridNoCellRect
)
6557 m_gridWin
->Refresh( FALSE
, &(rect
[i
]) );
6560 m_selectingTopLeft
= updateTopLeft
;
6561 m_selectingBottomRight
= updateBottomRight
;
6565 // ------ functions to get/send data (see also public functions)
6568 bool wxGrid::GetModelValues()
6570 // Hide the editor, so it won't hide a changed value.
6571 HideCellEditControl();
6575 // all we need to do is repaint the grid
6577 m_gridWin
->Refresh();
6585 bool wxGrid::SetModelValues()
6589 // Disable the editor, so it won't hide a changed value.
6590 // Do we also want to save the current value of the editor first?
6592 DisableCellEditControl();
6596 for ( row
= 0; row
< m_numRows
; row
++ )
6598 for ( col
= 0; col
< m_numCols
; col
++ )
6600 m_table
->SetValue( row
, col
, GetCellValue(row
, col
) );
6612 // Note - this function only draws cells that are in the list of
6613 // exposed cells (usually set from the update region by
6614 // CalcExposedCells)
6616 void wxGrid::DrawGridCellArea( wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
6618 if ( !m_numRows
|| !m_numCols
) return;
6620 int i
, numCells
= cells
.GetCount();
6621 int row
, col
, cell_rows
, cell_cols
;
6622 wxGridCellCoordsArray redrawCells
;
6624 for ( i
= numCells
-1; i
>= 0; i
-- )
6626 row
= cells
[i
].GetRow();
6627 col
= cells
[i
].GetCol();
6628 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
6630 // If this cell is part of a multicell block, find owner for repaint
6631 if ( cell_rows
<= 0 || cell_cols
<= 0 )
6633 wxGridCellCoords
cell(row
+cell_rows
, col
+cell_cols
);
6634 bool marked
= FALSE
;
6635 for ( int j
= 0; j
< numCells
; j
++ )
6637 if ( cell
== cells
[j
] )
6645 int count
= redrawCells
.GetCount();
6646 for (int j
= 0; j
< count
; j
++)
6648 if ( cell
== redrawCells
[j
] )
6654 if (!marked
) redrawCells
.Add( cell
);
6656 continue; // don't bother drawing this cell
6659 // If this cell is empty, find cell to left that might want to overflow
6660 if (m_table
&& m_table
->IsEmptyCell(row
, col
))
6662 for ( int l
= 0; l
< cell_rows
; l
++ )
6664 // find a cell in this row to left alreay marked for repaint
6666 for (int k
= 0; k
< int(redrawCells
.GetCount()); k
++)
6667 if ((redrawCells
[k
].GetCol() < left
) &&
6668 (redrawCells
[k
].GetRow() == row
))
6669 left
=redrawCells
[k
].GetCol();
6671 if (left
== col
) left
= 0; // oh well
6673 for (int j
= col
-1; j
>= left
; j
--)
6675 if (!m_table
->IsEmptyCell(row
+l
, j
))
6677 if (GetCellOverflow(row
+l
, j
))
6679 wxGridCellCoords
cell(row
+l
, j
);
6680 bool marked
= FALSE
;
6682 for (int k
= 0; k
< numCells
; k
++)
6684 if ( cell
== cells
[k
] )
6692 int count
= redrawCells
.GetCount();
6693 for (int k
= 0; k
< count
; k
++)
6695 if ( cell
== redrawCells
[k
] )
6701 if (!marked
) redrawCells
.Add( cell
);
6709 DrawCell( dc
, cells
[i
] );
6712 numCells
= redrawCells
.GetCount();
6714 for ( i
= numCells
- 1; i
>= 0; i
-- )
6716 DrawCell( dc
, redrawCells
[i
] );
6721 void wxGrid::DrawGridSpace( wxDC
& dc
)
6724 m_gridWin
->GetClientSize( &cw
, &ch
);
6727 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6729 int rightCol
= m_numCols
> 0 ? GetColRight(m_numCols
- 1) : 0;
6730 int bottomRow
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0 ;
6732 if ( right
> rightCol
|| bottom
> bottomRow
)
6735 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6737 dc
.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID
) );
6738 dc
.SetPen( *wxTRANSPARENT_PEN
);
6740 if ( right
> rightCol
)
6742 dc
.DrawRectangle( rightCol
, top
, right
- rightCol
, ch
);
6745 if ( bottom
> bottomRow
)
6747 dc
.DrawRectangle( left
, bottomRow
, cw
, bottom
- bottomRow
);
6753 void wxGrid::DrawCell( wxDC
& dc
, const wxGridCellCoords
& coords
)
6755 int row
= coords
.GetRow();
6756 int col
= coords
.GetCol();
6758 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6761 // we draw the cell border ourselves
6762 #if !WXGRID_DRAW_LINES
6763 if ( m_gridLinesEnabled
)
6764 DrawCellBorder( dc
, coords
);
6767 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6769 bool isCurrent
= coords
== m_currentCellCoords
;
6771 wxRect rect
= CellToRect( row
, col
);
6773 // if the editor is shown, we should use it and not the renderer
6774 // Note: However, only if it is really _shown_, i.e. not hidden!
6775 if ( isCurrent
&& IsCellEditControlShown() )
6777 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
6778 editor
->PaintBackground(rect
, attr
);
6783 // but all the rest is drawn by the cell renderer and hence may be
6785 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
6786 renderer
->Draw(*this, *attr
, dc
, rect
, row
, col
, IsInSelection(coords
));
6793 void wxGrid::DrawCellHighlight( wxDC
& dc
, const wxGridCellAttr
*attr
)
6795 int row
= m_currentCellCoords
.GetRow();
6796 int col
= m_currentCellCoords
.GetCol();
6798 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6801 wxRect rect
= CellToRect(row
, col
);
6803 // hmmm... what could we do here to show that the cell is disabled?
6804 // for now, I just draw a thinner border than for the other ones, but
6805 // it doesn't look really good
6807 int penWidth
= attr
->IsReadOnly() ? m_cellHighlightROPenWidth
: m_cellHighlightPenWidth
;
6811 // The center of th drawn line is where the position/width/height of
6812 // the rectangle is actually at, (on wxMSW atr least,) so we will
6813 // reduce the size of the rectangle to compensate for the thickness of
6814 // the line. If this is too strange on non wxMSW platforms then
6815 // please #ifdef this appropriately.
6816 rect
.x
+= penWidth
/2;
6817 rect
.y
+= penWidth
/2;
6818 rect
.width
-= penWidth
-1;
6819 rect
.height
-= penWidth
-1;
6822 // Now draw the rectangle
6823 // use the cellHighlightColour if the cell is inside a selection, this
6824 // will ensure the cell is always visible.
6825 dc
.SetPen(wxPen(IsInSelection(row
,col
)?m_selectionForeground
:m_cellHighlightColour
, penWidth
, wxSOLID
));
6826 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
6827 dc
.DrawRectangle(rect
);
6831 // VZ: my experiments with 3d borders...
6833 // how to properly set colours for arbitrary bg?
6834 wxCoord x1
= rect
.x
,
6836 x2
= rect
.x
+ rect
.width
-1,
6837 y2
= rect
.y
+ rect
.height
-1;
6839 dc
.SetPen(*wxWHITE_PEN
);
6840 dc
.DrawLine(x1
, y1
, x2
, y1
);
6841 dc
.DrawLine(x1
, y1
, x1
, y2
);
6843 dc
.DrawLine(x1
+ 1, y2
- 1, x2
- 1, y2
- 1);
6844 dc
.DrawLine(x2
- 1, y1
+ 1, x2
- 1, y2
);
6846 dc
.SetPen(*wxBLACK_PEN
);
6847 dc
.DrawLine(x1
, y2
, x2
, y2
);
6848 dc
.DrawLine(x2
, y1
, x2
, y2
+1);
6853 void wxGrid::DrawCellBorder( wxDC
& dc
, const wxGridCellCoords
& coords
)
6855 int row
= coords
.GetRow();
6856 int col
= coords
.GetCol();
6857 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6860 dc
.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID
) );
6862 wxRect rect
= CellToRect( row
, col
);
6864 // right hand border
6866 dc
.DrawLine( rect
.x
+ rect
.width
, rect
.y
,
6867 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
+ 1 );
6871 dc
.DrawLine( rect
.x
, rect
.y
+ rect
.height
,
6872 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
6875 void wxGrid::DrawHighlight(wxDC
& dc
,const wxGridCellCoordsArray
& cells
)
6877 // This if block was previously in wxGrid::OnPaint but that doesn't
6878 // seem to get called under wxGTK - MB
6880 if ( m_currentCellCoords
== wxGridNoCellCoords
&&
6881 m_numRows
&& m_numCols
)
6883 m_currentCellCoords
.Set(0, 0);
6886 if ( IsCellEditControlShown() )
6888 // don't show highlight when the edit control is shown
6892 // if the active cell was repainted, repaint its highlight too because it
6893 // might have been damaged by the grid lines
6894 size_t count
= cells
.GetCount();
6895 for ( size_t n
= 0; n
< count
; n
++ )
6897 if ( cells
[n
] == m_currentCellCoords
)
6899 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
6900 DrawCellHighlight(dc
, attr
);
6908 // TODO: remove this ???
6909 // This is used to redraw all grid lines e.g. when the grid line colour
6912 void wxGrid::DrawAllGridLines( wxDC
& dc
, const wxRegion
& WXUNUSED(reg
) )
6914 #if !WXGRID_DRAW_LINES
6918 if ( !m_gridLinesEnabled
||
6920 !m_numCols
) return;
6922 int top
, bottom
, left
, right
;
6924 #if 0 //#ifndef __WXGTK__
6928 m_gridWin
->GetClientSize(&cw
, &ch
);
6930 // virtual coords of visible area
6932 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6933 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6938 reg
.GetBox(x
, y
, w
, h
);
6939 CalcUnscrolledPosition( x
, y
, &left
, &top
);
6940 CalcUnscrolledPosition( x
+ w
, y
+ h
, &right
, &bottom
);
6944 m_gridWin
->GetClientSize(&cw
, &ch
);
6945 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6946 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6949 // avoid drawing grid lines past the last row and col
6951 right
= wxMin( right
, GetColRight(m_numCols
- 1) );
6952 bottom
= wxMin( bottom
, GetRowBottom(m_numRows
- 1) );
6954 // no gridlines inside multicells, clip them out
6955 int leftCol
= internalXToCol(left
);
6956 int topRow
= internalYToRow(top
);
6957 int rightCol
= internalXToCol(right
);
6958 int bottomRow
= internalYToRow(bottom
);
6959 wxRegion
clippedcells(0, 0, cw
, ch
);
6962 int i
, j
, cell_rows
, cell_cols
;
6965 for (j
=topRow
; j
<bottomRow
; j
++)
6967 for (i
=leftCol
; i
<rightCol
; i
++)
6969 GetCellSize( j
, i
, &cell_rows
, &cell_cols
);
6970 if ((cell_rows
> 1) || (cell_cols
> 1))
6972 rect
= CellToRect(j
,i
);
6973 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
6974 clippedcells
.Subtract(rect
);
6976 else if ((cell_rows
< 0) || (cell_cols
< 0))
6978 rect
= CellToRect(j
+cell_rows
, i
+cell_cols
);
6979 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
6980 clippedcells
.Subtract(rect
);
6984 dc
.SetClippingRegion( clippedcells
);
6986 dc
.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID
) );
6988 // horizontal grid lines
6990 // already declared above - int i;
6991 for ( i
= internalYToRow(top
); i
< m_numRows
; i
++ )
6993 int bot
= GetRowBottom(i
) - 1;
7002 dc
.DrawLine( left
, bot
, right
, bot
);
7007 // vertical grid lines
7009 for ( i
= internalXToCol(left
); i
< m_numCols
; i
++ )
7011 int colRight
= GetColRight(i
) - 1;
7012 if ( colRight
> right
)
7017 if ( colRight
>= left
)
7019 dc
.DrawLine( colRight
, top
, colRight
, bottom
);
7022 dc
.DestroyClippingRegion();
7026 void wxGrid::DrawRowLabels( wxDC
& dc
,const wxArrayInt
& rows
)
7028 if ( !m_numRows
) return;
7031 size_t numLabels
= rows
.GetCount();
7033 for ( i
= 0; i
< numLabels
; i
++ )
7035 DrawRowLabel( dc
, rows
[i
] );
7040 void wxGrid::DrawRowLabel( wxDC
& dc
, int row
)
7042 if ( GetRowHeight(row
) <= 0 )
7045 int rowTop
= GetRowTop(row
),
7046 rowBottom
= GetRowBottom(row
) - 1;
7048 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW
),1, wxSOLID
) );
7049 dc
.DrawLine( m_rowLabelWidth
-1, rowTop
,
7050 m_rowLabelWidth
-1, rowBottom
);
7052 dc
.DrawLine( 0, rowTop
, 0, rowBottom
);
7054 dc
.DrawLine( 0, rowBottom
, m_rowLabelWidth
, rowBottom
);
7056 dc
.SetPen( *wxWHITE_PEN
);
7057 dc
.DrawLine( 1, rowTop
, 1, rowBottom
);
7058 dc
.DrawLine( 1, rowTop
, m_rowLabelWidth
-1, rowTop
);
7060 dc
.SetBackgroundMode( wxTRANSPARENT
);
7061 dc
.SetTextForeground( GetLabelTextColour() );
7062 dc
.SetFont( GetLabelFont() );
7065 GetRowLabelAlignment( &hAlign
, &vAlign
);
7069 rect
.SetY( GetRowTop(row
) + 2 );
7070 rect
.SetWidth( m_rowLabelWidth
- 4 );
7071 rect
.SetHeight( GetRowHeight(row
) - 4 );
7072 DrawTextRectangle( dc
, GetRowLabelValue( row
), rect
, hAlign
, vAlign
);
7076 void wxGrid::DrawColLabels( wxDC
& dc
,const wxArrayInt
& cols
)
7078 if ( !m_numCols
) return;
7081 size_t numLabels
= cols
.GetCount();
7083 for ( i
= 0; i
< numLabels
; i
++ )
7085 DrawColLabel( dc
, cols
[i
] );
7090 void wxGrid::DrawColLabel( wxDC
& dc
, int col
)
7092 if ( GetColWidth(col
) <= 0 )
7095 int colLeft
= GetColLeft(col
),
7096 colRight
= GetColRight(col
) - 1;
7098 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW
),1, wxSOLID
) );
7099 dc
.DrawLine( colRight
, 0,
7100 colRight
, m_colLabelHeight
-1 );
7102 dc
.DrawLine( colLeft
, 0, colRight
, 0 );
7104 dc
.DrawLine( colLeft
, m_colLabelHeight
-1,
7105 colRight
+1, m_colLabelHeight
-1 );
7107 dc
.SetPen( *wxWHITE_PEN
);
7108 dc
.DrawLine( colLeft
, 1, colLeft
, m_colLabelHeight
-1 );
7109 dc
.DrawLine( colLeft
, 1, colRight
, 1 );
7111 dc
.SetBackgroundMode( wxTRANSPARENT
);
7112 dc
.SetTextForeground( GetLabelTextColour() );
7113 dc
.SetFont( GetLabelFont() );
7115 int hAlign
, vAlign
, orient
;
7116 GetColLabelAlignment( &hAlign
, &vAlign
);
7117 orient
= GetColLabelTextOrientation();
7120 rect
.SetX( colLeft
+ 2 );
7122 rect
.SetWidth( GetColWidth(col
) - 4 );
7123 rect
.SetHeight( m_colLabelHeight
- 4 );
7124 DrawTextRectangle( dc
, GetColLabelValue( col
), rect
, hAlign
, vAlign
, orient
);
7127 void wxGrid::DrawTextRectangle( wxDC
& dc
,
7128 const wxString
& value
,
7132 int textOrientation
)
7134 wxArrayString lines
;
7136 StringToLines( value
, lines
);
7139 //Forward to new API.
7140 DrawTextRectangle( dc
,
7149 void wxGrid::DrawTextRectangle( wxDC
& dc
,
7150 const wxArrayString
& lines
,
7154 int textOrientation
)
7156 long textWidth
, textHeight
;
7157 long lineWidth
, lineHeight
;
7160 dc
.SetClippingRegion( rect
);
7162 nLines
= lines
.GetCount();
7166 float x
= 0.0, y
= 0.0;
7168 if( textOrientation
== wxHORIZONTAL
)
7169 GetTextBoxSize(dc
, lines
, &textWidth
, &textHeight
);
7171 GetTextBoxSize( dc
, lines
, &textHeight
, &textWidth
);
7175 case wxALIGN_BOTTOM
:
7176 if( textOrientation
== wxHORIZONTAL
)
7177 y
= rect
.y
+ (rect
.height
- textHeight
- 1);
7179 x
= rect
.x
+ rect
.width
- textWidth
;
7182 case wxALIGN_CENTRE
:
7183 if( textOrientation
== wxHORIZONTAL
)
7184 y
= rect
.y
+ ((rect
.height
- textHeight
)/2);
7186 x
= rect
.x
+ ((rect
.width
- textWidth
)/2);
7191 if( textOrientation
== wxHORIZONTAL
)
7198 // Align each line of a multi-line label
7199 for( l
= 0; l
< nLines
; l
++ )
7201 dc
.GetTextExtent(lines
[l
], &lineWidth
, &lineHeight
);
7203 switch( horizAlign
)
7206 if( textOrientation
== wxHORIZONTAL
)
7207 x
= rect
.x
+ (rect
.width
- lineWidth
- 1);
7209 y
= rect
.y
+ lineWidth
+ 1;
7212 case wxALIGN_CENTRE
:
7213 if( textOrientation
== wxHORIZONTAL
)
7214 x
= rect
.x
+ ((rect
.width
- lineWidth
)/2);
7216 y
= rect
.y
+ rect
.height
- ((rect
.height
- lineWidth
)/2);
7221 if( textOrientation
== wxHORIZONTAL
)
7224 y
= rect
.y
+ rect
.height
- 1;
7228 if( textOrientation
== wxHORIZONTAL
)
7230 dc
.DrawText( lines
[l
], (int)x
, (int)y
);
7235 dc
.DrawRotatedText( lines
[l
], (int)x
, (int)y
, 90.0 );
7240 dc
.DestroyClippingRegion();
7244 // Split multi line text up into an array of strings. Any existing
7245 // contents of the string array are preserved.
7247 void wxGrid::StringToLines( const wxString
& value
, wxArrayString
& lines
)
7251 wxString eol
= wxTextFile::GetEOL( wxTextFileType_Unix
);
7252 wxString tVal
= wxTextFile::Translate( value
, wxTextFileType_Unix
);
7254 while ( startPos
< (int)tVal
.Length() )
7256 pos
= tVal
.Mid(startPos
).Find( eol
);
7261 else if ( pos
== 0 )
7263 lines
.Add( wxEmptyString
);
7267 lines
.Add( value
.Mid(startPos
, pos
) );
7271 if ( startPos
< (int)value
.Length() )
7273 lines
.Add( value
.Mid( startPos
) );
7278 void wxGrid::GetTextBoxSize( wxDC
& dc
,
7279 const wxArrayString
& lines
,
7280 long *width
, long *height
)
7287 for ( i
= 0; i
< lines
.GetCount(); i
++ )
7289 dc
.GetTextExtent( lines
[i
], &lineW
, &lineH
);
7290 w
= wxMax( w
, lineW
);
7299 // ------ Batch processing.
7301 void wxGrid::EndBatch()
7303 if ( m_batchCount
> 0 )
7306 if ( !m_batchCount
)
7309 m_rowLabelWin
->Refresh();
7310 m_colLabelWin
->Refresh();
7311 m_cornerLabelWin
->Refresh();
7312 m_gridWin
->Refresh();
7317 // Use this, rather than wxWindow::Refresh(), to force an immediate
7318 // repainting of the grid. Has no effect if you are already inside a
7319 // BeginBatch / EndBatch block.
7321 void wxGrid::ForceRefresh()
7329 // ------ Edit control functions
7333 void wxGrid::EnableEditing( bool edit
)
7335 // TODO: improve this ?
7337 if ( edit
!= m_editable
)
7339 if(!edit
) EnableCellEditControl(edit
);
7345 void wxGrid::EnableCellEditControl( bool enable
)
7350 if ( m_currentCellCoords
== wxGridNoCellCoords
)
7351 SetCurrentCell( 0, 0 );
7353 if ( enable
!= m_cellEditCtrlEnabled
)
7357 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN
) <0)
7360 // this should be checked by the caller!
7361 wxASSERT_MSG( CanEnableCellControl(),
7362 _T("can't enable editing for this cell!") );
7364 // do it before ShowCellEditControl()
7365 m_cellEditCtrlEnabled
= enable
;
7367 ShowCellEditControl();
7371 //FIXME:add veto support
7372 SendEvent( wxEVT_GRID_EDITOR_HIDDEN
);
7374 HideCellEditControl();
7375 SaveEditControlValue();
7377 // do it after HideCellEditControl()
7378 m_cellEditCtrlEnabled
= enable
;
7383 bool wxGrid::IsCurrentCellReadOnly() const
7386 wxGridCellAttr
* attr
= ((wxGrid
*)this)->GetCellAttr(m_currentCellCoords
);
7387 bool readonly
= attr
->IsReadOnly();
7393 bool wxGrid::CanEnableCellControl() const
7395 return m_editable
&& !IsCurrentCellReadOnly();
7398 bool wxGrid::IsCellEditControlEnabled() const
7400 // the cell edit control might be disable for all cells or just for the
7401 // current one if it's read only
7402 return m_cellEditCtrlEnabled
? !IsCurrentCellReadOnly() : FALSE
;
7405 bool wxGrid::IsCellEditControlShown() const
7407 bool isShown
= FALSE
;
7409 if ( m_cellEditCtrlEnabled
)
7411 int row
= m_currentCellCoords
.GetRow();
7412 int col
= m_currentCellCoords
.GetCol();
7413 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7414 wxGridCellEditor
* editor
= attr
->GetEditor((wxGrid
*) this, row
, col
);
7419 if ( editor
->IsCreated() )
7421 isShown
= editor
->GetControl()->IsShown();
7431 void wxGrid::ShowCellEditControl()
7433 if ( IsCellEditControlEnabled() )
7435 if ( !IsVisible( m_currentCellCoords
) )
7437 m_cellEditCtrlEnabled
= FALSE
;
7442 wxRect rect
= CellToRect( m_currentCellCoords
);
7443 int row
= m_currentCellCoords
.GetRow();
7444 int col
= m_currentCellCoords
.GetCol();
7446 // if this is part of a multicell, find owner (topleft)
7447 int cell_rows
, cell_cols
;
7448 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7449 if ( cell_rows
<= 0 || cell_cols
<= 0 )
7453 m_currentCellCoords
.SetRow( row
);
7454 m_currentCellCoords
.SetCol( col
);
7457 // convert to scrolled coords
7459 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7461 // done in PaintBackground()
7463 // erase the highlight and the cell contents because the editor
7464 // might not cover the entire cell
7465 wxClientDC
dc( m_gridWin
);
7467 dc
.SetBrush(*wxLIGHT_GREY_BRUSH
); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
7468 dc
.SetPen(*wxTRANSPARENT_PEN
);
7469 dc
.DrawRectangle(rect
);
7472 // cell is shifted by one pixel
7473 // However, don't allow x or y to become negative
7474 // since the SetSize() method interprets that as
7481 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7482 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
7483 if ( !editor
->IsCreated() )
7485 editor
->Create(m_gridWin
, -1,
7486 new wxGridCellEditorEvtHandler(this, editor
));
7488 wxGridEditorCreatedEvent
evt(GetId(),
7489 wxEVT_GRID_EDITOR_CREATED
,
7493 editor
->GetControl());
7494 GetEventHandler()->ProcessEvent(evt
);
7498 // resize editor to overflow into righthand cells if allowed
7499 int maxWidth
= rect
.width
;
7500 wxString value
= GetCellValue(row
, col
);
7501 if ( (value
!= wxEmptyString
) && (attr
->GetOverflow()) )
7504 GetTextExtent(value
, &maxWidth
, &y
,
7505 NULL
, NULL
, &attr
->GetFont());
7506 if (maxWidth
< rect
.width
) maxWidth
= rect
.width
;
7508 int client_right
= m_gridWin
->GetClientSize().GetWidth();
7509 if (rect
.x
+maxWidth
> client_right
)
7510 maxWidth
= client_right
- rect
.x
;
7512 if ((maxWidth
> rect
.width
) && (col
< m_numCols
) && m_table
)
7514 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7515 // may have changed earlier
7516 for (int i
= col
+cell_cols
; i
< m_numCols
; i
++)
7519 GetCellSize( row
, i
, &c_rows
, &c_cols
);
7520 // looks weird going over a multicell
7521 if (m_table
->IsEmptyCell(row
,i
) &&
7522 (rect
.width
< maxWidth
) && (c_rows
== 1))
7523 rect
.width
+= GetColWidth(i
);
7527 if (rect
.GetRight() > client_right
)
7528 rect
.SetRight(client_right
-1);
7531 editor
->SetCellAttr(attr
);
7532 editor
->SetSize( rect
);
7533 editor
->Show( TRUE
, attr
);
7535 // recalc dimensions in case we need to
7536 // expand the scrolled window to account for editor
7539 editor
->BeginEdit(row
, col
, this);
7540 editor
->SetCellAttr(NULL
);
7549 void wxGrid::HideCellEditControl()
7551 if ( IsCellEditControlEnabled() )
7553 int row
= m_currentCellCoords
.GetRow();
7554 int col
= m_currentCellCoords
.GetCol();
7556 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7557 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
7558 editor
->Show( FALSE
);
7561 m_gridWin
->SetFocus();
7562 // refresh whole row to the right
7563 wxRect
rect( CellToRect(row
, col
) );
7564 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7565 rect
.width
= m_gridWin
->GetClientSize().GetWidth() - rect
.x
;
7566 m_gridWin
->Refresh( FALSE
, &rect
);
7571 void wxGrid::SaveEditControlValue()
7573 if ( IsCellEditControlEnabled() )
7575 int row
= m_currentCellCoords
.GetRow();
7576 int col
= m_currentCellCoords
.GetCol();
7578 wxString oldval
= GetCellValue(row
,col
);
7580 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7581 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
7582 bool changed
= editor
->EndEdit(row
, col
, this);
7589 if ( SendEvent( wxEVT_GRID_CELL_CHANGE
,
7590 m_currentCellCoords
.GetRow(),
7591 m_currentCellCoords
.GetCol() ) < 0 ) {
7593 // Event has been vetoed, set the data back.
7594 SetCellValue(row
,col
,oldval
);
7602 // ------ Grid location functions
7603 // Note that all of these functions work with the logical coordinates of
7604 // grid cells and labels so you will need to convert from device
7605 // coordinates for mouse events etc.
7608 void wxGrid::XYToCell( int x
, int y
, wxGridCellCoords
& coords
)
7610 int row
= YToRow(y
);
7611 int col
= XToCol(x
);
7613 if ( row
== -1 || col
== -1 )
7615 coords
= wxGridNoCellCoords
;
7619 coords
.Set( row
, col
);
7624 // Internal Helper function for computing row or column from some
7625 // (unscrolled) coordinate value, using either
7626 // m_defaultRowHeight/m_defaultColWidth or binary search on array
7627 // of m_rowBottoms/m_ColRights to speed up the search!
7629 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
7630 const wxArrayInt
& BorderArray
, int nMax
,
7635 return clipToMinMax
&& (nMax
> 0) ? 0 : -1;
7641 size_t i_max
= coord
/ defaultDist
,
7644 if (BorderArray
.IsEmpty())
7646 if((int) i_max
< nMax
)
7648 return clipToMinMax
? nMax
- 1 : -1;
7651 if ( i_max
>= BorderArray
.GetCount())
7652 i_max
= BorderArray
.GetCount() - 1;
7655 if ( coord
>= BorderArray
[i_max
])
7658 i_max
= coord
/ minDist
;
7660 if ( i_max
>= BorderArray
.GetCount())
7661 i_max
= BorderArray
.GetCount() - 1;
7663 if ( coord
>= BorderArray
[i_max
])
7664 return clipToMinMax
? (int)i_max
: -1;
7665 if ( coord
< BorderArray
[0] )
7668 while ( i_max
- i_min
> 0 )
7670 wxCHECK_MSG(BorderArray
[i_min
] <= coord
&& coord
< BorderArray
[i_max
],
7671 0, _T("wxGrid: internal error in CoordToRowOrCol"));
7672 if (coord
>= BorderArray
[ i_max
- 1])
7676 int median
= i_min
+ (i_max
- i_min
+ 1) / 2;
7677 if (coord
< BorderArray
[median
])
7685 int wxGrid::YToRow( int y
)
7687 return CoordToRowOrCol(y
, m_defaultRowHeight
,
7688 m_minAcceptableRowHeight
, m_rowBottoms
, m_numRows
, FALSE
);
7692 int wxGrid::XToCol( int x
)
7694 return CoordToRowOrCol(x
, m_defaultColWidth
,
7695 m_minAcceptableColWidth
, m_colRights
, m_numCols
, FALSE
);
7699 // return the row number that that the y coord is near the edge of, or
7700 // -1 if not near an edge
7702 int wxGrid::YToEdgeOfRow( int y
)
7705 i
= internalYToRow(y
);
7707 if ( GetRowHeight(i
) > WXGRID_LABEL_EDGE_ZONE
)
7709 // We know that we are in row i, test whether we are
7710 // close enough to lower or upper border, respectively.
7711 if ( abs(GetRowBottom(i
) - y
) < WXGRID_LABEL_EDGE_ZONE
)
7713 else if( i
> 0 && y
- GetRowTop(i
) < WXGRID_LABEL_EDGE_ZONE
)
7721 // return the col number that that the x coord is near the edge of, or
7722 // -1 if not near an edge
7724 int wxGrid::XToEdgeOfCol( int x
)
7727 i
= internalXToCol(x
);
7729 if ( GetColWidth(i
) > WXGRID_LABEL_EDGE_ZONE
)
7731 // We know that we are in column i, test whether we are
7732 // close enough to right or left border, respectively.
7733 if ( abs(GetColRight(i
) - x
) < WXGRID_LABEL_EDGE_ZONE
)
7735 else if( i
> 0 && x
- GetColLeft(i
) < WXGRID_LABEL_EDGE_ZONE
)
7743 wxRect
wxGrid::CellToRect( int row
, int col
)
7745 wxRect
rect( -1, -1, -1, -1 );
7747 if ( row
>= 0 && row
< m_numRows
&&
7748 col
>= 0 && col
< m_numCols
)
7750 int i
, cell_rows
, cell_cols
;
7751 rect
.width
= rect
.height
= 0;
7752 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7753 // if negative then find multicell owner
7754 if (cell_rows
< 0) row
+= cell_rows
;
7755 if (cell_cols
< 0) col
+= cell_cols
;
7756 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7758 rect
.x
= GetColLeft(col
);
7759 rect
.y
= GetRowTop(row
);
7760 for (i
=col
; i
<col
+cell_cols
; i
++)
7761 rect
.width
+= GetColWidth(i
);
7762 for (i
=row
; i
<row
+cell_rows
; i
++)
7763 rect
.height
+= GetRowHeight(i
);
7766 // if grid lines are enabled, then the area of the cell is a bit smaller
7767 if (m_gridLinesEnabled
) {
7775 bool wxGrid::IsVisible( int row
, int col
, bool wholeCellVisible
)
7777 // get the cell rectangle in logical coords
7779 wxRect
r( CellToRect( row
, col
) );
7781 // convert to device coords
7783 int left
, top
, right
, bottom
;
7784 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
7785 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
7787 // check against the client area of the grid window
7790 m_gridWin
->GetClientSize( &cw
, &ch
);
7792 if ( wholeCellVisible
)
7794 // is the cell wholly visible ?
7796 return ( left
>= 0 && right
<= cw
&&
7797 top
>= 0 && bottom
<= ch
);
7801 // is the cell partly visible ?
7803 return ( ((left
>=0 && left
< cw
) || (right
> 0 && right
<= cw
)) &&
7804 ((top
>=0 && top
< ch
) || (bottom
> 0 && bottom
<= ch
)) );
7809 // make the specified cell location visible by doing a minimal amount
7812 void wxGrid::MakeCellVisible( int row
, int col
)
7816 int xpos
= -1, ypos
= -1;
7818 if ( row
>= 0 && row
< m_numRows
&&
7819 col
>= 0 && col
< m_numCols
)
7821 // get the cell rectangle in logical coords
7823 wxRect
r( CellToRect( row
, col
) );
7825 // convert to device coords
7827 int left
, top
, right
, bottom
;
7828 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
7829 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
7832 m_gridWin
->GetClientSize( &cw
, &ch
);
7838 else if ( bottom
> ch
)
7840 int h
= r
.GetHeight();
7842 for ( i
= row
-1; i
>= 0; i
-- )
7844 int rowHeight
= GetRowHeight(i
);
7845 if ( h
+ rowHeight
> ch
)
7852 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7853 // have rounding errors (this is important, because if we do, we
7854 // might not scroll at all and some cells won't be redrawn)
7856 // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7858 ypos
+= GRID_SCROLL_LINE_Y
;
7865 else if ( right
> cw
)
7867 // position the view so that the cell is on the right
7869 CalcUnscrolledPosition(0, 0, &x0
, &y0
);
7870 xpos
= x0
+ (right
- cw
);
7872 // see comment for ypos above
7873 xpos
+= GRID_SCROLL_LINE_X
;
7876 if ( xpos
!= -1 || ypos
!= -1 )
7879 xpos
/= GRID_SCROLL_LINE_X
;
7881 ypos
/= GRID_SCROLL_LINE_Y
;
7882 Scroll( xpos
, ypos
);
7890 // ------ Grid cursor movement functions
7893 bool wxGrid::MoveCursorUp( bool expandSelection
)
7895 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7896 m_currentCellCoords
.GetRow() >= 0 )
7898 if ( expandSelection
)
7900 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7901 m_selectingKeyboard
= m_currentCellCoords
;
7902 if ( m_selectingKeyboard
.GetRow() > 0 )
7904 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() - 1 );
7905 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7906 m_selectingKeyboard
.GetCol() );
7907 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7910 else if ( m_currentCellCoords
.GetRow() > 0 )
7913 MakeCellVisible( m_currentCellCoords
.GetRow() - 1,
7914 m_currentCellCoords
.GetCol() );
7915 SetCurrentCell( m_currentCellCoords
.GetRow() - 1,
7916 m_currentCellCoords
.GetCol() );
7927 bool wxGrid::MoveCursorDown( bool expandSelection
)
7929 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7930 m_currentCellCoords
.GetRow() < m_numRows
)
7932 if ( expandSelection
)
7934 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7935 m_selectingKeyboard
= m_currentCellCoords
;
7936 if ( m_selectingKeyboard
.GetRow() < m_numRows
-1 )
7938 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() + 1 );
7939 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7940 m_selectingKeyboard
.GetCol() );
7941 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7944 else if ( m_currentCellCoords
.GetRow() < m_numRows
- 1 )
7947 MakeCellVisible( m_currentCellCoords
.GetRow() + 1,
7948 m_currentCellCoords
.GetCol() );
7949 SetCurrentCell( m_currentCellCoords
.GetRow() + 1,
7950 m_currentCellCoords
.GetCol() );
7961 bool wxGrid::MoveCursorLeft( bool expandSelection
)
7963 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7964 m_currentCellCoords
.GetCol() >= 0 )
7966 if ( expandSelection
)
7968 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7969 m_selectingKeyboard
= m_currentCellCoords
;
7970 if ( m_selectingKeyboard
.GetCol() > 0 )
7972 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() - 1 );
7973 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7974 m_selectingKeyboard
.GetCol() );
7975 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7978 else if ( m_currentCellCoords
.GetCol() > 0 )
7981 MakeCellVisible( m_currentCellCoords
.GetRow(),
7982 m_currentCellCoords
.GetCol() - 1 );
7983 SetCurrentCell( m_currentCellCoords
.GetRow(),
7984 m_currentCellCoords
.GetCol() - 1 );
7995 bool wxGrid::MoveCursorRight( bool expandSelection
)
7997 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7998 m_currentCellCoords
.GetCol() < m_numCols
)
8000 if ( expandSelection
)
8002 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
8003 m_selectingKeyboard
= m_currentCellCoords
;
8004 if ( m_selectingKeyboard
.GetCol() < m_numCols
- 1 )
8006 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() + 1 );
8007 MakeCellVisible( m_selectingKeyboard
.GetRow(),
8008 m_selectingKeyboard
.GetCol() );
8009 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8012 else if ( m_currentCellCoords
.GetCol() < m_numCols
- 1 )
8015 MakeCellVisible( m_currentCellCoords
.GetRow(),
8016 m_currentCellCoords
.GetCol() + 1 );
8017 SetCurrentCell( m_currentCellCoords
.GetRow(),
8018 m_currentCellCoords
.GetCol() + 1 );
8029 bool wxGrid::MovePageUp()
8031 if ( m_currentCellCoords
== wxGridNoCellCoords
) return FALSE
;
8033 int row
= m_currentCellCoords
.GetRow();
8037 m_gridWin
->GetClientSize( &cw
, &ch
);
8039 int y
= GetRowTop(row
);
8040 int newRow
= internalYToRow( y
- ch
+ 1 );
8042 if ( newRow
== row
)
8044 //row > 0 , so newrow can never be less than 0 here.
8048 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
8049 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
8057 bool wxGrid::MovePageDown()
8059 if ( m_currentCellCoords
== wxGridNoCellCoords
) return FALSE
;
8061 int row
= m_currentCellCoords
.GetRow();
8062 if ( (row
+1) < m_numRows
)
8065 m_gridWin
->GetClientSize( &cw
, &ch
);
8067 int y
= GetRowTop(row
);
8068 int newRow
= internalYToRow( y
+ ch
);
8069 if ( newRow
== row
)
8071 // row < m_numRows , so newrow can't overflow here.
8075 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
8076 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
8084 bool wxGrid::MoveCursorUpBlock( bool expandSelection
)
8087 m_currentCellCoords
!= wxGridNoCellCoords
&&
8088 m_currentCellCoords
.GetRow() > 0 )
8090 int row
= m_currentCellCoords
.GetRow();
8091 int col
= m_currentCellCoords
.GetCol();
8093 if ( m_table
->IsEmptyCell(row
, col
) )
8095 // starting in an empty cell: find the next block of
8101 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8104 else if ( m_table
->IsEmptyCell(row
-1, col
) )
8106 // starting at the top of a block: find the next block
8112 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8117 // starting within a block: find the top of the block
8122 if ( m_table
->IsEmptyCell(row
, col
) )
8130 MakeCellVisible( row
, col
);
8131 if ( expandSelection
)
8133 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8134 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8139 SetCurrentCell( row
, col
);
8147 bool wxGrid::MoveCursorDownBlock( bool expandSelection
)
8150 m_currentCellCoords
!= wxGridNoCellCoords
&&
8151 m_currentCellCoords
.GetRow() < m_numRows
-1 )
8153 int row
= m_currentCellCoords
.GetRow();
8154 int col
= m_currentCellCoords
.GetCol();
8156 if ( m_table
->IsEmptyCell(row
, col
) )
8158 // starting in an empty cell: find the next block of
8161 while ( row
< m_numRows
-1 )
8164 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8167 else if ( m_table
->IsEmptyCell(row
+1, col
) )
8169 // starting at the bottom of a block: find the next block
8172 while ( row
< m_numRows
-1 )
8175 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8180 // starting within a block: find the bottom of the block
8182 while ( row
< m_numRows
-1 )
8185 if ( m_table
->IsEmptyCell(row
, col
) )
8193 MakeCellVisible( row
, col
);
8194 if ( expandSelection
)
8196 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8197 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8202 SetCurrentCell( row
, col
);
8211 bool wxGrid::MoveCursorLeftBlock( bool expandSelection
)
8214 m_currentCellCoords
!= wxGridNoCellCoords
&&
8215 m_currentCellCoords
.GetCol() > 0 )
8217 int row
= m_currentCellCoords
.GetRow();
8218 int col
= m_currentCellCoords
.GetCol();
8220 if ( m_table
->IsEmptyCell(row
, col
) )
8222 // starting in an empty cell: find the next block of
8228 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8231 else if ( m_table
->IsEmptyCell(row
, col
-1) )
8233 // starting at the left of a block: find the next block
8239 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8244 // starting within a block: find the left of the block
8249 if ( m_table
->IsEmptyCell(row
, col
) )
8257 MakeCellVisible( row
, col
);
8258 if ( expandSelection
)
8260 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8261 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8266 SetCurrentCell( row
, col
);
8275 bool wxGrid::MoveCursorRightBlock( bool expandSelection
)
8278 m_currentCellCoords
!= wxGridNoCellCoords
&&
8279 m_currentCellCoords
.GetCol() < m_numCols
-1 )
8281 int row
= m_currentCellCoords
.GetRow();
8282 int col
= m_currentCellCoords
.GetCol();
8284 if ( m_table
->IsEmptyCell(row
, col
) )
8286 // starting in an empty cell: find the next block of
8289 while ( col
< m_numCols
-1 )
8292 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8295 else if ( m_table
->IsEmptyCell(row
, col
+1) )
8297 // starting at the right of a block: find the next block
8300 while ( col
< m_numCols
-1 )
8303 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8308 // starting within a block: find the right of the block
8310 while ( col
< m_numCols
-1 )
8313 if ( m_table
->IsEmptyCell(row
, col
) )
8321 MakeCellVisible( row
, col
);
8322 if ( expandSelection
)
8324 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8325 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8330 SetCurrentCell( row
, col
);
8342 // ------ Label values and formatting
8345 void wxGrid::GetRowLabelAlignment( int *horiz
, int *vert
)
8347 *horiz
= m_rowLabelHorizAlign
;
8348 *vert
= m_rowLabelVertAlign
;
8351 void wxGrid::GetColLabelAlignment( int *horiz
, int *vert
)
8353 *horiz
= m_colLabelHorizAlign
;
8354 *vert
= m_colLabelVertAlign
;
8357 int wxGrid::GetColLabelTextOrientation()
8359 return m_colLabelTextOrientation
;
8362 wxString
wxGrid::GetRowLabelValue( int row
)
8366 return m_table
->GetRowLabelValue( row
);
8376 wxString
wxGrid::GetColLabelValue( int col
)
8380 return m_table
->GetColLabelValue( col
);
8391 void wxGrid::SetRowLabelSize( int width
)
8393 width
= wxMax( width
, 0 );
8394 if ( width
!= m_rowLabelWidth
)
8398 m_rowLabelWin
->Show( FALSE
);
8399 m_cornerLabelWin
->Show( FALSE
);
8401 else if ( m_rowLabelWidth
== 0 )
8403 m_rowLabelWin
->Show( TRUE
);
8404 if ( m_colLabelHeight
> 0 ) m_cornerLabelWin
->Show( TRUE
);
8407 m_rowLabelWidth
= width
;
8409 wxScrolledWindow::Refresh( TRUE
);
8414 void wxGrid::SetColLabelSize( int height
)
8416 height
= wxMax( height
, 0 );
8417 if ( height
!= m_colLabelHeight
)
8421 m_colLabelWin
->Show( FALSE
);
8422 m_cornerLabelWin
->Show( FALSE
);
8424 else if ( m_colLabelHeight
== 0 )
8426 m_colLabelWin
->Show( TRUE
);
8427 if ( m_rowLabelWidth
> 0 ) m_cornerLabelWin
->Show( TRUE
);
8430 m_colLabelHeight
= height
;
8432 wxScrolledWindow::Refresh( TRUE
);
8437 void wxGrid::SetLabelBackgroundColour( const wxColour
& colour
)
8439 if ( m_labelBackgroundColour
!= colour
)
8441 m_labelBackgroundColour
= colour
;
8442 m_rowLabelWin
->SetBackgroundColour( colour
);
8443 m_colLabelWin
->SetBackgroundColour( colour
);
8444 m_cornerLabelWin
->SetBackgroundColour( colour
);
8446 if ( !GetBatchCount() )
8448 m_rowLabelWin
->Refresh();
8449 m_colLabelWin
->Refresh();
8450 m_cornerLabelWin
->Refresh();
8455 void wxGrid::SetLabelTextColour( const wxColour
& colour
)
8457 if ( m_labelTextColour
!= colour
)
8459 m_labelTextColour
= colour
;
8460 if ( !GetBatchCount() )
8462 m_rowLabelWin
->Refresh();
8463 m_colLabelWin
->Refresh();
8468 void wxGrid::SetLabelFont( const wxFont
& font
)
8471 if ( !GetBatchCount() )
8473 m_rowLabelWin
->Refresh();
8474 m_colLabelWin
->Refresh();
8478 void wxGrid::SetRowLabelAlignment( int horiz
, int vert
)
8480 // allow old (incorrect) defs to be used
8483 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
8484 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
8485 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
8490 case wxTOP
: vert
= wxALIGN_TOP
; break;
8491 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
8492 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
8495 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
8497 m_rowLabelHorizAlign
= horiz
;
8500 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
8502 m_rowLabelVertAlign
= vert
;
8505 if ( !GetBatchCount() )
8507 m_rowLabelWin
->Refresh();
8511 void wxGrid::SetColLabelAlignment( int horiz
, int vert
)
8513 // allow old (incorrect) defs to be used
8516 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
8517 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
8518 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
8523 case wxTOP
: vert
= wxALIGN_TOP
; break;
8524 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
8525 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
8528 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
8530 m_colLabelHorizAlign
= horiz
;
8533 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
8535 m_colLabelVertAlign
= vert
;
8538 if ( !GetBatchCount() )
8540 m_colLabelWin
->Refresh();
8544 // Note: under MSW, the default column label font must be changed because it
8545 // does not support vertical printing
8547 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
8548 // pGrid->SetLabelFont(font);
8549 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
8551 void wxGrid::SetColLabelTextOrientation( int textOrientation
)
8553 if( textOrientation
== wxHORIZONTAL
|| textOrientation
== wxVERTICAL
)
8555 m_colLabelTextOrientation
= textOrientation
;
8558 if ( !GetBatchCount() )
8560 m_colLabelWin
->Refresh();
8564 void wxGrid::SetRowLabelValue( int row
, const wxString
& s
)
8568 m_table
->SetRowLabelValue( row
, s
);
8569 if ( !GetBatchCount() )
8571 wxRect rect
= CellToRect( row
, 0);
8572 if ( rect
.height
> 0 )
8574 CalcScrolledPosition(0, rect
.y
, &rect
.x
, &rect
.y
);
8576 rect
.width
= m_rowLabelWidth
;
8577 m_rowLabelWin
->Refresh( TRUE
, &rect
);
8583 void wxGrid::SetColLabelValue( int col
, const wxString
& s
)
8587 m_table
->SetColLabelValue( col
, s
);
8588 if ( !GetBatchCount() )
8590 wxRect rect
= CellToRect( 0, col
);
8591 if ( rect
.width
> 0 )
8593 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &rect
.y
);
8595 rect
.height
= m_colLabelHeight
;
8596 m_colLabelWin
->Refresh( TRUE
, &rect
);
8602 void wxGrid::SetGridLineColour( const wxColour
& colour
)
8604 if ( m_gridLineColour
!= colour
)
8606 m_gridLineColour
= colour
;
8608 wxClientDC
dc( m_gridWin
);
8610 DrawAllGridLines( dc
, wxRegion() );
8615 void wxGrid::SetCellHighlightColour( const wxColour
& colour
)
8617 if ( m_cellHighlightColour
!= colour
)
8619 m_cellHighlightColour
= colour
;
8621 wxClientDC
dc( m_gridWin
);
8623 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
8624 DrawCellHighlight(dc
, attr
);
8629 void wxGrid::SetCellHighlightPenWidth(int width
)
8631 if (m_cellHighlightPenWidth
!= width
) {
8632 m_cellHighlightPenWidth
= width
;
8634 // Just redrawing the cell highlight is not enough since that won't
8635 // make any visible change if the the thickness is getting smaller.
8636 int row
= m_currentCellCoords
.GetRow();
8637 int col
= m_currentCellCoords
.GetCol();
8638 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
8640 wxRect rect
= CellToRect(row
, col
);
8641 m_gridWin
->Refresh(TRUE
, &rect
);
8645 void wxGrid::SetCellHighlightROPenWidth(int width
)
8647 if (m_cellHighlightROPenWidth
!= width
) {
8648 m_cellHighlightROPenWidth
= width
;
8650 // Just redrawing the cell highlight is not enough since that won't
8651 // make any visible change if the the thickness is getting smaller.
8652 int row
= m_currentCellCoords
.GetRow();
8653 int col
= m_currentCellCoords
.GetCol();
8654 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
8656 wxRect rect
= CellToRect(row
, col
);
8657 m_gridWin
->Refresh(TRUE
, &rect
);
8661 void wxGrid::EnableGridLines( bool enable
)
8663 if ( enable
!= m_gridLinesEnabled
)
8665 m_gridLinesEnabled
= enable
;
8667 if ( !GetBatchCount() )
8671 wxClientDC
dc( m_gridWin
);
8673 DrawAllGridLines( dc
, wxRegion() );
8677 m_gridWin
->Refresh();
8684 int wxGrid::GetDefaultRowSize()
8686 return m_defaultRowHeight
;
8689 int wxGrid::GetRowSize( int row
)
8691 wxCHECK_MSG( row
>= 0 && row
< m_numRows
, 0, _T("invalid row index") );
8693 return GetRowHeight(row
);
8696 int wxGrid::GetDefaultColSize()
8698 return m_defaultColWidth
;
8701 int wxGrid::GetColSize( int col
)
8703 wxCHECK_MSG( col
>= 0 && col
< m_numCols
, 0, _T("invalid column index") );
8705 return GetColWidth(col
);
8708 // ============================================================================
8709 // access to the grid attributes: each of them has a default value in the grid
8710 // itself and may be overidden on a per-cell basis
8711 // ============================================================================
8713 // ----------------------------------------------------------------------------
8714 // setting default attributes
8715 // ----------------------------------------------------------------------------
8717 void wxGrid::SetDefaultCellBackgroundColour( const wxColour
& col
)
8719 m_defaultCellAttr
->SetBackgroundColour(col
);
8721 m_gridWin
->SetBackgroundColour(col
);
8725 void wxGrid::SetDefaultCellTextColour( const wxColour
& col
)
8727 m_defaultCellAttr
->SetTextColour(col
);
8730 void wxGrid::SetDefaultCellAlignment( int horiz
, int vert
)
8732 m_defaultCellAttr
->SetAlignment(horiz
, vert
);
8735 void wxGrid::SetDefaultCellOverflow( bool allow
)
8737 m_defaultCellAttr
->SetOverflow(allow
);
8740 void wxGrid::SetDefaultCellFont( const wxFont
& font
)
8742 m_defaultCellAttr
->SetFont(font
);
8745 void wxGrid::SetDefaultRenderer(wxGridCellRenderer
*renderer
)
8747 m_defaultCellAttr
->SetRenderer(renderer
);
8750 void wxGrid::SetDefaultEditor(wxGridCellEditor
*editor
)
8752 m_defaultCellAttr
->SetEditor(editor
);
8755 // ----------------------------------------------------------------------------
8756 // access to the default attrbiutes
8757 // ----------------------------------------------------------------------------
8759 wxColour
wxGrid::GetDefaultCellBackgroundColour()
8761 return m_defaultCellAttr
->GetBackgroundColour();
8764 wxColour
wxGrid::GetDefaultCellTextColour()
8766 return m_defaultCellAttr
->GetTextColour();
8769 wxFont
wxGrid::GetDefaultCellFont()
8771 return m_defaultCellAttr
->GetFont();
8774 void wxGrid::GetDefaultCellAlignment( int *horiz
, int *vert
)
8776 m_defaultCellAttr
->GetAlignment(horiz
, vert
);
8779 bool wxGrid::GetDefaultCellOverflow()
8781 return m_defaultCellAttr
->GetOverflow();
8784 wxGridCellRenderer
*wxGrid::GetDefaultRenderer() const
8786 return m_defaultCellAttr
->GetRenderer(NULL
, 0, 0);
8789 wxGridCellEditor
*wxGrid::GetDefaultEditor() const
8791 return m_defaultCellAttr
->GetEditor(NULL
,0,0);
8794 // ----------------------------------------------------------------------------
8795 // access to cell attributes
8796 // ----------------------------------------------------------------------------
8798 wxColour
wxGrid::GetCellBackgroundColour(int row
, int col
)
8800 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8801 wxColour colour
= attr
->GetBackgroundColour();
8806 wxColour
wxGrid::GetCellTextColour( int row
, int col
)
8808 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8809 wxColour colour
= attr
->GetTextColour();
8814 wxFont
wxGrid::GetCellFont( int row
, int col
)
8816 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8817 wxFont font
= attr
->GetFont();
8822 void wxGrid::GetCellAlignment( int row
, int col
, int *horiz
, int *vert
)
8824 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8825 attr
->GetAlignment(horiz
, vert
);
8829 bool wxGrid::GetCellOverflow( int row
, int col
)
8831 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8832 bool allow
= attr
->GetOverflow();
8837 void wxGrid::GetCellSize( int row
, int col
, int *num_rows
, int *num_cols
)
8839 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8840 attr
->GetSize( num_rows
, num_cols
);
8844 wxGridCellRenderer
* wxGrid::GetCellRenderer(int row
, int col
)
8846 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8847 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
8853 wxGridCellEditor
* wxGrid::GetCellEditor(int row
, int col
)
8855 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8856 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
8862 bool wxGrid::IsReadOnly(int row
, int col
) const
8864 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8865 bool isReadOnly
= attr
->IsReadOnly();
8870 // ----------------------------------------------------------------------------
8871 // attribute support: cache, automatic provider creation, ...
8872 // ----------------------------------------------------------------------------
8874 bool wxGrid::CanHaveAttributes()
8881 return m_table
->CanHaveAttributes();
8884 void wxGrid::ClearAttrCache()
8886 if ( m_attrCache
.row
!= -1 )
8888 wxSafeDecRef(m_attrCache
.attr
);
8889 m_attrCache
.attr
= NULL
;
8890 m_attrCache
.row
= -1;
8894 void wxGrid::CacheAttr(int row
, int col
, wxGridCellAttr
*attr
) const
8898 wxGrid
*self
= (wxGrid
*)this; // const_cast
8900 self
->ClearAttrCache();
8901 self
->m_attrCache
.row
= row
;
8902 self
->m_attrCache
.col
= col
;
8903 self
->m_attrCache
.attr
= attr
;
8908 bool wxGrid::LookupAttr(int row
, int col
, wxGridCellAttr
**attr
) const
8910 if ( row
== m_attrCache
.row
&& col
== m_attrCache
.col
)
8912 *attr
= m_attrCache
.attr
;
8913 wxSafeIncRef(m_attrCache
.attr
);
8915 #ifdef DEBUG_ATTR_CACHE
8916 gs_nAttrCacheHits
++;
8923 #ifdef DEBUG_ATTR_CACHE
8924 gs_nAttrCacheMisses
++;
8930 wxGridCellAttr
*wxGrid::GetCellAttr(int row
, int col
) const
8932 wxGridCellAttr
*attr
= NULL
;
8933 // Additional test to avoid looking at the cache e.g. for
8934 // wxNoCellCoords, as this will confuse memory management.
8937 if ( !LookupAttr(row
, col
, &attr
) )
8939 attr
= m_table
? m_table
->GetAttr(row
, col
, wxGridCellAttr::Any
)
8940 : (wxGridCellAttr
*)NULL
;
8941 CacheAttr(row
, col
, attr
);
8946 attr
->SetDefAttr(m_defaultCellAttr
);
8950 attr
= m_defaultCellAttr
;
8957 wxGridCellAttr
*wxGrid::GetOrCreateCellAttr(int row
, int col
) const
8959 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
8961 wxCHECK_MSG( m_table
, attr
,
8962 _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
8964 attr
= m_table
->GetAttr(row
, col
, wxGridCellAttr::Cell
);
8967 attr
= new wxGridCellAttr(m_defaultCellAttr
);
8969 // artificially inc the ref count to match DecRef() in caller
8971 m_table
->SetAttr(attr
, row
, col
);
8977 // ----------------------------------------------------------------------------
8978 // setting column attributes (wrappers around SetColAttr)
8979 // ----------------------------------------------------------------------------
8981 void wxGrid::SetColFormatBool(int col
)
8983 SetColFormatCustom(col
, wxGRID_VALUE_BOOL
);
8986 void wxGrid::SetColFormatNumber(int col
)
8988 SetColFormatCustom(col
, wxGRID_VALUE_NUMBER
);
8991 void wxGrid::SetColFormatFloat(int col
, int width
, int precision
)
8993 wxString typeName
= wxGRID_VALUE_FLOAT
;
8994 if ( (width
!= -1) || (precision
!= -1) )
8996 typeName
<< _T(':') << width
<< _T(',') << precision
;
8999 SetColFormatCustom(col
, typeName
);
9002 void wxGrid::SetColFormatCustom(int col
, const wxString
& typeName
)
9004 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
9006 attr
= m_table
->GetAttr(-1, col
, wxGridCellAttr::Col
);
9008 attr
= new wxGridCellAttr
;
9009 wxGridCellRenderer
*renderer
= GetDefaultRendererForType(typeName
);
9010 attr
->SetRenderer(renderer
);
9012 SetColAttr(col
, attr
);
9016 // ----------------------------------------------------------------------------
9017 // setting cell attributes: this is forwarded to the table
9018 // ----------------------------------------------------------------------------
9020 void wxGrid::SetAttr(int row
, int col
, wxGridCellAttr
*attr
)
9022 if ( CanHaveAttributes() )
9024 m_table
->SetAttr(attr
, row
, col
);
9033 void wxGrid::SetRowAttr(int row
, wxGridCellAttr
*attr
)
9035 if ( CanHaveAttributes() )
9037 m_table
->SetRowAttr(attr
, row
);
9046 void wxGrid::SetColAttr(int col
, wxGridCellAttr
*attr
)
9048 if ( CanHaveAttributes() )
9050 m_table
->SetColAttr(attr
, col
);
9059 void wxGrid::SetCellBackgroundColour( int row
, int col
, const wxColour
& colour
)
9061 if ( CanHaveAttributes() )
9063 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9064 attr
->SetBackgroundColour(colour
);
9069 void wxGrid::SetCellTextColour( int row
, int col
, const wxColour
& colour
)
9071 if ( CanHaveAttributes() )
9073 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9074 attr
->SetTextColour(colour
);
9079 void wxGrid::SetCellFont( int row
, int col
, const wxFont
& font
)
9081 if ( CanHaveAttributes() )
9083 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9084 attr
->SetFont(font
);
9089 void wxGrid::SetCellAlignment( int row
, int col
, int horiz
, int vert
)
9091 if ( CanHaveAttributes() )
9093 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9094 attr
->SetAlignment(horiz
, vert
);
9099 void wxGrid::SetCellOverflow( int row
, int col
, bool allow
)
9101 if ( CanHaveAttributes() )
9103 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9104 attr
->SetOverflow(allow
);
9109 void wxGrid::SetCellSize( int row
, int col
, int num_rows
, int num_cols
)
9111 if ( CanHaveAttributes() )
9113 int cell_rows
, cell_cols
;
9115 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9116 attr
->GetSize(&cell_rows
, &cell_cols
);
9117 attr
->SetSize(num_rows
, num_cols
);
9120 // Cannot set the size of a cell to 0 or negative values
9121 // While it is perfectly legal to do that, this function cannot
9122 // handle all the possibilies, do it by hand by getting the CellAttr.
9123 // You can only set the size of a cell to 1,1 or greater with this fn
9124 wxASSERT_MSG( !((cell_rows
< 1) || (cell_cols
< 1)),
9125 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
9126 wxASSERT_MSG( !((num_rows
< 1) || (num_cols
< 1)),
9127 wxT("wxGrid::SetCellSize setting cell size to < 1"));
9129 // if this was already a multicell then "turn off" the other cells first
9130 if ((cell_rows
> 1) || (cell_rows
> 1))
9133 for (j
=row
; j
<row
+cell_rows
; j
++)
9135 for (i
=col
; i
<col
+cell_cols
; i
++)
9137 if ((i
!= col
) || (j
!= row
))
9139 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
9140 attr_stub
->SetSize( 1, 1 );
9141 attr_stub
->DecRef();
9147 // mark the cells that will be covered by this cell to
9148 // negative or zero values to point back at this cell
9149 if (((num_rows
> 1) || (num_cols
> 1)) && (num_rows
>= 1) && (num_cols
>= 1))
9152 for (j
=row
; j
<row
+num_rows
; j
++)
9154 for (i
=col
; i
<col
+num_cols
; i
++)
9156 if ((i
!= col
) || (j
!= row
))
9158 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
9159 attr_stub
->SetSize( row
-j
, col
-i
);
9160 attr_stub
->DecRef();
9168 void wxGrid::SetCellRenderer(int row
, int col
, wxGridCellRenderer
*renderer
)
9170 if ( CanHaveAttributes() )
9172 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9173 attr
->SetRenderer(renderer
);
9178 void wxGrid::SetCellEditor(int row
, int col
, wxGridCellEditor
* editor
)
9180 if ( CanHaveAttributes() )
9182 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9183 attr
->SetEditor(editor
);
9188 void wxGrid::SetReadOnly(int row
, int col
, bool isReadOnly
)
9190 if ( CanHaveAttributes() )
9192 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9193 attr
->SetReadOnly(isReadOnly
);
9198 // ----------------------------------------------------------------------------
9199 // Data type registration
9200 // ----------------------------------------------------------------------------
9202 void wxGrid::RegisterDataType(const wxString
& typeName
,
9203 wxGridCellRenderer
* renderer
,
9204 wxGridCellEditor
* editor
)
9206 m_typeRegistry
->RegisterDataType(typeName
, renderer
, editor
);
9210 wxGridCellEditor
* wxGrid::GetDefaultEditorForCell(int row
, int col
) const
9212 wxString typeName
= m_table
->GetTypeName(row
, col
);
9213 return GetDefaultEditorForType(typeName
);
9216 wxGridCellRenderer
* wxGrid::GetDefaultRendererForCell(int row
, int col
) const
9218 wxString typeName
= m_table
->GetTypeName(row
, col
);
9219 return GetDefaultRendererForType(typeName
);
9223 wxGrid::GetDefaultEditorForType(const wxString
& typeName
) const
9225 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
9226 if ( index
== wxNOT_FOUND
)
9228 wxFAIL_MSG(wxT("Unknown data type name"));
9233 return m_typeRegistry
->GetEditor(index
);
9237 wxGrid::GetDefaultRendererForType(const wxString
& typeName
) const
9239 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
9240 if ( index
== wxNOT_FOUND
)
9242 wxFAIL_MSG(wxT("Unknown data type name"));
9247 return m_typeRegistry
->GetRenderer(index
);
9251 // ----------------------------------------------------------------------------
9253 // ----------------------------------------------------------------------------
9255 void wxGrid::EnableDragRowSize( bool enable
)
9257 m_canDragRowSize
= enable
;
9261 void wxGrid::EnableDragColSize( bool enable
)
9263 m_canDragColSize
= enable
;
9266 void wxGrid::EnableDragGridSize( bool enable
)
9268 m_canDragGridSize
= enable
;
9272 void wxGrid::SetDefaultRowSize( int height
, bool resizeExistingRows
)
9274 m_defaultRowHeight
= wxMax( height
, m_minAcceptableRowHeight
);
9276 if ( resizeExistingRows
)
9278 // since we are resizing all rows to the default row size,
9279 // we can simply clear the row heights and row bottoms
9280 // arrays (which also allows us to take advantage of
9281 // some speed optimisations)
9282 m_rowHeights
.Empty();
9283 m_rowBottoms
.Empty();
9284 if ( !GetBatchCount() )
9289 void wxGrid::SetRowSize( int row
, int height
)
9291 wxCHECK_RET( row
>= 0 && row
< m_numRows
, _T("invalid row index") );
9293 // See comment in SetColSize
9294 if ( height
< GetRowMinimalAcceptableHeight()) { return; }
9296 if ( m_rowHeights
.IsEmpty() )
9298 // need to really create the array
9302 int h
= wxMax( 0, height
);
9303 int diff
= h
- m_rowHeights
[row
];
9305 m_rowHeights
[row
] = h
;
9307 for ( i
= row
; i
< m_numRows
; i
++ )
9309 m_rowBottoms
[i
] += diff
;
9311 if ( !GetBatchCount() )
9315 void wxGrid::SetDefaultColSize( int width
, bool resizeExistingCols
)
9317 m_defaultColWidth
= wxMax( width
, m_minAcceptableColWidth
);
9319 if ( resizeExistingCols
)
9321 // since we are resizing all columns to the default column size,
9322 // we can simply clear the col widths and col rights
9323 // arrays (which also allows us to take advantage of
9324 // some speed optimisations)
9325 m_colWidths
.Empty();
9326 m_colRights
.Empty();
9327 if ( !GetBatchCount() )
9332 void wxGrid::SetColSize( int col
, int width
)
9334 wxCHECK_RET( col
>= 0 && col
< m_numCols
, _T("invalid column index") );
9336 // should we check that it's bigger than GetColMinimalWidth(col) here?
9338 // No, because it is reasonable to assume the library user know's
9339 // what he is doing. However whe should test against the weaker
9340 // constariant of minimalAcceptableWidth, as this breaks rendering
9342 // This test then fixes sf.net bug #645734
9344 if ( width
< GetColMinimalAcceptableWidth()) { return; }
9346 if ( m_colWidths
.IsEmpty() )
9348 // need to really create the array
9352 // if < 0 calc new width from label
9356 wxArrayString lines
;
9357 wxClientDC
dc(m_colLabelWin
);
9358 dc
.SetFont(GetLabelFont());
9359 StringToLines(GetColLabelValue(col
), lines
);
9360 GetTextBoxSize(dc
, lines
, &w
, &h
);
9363 int w
= wxMax( 0, width
);
9364 int diff
= w
- m_colWidths
[col
];
9365 m_colWidths
[col
] = w
;
9368 for ( i
= col
; i
< m_numCols
; i
++ )
9370 m_colRights
[i
] += diff
;
9372 if ( !GetBatchCount() )
9377 void wxGrid::SetColMinimalWidth( int col
, int width
)
9379 if (width
> GetColMinimalAcceptableWidth()) {
9380 m_colMinWidths
[col
] = width
;
9384 void wxGrid::SetRowMinimalHeight( int row
, int width
)
9386 if (width
> GetRowMinimalAcceptableHeight()) {
9387 m_rowMinHeights
[row
] = width
;
9391 int wxGrid::GetColMinimalWidth(int col
) const
9393 wxLongToLongHashMap::const_iterator it
= m_colMinWidths
.find(col
);
9394 return it
!= m_colMinWidths
.end() ? (int)it
->second
: m_minAcceptableColWidth
;
9397 int wxGrid::GetRowMinimalHeight(int row
) const
9399 wxLongToLongHashMap::const_iterator it
= m_rowMinHeights
.find(row
);
9400 return it
!= m_rowMinHeights
.end() ? (int)it
->second
: m_minAcceptableRowHeight
;
9403 void wxGrid::SetColMinimalAcceptableWidth( int width
)
9407 m_minAcceptableColWidth
= width
;
9410 void wxGrid::SetRowMinimalAcceptableHeight( int height
)
9414 m_minAcceptableRowHeight
= height
;
9417 int wxGrid::GetColMinimalAcceptableWidth() const
9419 return m_minAcceptableColWidth
;
9422 int wxGrid::GetRowMinimalAcceptableHeight() const
9424 return m_minAcceptableRowHeight
;
9427 // ----------------------------------------------------------------------------
9429 // ----------------------------------------------------------------------------
9431 void wxGrid::AutoSizeColOrRow( int colOrRow
, bool setAsMin
, bool column
)
9433 wxClientDC
dc(m_gridWin
);
9435 // init both of them to avoid compiler warnings, even if weo nly need one
9443 wxCoord extent
, extentMax
= 0;
9444 int max
= column
? m_numRows
: m_numCols
;
9445 for ( int rowOrCol
= 0; rowOrCol
< max
; rowOrCol
++ )
9452 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
9453 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
9456 wxSize size
= renderer
->GetBestSize(*this, *attr
, dc
, row
, col
);
9457 extent
= column
? size
.x
: size
.y
;
9458 if ( extent
> extentMax
)
9469 // now also compare with the column label extent
9471 dc
.SetFont( GetLabelFont() );
9475 dc
.GetTextExtent( GetColLabelValue(col
), &w
, &h
);
9476 if( GetColLabelTextOrientation() == wxVERTICAL
)
9480 dc
.GetTextExtent( GetRowLabelValue(row
), &w
, &h
);
9482 extent
= column
? w
: h
;
9483 if ( extent
> extentMax
)
9490 // empty column - give default extent (notice that if extentMax is less
9491 // than default extent but != 0, it's ok)
9492 extentMax
= column
? m_defaultColWidth
: m_defaultRowHeight
;
9498 // leave some space around text
9509 SetColSize(col
, extentMax
);
9510 if ( !GetBatchCount() )
9513 m_gridWin
->GetClientSize( &cw
, &ch
);
9514 wxRect
rect ( CellToRect( 0, col
) );
9516 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
9517 rect
.width
= cw
- rect
.x
;
9518 rect
.height
= m_colLabelHeight
;
9519 m_colLabelWin
->Refresh( TRUE
, &rect
);
9524 SetRowSize(row
, extentMax
);
9525 if ( !GetBatchCount() )
9528 m_gridWin
->GetClientSize( &cw
, &ch
);
9529 wxRect
rect ( CellToRect( row
, 0 ) );
9531 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
9532 rect
.width
= m_rowLabelWidth
;
9533 rect
.height
= ch
- rect
.y
;
9534 m_rowLabelWin
->Refresh( TRUE
, &rect
);
9540 SetColMinimalWidth(col
, extentMax
);
9542 SetRowMinimalHeight(row
, extentMax
);
9546 int wxGrid::SetOrCalcColumnSizes(bool calcOnly
, bool setAsMin
)
9548 int width
= m_rowLabelWidth
;
9553 for ( int col
= 0; col
< m_numCols
; col
++ )
9557 AutoSizeColumn(col
, setAsMin
);
9560 width
+= GetColWidth(col
);
9569 int wxGrid::SetOrCalcRowSizes(bool calcOnly
, bool setAsMin
)
9571 int height
= m_colLabelHeight
;
9576 for ( int row
= 0; row
< m_numRows
; row
++ )
9580 AutoSizeRow(row
, setAsMin
);
9583 height
+= GetRowHeight(row
);
9592 void wxGrid::AutoSize()
9596 wxSize
size(SetOrCalcColumnSizes(FALSE
), SetOrCalcRowSizes(FALSE
));
9598 // round up the size to a multiple of scroll step - this ensures that we
9599 // won't get the scrollbars if we're sized exactly to this width
9600 // CalcDimension adds m_extraWidth + 1 etc. to calculate the necessary
9602 wxSize
sizeFit(GetScrollX(size
.x
+ m_extraWidth
+ 1) * GRID_SCROLL_LINE_X
,
9603 GetScrollY(size
.y
+ m_extraHeight
+ 1) * GRID_SCROLL_LINE_Y
);
9605 // distribute the extra space between the columns/rows to avoid having
9606 // extra white space
9608 // Remove the extra m_extraWidth + 1 added above
9609 wxCoord diff
= sizeFit
.x
- size
.x
+ (m_extraWidth
+ 1);
9610 if ( diff
&& m_numCols
)
9612 // try to resize the columns uniformly
9613 wxCoord diffPerCol
= diff
/ m_numCols
;
9616 for ( int col
= 0; col
< m_numCols
; col
++ )
9618 SetColSize(col
, GetColWidth(col
) + diffPerCol
);
9622 // add remaining amount to the last columns
9623 diff
-= diffPerCol
* m_numCols
;
9626 for ( int col
= m_numCols
- 1; col
>= m_numCols
- diff
; col
-- )
9628 SetColSize(col
, GetColWidth(col
) + 1);
9634 diff
= sizeFit
.y
- size
.y
- (m_extraHeight
+ 1);
9635 if ( diff
&& m_numRows
)
9637 // try to resize the columns uniformly
9638 wxCoord diffPerRow
= diff
/ m_numRows
;
9641 for ( int row
= 0; row
< m_numRows
; row
++ )
9643 SetRowSize(row
, GetRowHeight(row
) + diffPerRow
);
9647 // add remaining amount to the last rows
9648 diff
-= diffPerRow
* m_numRows
;
9651 for ( int row
= m_numRows
- 1; row
>= m_numRows
- diff
; row
-- )
9653 SetRowSize(row
, GetRowHeight(row
) + 1);
9660 SetClientSize(sizeFit
);
9663 void wxGrid::AutoSizeRowLabelSize( int row
)
9665 wxArrayString lines
;
9668 // Hide the edit control, so it
9669 // won't interfer with drag-shrinking.
9670 if( IsCellEditControlShown() )
9672 HideCellEditControl();
9673 SaveEditControlValue();
9676 // autosize row height depending on label text
9677 StringToLines( GetRowLabelValue( row
), lines
);
9678 wxClientDC
dc( m_rowLabelWin
);
9679 GetTextBoxSize( dc
, lines
, &w
, &h
);
9680 if( h
< m_defaultRowHeight
)
9681 h
= m_defaultRowHeight
;
9686 void wxGrid::AutoSizeColLabelSize( int col
)
9688 wxArrayString lines
;
9691 // Hide the edit control, so it
9692 // won't interfer with drag-shrinking.
9693 if( IsCellEditControlShown() )
9695 HideCellEditControl();
9696 SaveEditControlValue();
9699 // autosize column width depending on label text
9700 StringToLines( GetColLabelValue( col
), lines
);
9701 wxClientDC
dc( m_colLabelWin
);
9702 if( GetColLabelTextOrientation() == wxHORIZONTAL
)
9703 GetTextBoxSize( dc
, lines
, &w
, &h
);
9705 GetTextBoxSize( dc
, lines
, &h
, &w
);
9706 if( w
< m_defaultColWidth
)
9707 w
= m_defaultColWidth
;
9712 wxSize
wxGrid::DoGetBestSize() const
9714 // don't set sizes, only calculate them
9715 wxGrid
*self
= (wxGrid
*)this; // const_cast
9718 width
= self
->SetOrCalcColumnSizes(TRUE
);
9719 height
= self
->SetOrCalcRowSizes(TRUE
);
9721 int maxwidth
, maxheight
;
9722 wxDisplaySize( & maxwidth
, & maxheight
);
9724 if ( width
> maxwidth
) width
= maxwidth
;
9725 if ( height
> maxheight
) height
= maxheight
;
9727 return wxSize( width
, height
);
9736 wxPen
& wxGrid::GetDividerPen() const
9741 // ----------------------------------------------------------------------------
9742 // cell value accessor functions
9743 // ----------------------------------------------------------------------------
9745 void wxGrid::SetCellValue( int row
, int col
, const wxString
& s
)
9749 m_table
->SetValue( row
, col
, s
);
9750 if ( !GetBatchCount() )
9753 wxRect
rect( CellToRect( row
, col
) );
9755 rect
.width
= m_gridWin
->GetClientSize().GetWidth();
9756 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
9757 m_gridWin
->Refresh( FALSE
, &rect
);
9760 if ( m_currentCellCoords
.GetRow() == row
&&
9761 m_currentCellCoords
.GetCol() == col
&&
9762 IsCellEditControlShown())
9763 // Note: If we are using IsCellEditControlEnabled,
9764 // this interacts badly with calling SetCellValue from
9765 // an EVT_GRID_CELL_CHANGE handler.
9767 HideCellEditControl();
9768 ShowCellEditControl(); // will reread data from table
9775 // ------ Block, row and col selection
9778 void wxGrid::SelectRow( int row
, bool addToSelected
)
9780 if ( IsSelection() && !addToSelected
)
9784 m_selection
->SelectRow( row
, FALSE
, addToSelected
);
9788 void wxGrid::SelectCol( int col
, bool addToSelected
)
9790 if ( IsSelection() && !addToSelected
)
9794 m_selection
->SelectCol( col
, FALSE
, addToSelected
);
9798 void wxGrid::SelectBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
,
9799 bool addToSelected
)
9801 if ( IsSelection() && !addToSelected
)
9805 m_selection
->SelectBlock( topRow
, leftCol
, bottomRow
, rightCol
,
9806 FALSE
, addToSelected
);
9810 void wxGrid::SelectAll()
9812 if ( m_numRows
> 0 && m_numCols
> 0 )
9815 m_selection
->SelectBlock( 0, 0, m_numRows
-1, m_numCols
-1 );
9820 // ------ Cell, row and col deselection
9823 void wxGrid::DeselectRow( int row
)
9828 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
9830 if ( m_selection
->IsInSelection(row
, 0 ) )
9831 m_selection
->ToggleCellSelection( row
, 0);
9835 int nCols
= GetNumberCols();
9836 for ( int i
= 0; i
< nCols
; i
++ )
9838 if ( m_selection
->IsInSelection(row
, i
) )
9839 m_selection
->ToggleCellSelection( row
, i
);
9844 void wxGrid::DeselectCol( int col
)
9849 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
9851 if ( m_selection
->IsInSelection(0, col
) )
9852 m_selection
->ToggleCellSelection( 0, col
);
9856 int nRows
= GetNumberRows();
9857 for ( int i
= 0; i
< nRows
; i
++ )
9859 if ( m_selection
->IsInSelection(i
, col
) )
9860 m_selection
->ToggleCellSelection(i
, col
);
9865 void wxGrid::DeselectCell( int row
, int col
)
9867 if ( m_selection
&& m_selection
->IsInSelection(row
, col
) )
9868 m_selection
->ToggleCellSelection(row
, col
);
9871 bool wxGrid::IsSelection()
9873 return ( m_selection
&& (m_selection
->IsSelection() ||
9874 ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
9875 m_selectingBottomRight
!= wxGridNoCellCoords
) ) );
9878 bool wxGrid::IsInSelection( int row
, int col
) const
9880 return ( m_selection
&& (m_selection
->IsInSelection( row
, col
) ||
9881 ( row
>= m_selectingTopLeft
.GetRow() &&
9882 col
>= m_selectingTopLeft
.GetCol() &&
9883 row
<= m_selectingBottomRight
.GetRow() &&
9884 col
<= m_selectingBottomRight
.GetCol() )) );
9887 wxGridCellCoordsArray
wxGrid::GetSelectedCells() const
9889 if (!m_selection
) { wxGridCellCoordsArray a
; return a
; }
9890 return m_selection
->m_cellSelection
;
9892 wxGridCellCoordsArray
wxGrid::GetSelectionBlockTopLeft() const
9894 if (!m_selection
) { wxGridCellCoordsArray a
; return a
; }
9895 return m_selection
->m_blockSelectionTopLeft
;
9897 wxGridCellCoordsArray
wxGrid::GetSelectionBlockBottomRight() const
9899 if (!m_selection
) { wxGridCellCoordsArray a
; return a
; }
9900 return m_selection
->m_blockSelectionBottomRight
;
9902 wxArrayInt
wxGrid::GetSelectedRows() const
9904 if (!m_selection
) { wxArrayInt a
; return a
; }
9905 return m_selection
->m_rowSelection
;
9907 wxArrayInt
wxGrid::GetSelectedCols() const
9909 if (!m_selection
) { wxArrayInt a
; return a
; }
9910 return m_selection
->m_colSelection
;
9914 void wxGrid::ClearSelection()
9916 m_selectingTopLeft
= wxGridNoCellCoords
;
9917 m_selectingBottomRight
= wxGridNoCellCoords
;
9919 m_selection
->ClearSelection();
9923 // This function returns the rectangle that encloses the given block
9924 // in device coords clipped to the client size of the grid window.
9926 wxRect
wxGrid::BlockToDeviceRect( const wxGridCellCoords
&topLeft
,
9927 const wxGridCellCoords
&bottomRight
)
9929 wxRect
rect( wxGridNoCellRect
);
9932 cellRect
= CellToRect( topLeft
);
9933 if ( cellRect
!= wxGridNoCellRect
)
9939 rect
= wxRect( 0, 0, 0, 0 );
9942 cellRect
= CellToRect( bottomRight
);
9943 if ( cellRect
!= wxGridNoCellRect
)
9949 return wxGridNoCellRect
;
9953 int left
= rect
.GetLeft();
9954 int top
= rect
.GetTop();
9955 int right
= rect
.GetRight();
9956 int bottom
= rect
.GetBottom();
9958 int leftCol
= topLeft
.GetCol();
9959 int topRow
= topLeft
.GetRow();
9960 int rightCol
= bottomRight
.GetCol();
9961 int bottomRow
= bottomRight
.GetRow();
9984 for ( j
= topRow
; j
<= bottomRow
; j
++ )
9986 for ( i
= leftCol
; i
<= rightCol
; i
++ )
9988 if ((j
==topRow
) || (j
==bottomRow
) || (i
==leftCol
) || (i
==rightCol
))
9990 cellRect
= CellToRect( j
, i
);
9992 if (cellRect
.x
< left
)
9994 if (cellRect
.y
< top
)
9996 if (cellRect
.x
+ cellRect
.width
> right
)
9997 right
= cellRect
.x
+ cellRect
.width
;
9998 if (cellRect
.y
+ cellRect
.height
> bottom
)
9999 bottom
= cellRect
.y
+ cellRect
.height
;
10001 else i
= rightCol
; // jump over inner cells.
10005 // convert to scrolled coords
10007 CalcScrolledPosition( left
, top
, &left
, &top
);
10008 CalcScrolledPosition( right
, bottom
, &right
, &bottom
);
10011 m_gridWin
->GetClientSize( &cw
, &ch
);
10013 if (right
< 0 || bottom
< 0 || left
> cw
|| top
> ch
)
10014 return wxRect( 0, 0, 0, 0);
10016 rect
.SetLeft( wxMax(0, left
) );
10017 rect
.SetTop( wxMax(0, top
) );
10018 rect
.SetRight( wxMin(cw
, right
) );
10019 rect
.SetBottom( wxMin(ch
, bottom
) );
10025 // ------ Grid event classes
10028 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent
, wxNotifyEvent
)
10030 wxGridEvent::wxGridEvent( int id
, wxEventType type
, wxObject
* obj
,
10031 int row
, int col
, int x
, int y
, bool sel
,
10032 bool control
, bool shift
, bool alt
, bool meta
)
10033 : wxNotifyEvent( type
, id
)
10040 m_control
= control
;
10045 SetEventObject(obj
);
10049 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent
, wxNotifyEvent
)
10051 wxGridSizeEvent::wxGridSizeEvent( int id
, wxEventType type
, wxObject
* obj
,
10052 int rowOrCol
, int x
, int y
,
10053 bool control
, bool shift
, bool alt
, bool meta
)
10054 : wxNotifyEvent( type
, id
)
10056 m_rowOrCol
= rowOrCol
;
10059 m_control
= control
;
10064 SetEventObject(obj
);
10068 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent
, wxNotifyEvent
)
10070 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id
, wxEventType type
, wxObject
* obj
,
10071 const wxGridCellCoords
& topLeft
,
10072 const wxGridCellCoords
& bottomRight
,
10073 bool sel
, bool control
,
10074 bool shift
, bool alt
, bool meta
)
10075 : wxNotifyEvent( type
, id
)
10077 m_topLeft
= topLeft
;
10078 m_bottomRight
= bottomRight
;
10080 m_control
= control
;
10085 SetEventObject(obj
);
10089 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent
, wxCommandEvent
)
10091 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id
, wxEventType type
,
10092 wxObject
* obj
, int row
,
10093 int col
, wxControl
* ctrl
)
10094 : wxCommandEvent(type
, id
)
10096 SetEventObject(obj
);
10102 #endif // wxUSE_GRID