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"
35 #if !defined(wxUSE_NEW_GRID) || !(wxUSE_NEW_GRID)
37 #else // wxUSE_NEW_GRID
41 #include "wx/dcclient.h"
42 #include "wx/settings.h"
44 #include "wx/textctrl.h"
45 #include "wx/checkbox.h"
46 #include "wx/combobox.h"
47 #include "wx/valtext.h"
50 #include "wx/textfile.h"
51 #include "wx/spinctrl.h"
52 #include "wx/tokenzr.h"
55 #include "wx/generic/gridsel.h"
57 #if defined(__WXMOTIF__)
58 #define WXUNUSED_MOTIF(identifier) WXUNUSED(identifier)
60 #define WXUNUSED_MOTIF(identifier) identifier
63 #if defined(__WXGTK__)
64 #define WXUNUSED_GTK(identifier) WXUNUSED(identifier)
66 #define WXUNUSED_GTK(identifier) identifier
69 // Required for wxIs... functions
72 // ----------------------------------------------------------------------------
74 // ----------------------------------------------------------------------------
76 WX_DEFINE_EXPORTED_ARRAY(wxGridCellAttr
*, wxArrayAttrs
);
78 struct wxGridCellWithAttr
80 wxGridCellWithAttr(int row
, int col
, wxGridCellAttr
*attr_
)
81 : coords(row
, col
), attr(attr_
)
90 wxGridCellCoords coords
;
94 // DECLARE_NO_COPY_CLASS(wxGridCellWithAttr)
95 // without rewriting the macros, which require a public copy constructor.
98 WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr
, wxGridCellWithAttrArray
);
100 #include "wx/arrimpl.cpp"
102 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray
)
103 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray
)
105 // ----------------------------------------------------------------------------
107 // ----------------------------------------------------------------------------
109 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK
)
110 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK
)
111 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK
)
112 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK
)
113 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK
)
114 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK
)
115 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK
)
116 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK
)
117 DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE
)
118 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE
)
119 DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT
)
120 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE
)
121 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL
)
122 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN
)
123 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN
)
124 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED
)
126 // ----------------------------------------------------------------------------
128 // ----------------------------------------------------------------------------
130 class WXDLLEXPORT wxGridRowLabelWindow
: public wxWindow
133 wxGridRowLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
134 wxGridRowLabelWindow( wxGrid
*parent
, wxWindowID id
,
135 const wxPoint
&pos
, const wxSize
&size
);
140 void OnPaint( wxPaintEvent
& event
);
141 void OnMouseEvent( wxMouseEvent
& event
);
142 void OnMouseWheel( wxMouseEvent
& event
);
143 void OnKeyDown( wxKeyEvent
& event
);
144 void OnKeyUp( wxKeyEvent
& );
146 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow
)
147 DECLARE_EVENT_TABLE()
148 DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow
)
152 class WXDLLEXPORT wxGridColLabelWindow
: public wxWindow
155 wxGridColLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
156 wxGridColLabelWindow( wxGrid
*parent
, wxWindowID id
,
157 const wxPoint
&pos
, const wxSize
&size
);
162 void OnPaint( wxPaintEvent
&event
);
163 void OnMouseEvent( wxMouseEvent
& event
);
164 void OnMouseWheel( wxMouseEvent
& event
);
165 void OnKeyDown( wxKeyEvent
& event
);
166 void OnKeyUp( wxKeyEvent
& );
168 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow
)
169 DECLARE_EVENT_TABLE()
170 DECLARE_NO_COPY_CLASS(wxGridColLabelWindow
)
174 class WXDLLEXPORT wxGridCornerLabelWindow
: public wxWindow
177 wxGridCornerLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
178 wxGridCornerLabelWindow( wxGrid
*parent
, wxWindowID id
,
179 const wxPoint
&pos
, const wxSize
&size
);
184 void OnMouseEvent( wxMouseEvent
& event
);
185 void OnMouseWheel( wxMouseEvent
& event
);
186 void OnKeyDown( wxKeyEvent
& event
);
187 void OnKeyUp( wxKeyEvent
& );
188 void OnPaint( wxPaintEvent
& event
);
190 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow
)
191 DECLARE_EVENT_TABLE()
192 DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow
)
195 class WXDLLEXPORT wxGridWindow
: public wxWindow
200 m_owner
= (wxGrid
*)NULL
;
201 m_rowLabelWin
= (wxGridRowLabelWindow
*)NULL
;
202 m_colLabelWin
= (wxGridColLabelWindow
*)NULL
;
205 wxGridWindow( wxGrid
*parent
,
206 wxGridRowLabelWindow
*rowLblWin
,
207 wxGridColLabelWindow
*colLblWin
,
208 wxWindowID id
, const wxPoint
&pos
, const wxSize
&size
);
211 void ScrollWindow( int dx
, int dy
, const wxRect
*rect
);
213 wxGrid
* GetOwner() { return m_owner
; }
217 wxGridRowLabelWindow
*m_rowLabelWin
;
218 wxGridColLabelWindow
*m_colLabelWin
;
220 void OnPaint( wxPaintEvent
&event
);
221 void OnMouseWheel( wxMouseEvent
& event
);
222 void OnMouseEvent( wxMouseEvent
& event
);
223 void OnKeyDown( wxKeyEvent
& );
224 void OnKeyUp( wxKeyEvent
& );
225 void OnEraseBackground( wxEraseEvent
& );
228 DECLARE_DYNAMIC_CLASS(wxGridWindow
)
229 DECLARE_EVENT_TABLE()
230 DECLARE_NO_COPY_CLASS(wxGridWindow
)
235 class wxGridCellEditorEvtHandler
: public wxEvtHandler
238 wxGridCellEditorEvtHandler()
239 : m_grid(0), m_editor(0)
241 wxGridCellEditorEvtHandler(wxGrid
* grid
, wxGridCellEditor
* editor
)
242 : m_grid(grid
), m_editor(editor
)
245 void OnKeyDown(wxKeyEvent
& event
);
246 void OnChar(wxKeyEvent
& event
);
250 wxGridCellEditor
* m_editor
;
251 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler
)
252 DECLARE_EVENT_TABLE()
253 DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler
)
257 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler
, wxEvtHandler
)
258 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler
, wxEvtHandler
)
259 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown
)
260 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar
)
265 // ----------------------------------------------------------------------------
266 // the internal data representation used by wxGridCellAttrProvider
267 // ----------------------------------------------------------------------------
269 // this class stores attributes set for cells
270 class WXDLLEXPORT wxGridCellAttrData
273 void SetAttr(wxGridCellAttr
*attr
, int row
, int col
);
274 wxGridCellAttr
*GetAttr(int row
, int col
) const;
275 void UpdateAttrRows( size_t pos
, int numRows
);
276 void UpdateAttrCols( size_t pos
, int numCols
);
279 // searches for the attr for given cell, returns wxNOT_FOUND if not found
280 int FindIndex(int row
, int col
) const;
282 wxGridCellWithAttrArray m_attrs
;
285 // this class stores attributes set for rows or columns
286 class WXDLLEXPORT wxGridRowOrColAttrData
289 // empty ctor to suppress warnings
290 wxGridRowOrColAttrData() { }
291 ~wxGridRowOrColAttrData();
293 void SetAttr(wxGridCellAttr
*attr
, int rowOrCol
);
294 wxGridCellAttr
*GetAttr(int rowOrCol
) const;
295 void UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
);
298 wxArrayInt m_rowsOrCols
;
299 wxArrayAttrs m_attrs
;
302 // NB: this is just a wrapper around 3 objects: one which stores cell
303 // attributes, and 2 others for row/col ones
304 class WXDLLEXPORT wxGridCellAttrProviderData
307 wxGridCellAttrData m_cellAttrs
;
308 wxGridRowOrColAttrData m_rowAttrs
,
313 // ----------------------------------------------------------------------------
314 // data structures used for the data type registry
315 // ----------------------------------------------------------------------------
317 struct wxGridDataTypeInfo
319 wxGridDataTypeInfo(const wxString
& typeName
,
320 wxGridCellRenderer
* renderer
,
321 wxGridCellEditor
* editor
)
322 : m_typeName(typeName
), m_renderer(renderer
), m_editor(editor
)
325 ~wxGridDataTypeInfo()
327 wxSafeDecRef(m_renderer
);
328 wxSafeDecRef(m_editor
);
332 wxGridCellRenderer
* m_renderer
;
333 wxGridCellEditor
* m_editor
;
335 DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo
)
339 WX_DEFINE_EXPORTED_ARRAY(wxGridDataTypeInfo
*, wxGridDataTypeInfoArray
);
342 class WXDLLEXPORT wxGridTypeRegistry
345 wxGridTypeRegistry() {}
346 ~wxGridTypeRegistry();
348 void RegisterDataType(const wxString
& typeName
,
349 wxGridCellRenderer
* renderer
,
350 wxGridCellEditor
* editor
);
352 // find one of already registered data types
353 int FindRegisteredDataType(const wxString
& typeName
);
355 // try to FindRegisteredDataType(), if this fails and typeName is one of
356 // standard typenames, register it and return its index
357 int FindDataType(const wxString
& typeName
);
359 // try to FindDataType(), if it fails see if it is not one of already
360 // registered data types with some params in which case clone the
361 // registered data type and set params for it
362 int FindOrCloneDataType(const wxString
& typeName
);
364 wxGridCellRenderer
* GetRenderer(int index
);
365 wxGridCellEditor
* GetEditor(int index
);
368 wxGridDataTypeInfoArray m_typeinfo
;
371 // ----------------------------------------------------------------------------
372 // conditional compilation
373 // ----------------------------------------------------------------------------
375 #ifndef WXGRID_DRAW_LINES
376 #define WXGRID_DRAW_LINES 1
379 // ----------------------------------------------------------------------------
381 // ----------------------------------------------------------------------------
383 //#define DEBUG_ATTR_CACHE
384 #ifdef DEBUG_ATTR_CACHE
385 static size_t gs_nAttrCacheHits
= 0;
386 static size_t gs_nAttrCacheMisses
= 0;
387 #endif // DEBUG_ATTR_CACHE
389 // ----------------------------------------------------------------------------
391 // ----------------------------------------------------------------------------
393 wxGridCellCoords
wxGridNoCellCoords( -1, -1 );
394 wxRect
wxGridNoCellRect( -1, -1, -1, -1 );
397 // TODO: this doesn't work at all, grid cells have different sizes and approx
398 // calculations don't work as because of the size mismatch scrollbars
399 // sometimes fail to be shown when they should be or vice versa
401 // The scroll bars may be a little flakey once in a while, but that is
402 // surely much less horrible than having scroll lines of only 1!!!
405 // Well, it's still seriously broken so it might be better but needs
408 static const size_t GRID_SCROLL_LINE_X
= 15; // 1;
409 static const size_t GRID_SCROLL_LINE_Y
= GRID_SCROLL_LINE_X
;
411 // the size of hash tables used a bit everywhere (the max number of elements
412 // in these hash tables is the number of rows/columns)
413 static const int GRID_HASH_SIZE
= 100;
415 // ----------------------------------------------------------------------------
417 // ----------------------------------------------------------------------------
419 static inline int GetScrollX(int x
)
421 return (x
+ GRID_SCROLL_LINE_X
- 1) / GRID_SCROLL_LINE_X
;
424 static inline int GetScrollY(int y
)
426 return (y
+ GRID_SCROLL_LINE_Y
- 1) / GRID_SCROLL_LINE_Y
;
429 // ============================================================================
431 // ============================================================================
433 // ----------------------------------------------------------------------------
435 // ----------------------------------------------------------------------------
437 wxGridCellEditor::wxGridCellEditor()
444 wxGridCellEditor::~wxGridCellEditor()
449 void wxGridCellEditor::Create(wxWindow
* WXUNUSED(parent
),
450 wxWindowID
WXUNUSED(id
),
451 wxEvtHandler
* evtHandler
)
454 m_control
->PushEventHandler(evtHandler
);
457 void wxGridCellEditor::PaintBackground(const wxRect
& rectCell
,
458 wxGridCellAttr
*attr
)
460 // erase the background because we might not fill the cell
461 wxClientDC
dc(m_control
->GetParent());
462 wxGridWindow
* gridWindow
= wxDynamicCast(m_control
->GetParent(), wxGridWindow
);
464 gridWindow
->GetOwner()->PrepareDC(dc
);
466 dc
.SetPen(*wxTRANSPARENT_PEN
);
467 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
468 dc
.DrawRectangle(rectCell
);
470 // redraw the control we just painted over
471 m_control
->Refresh();
474 void wxGridCellEditor::Destroy()
478 m_control
->PopEventHandler(TRUE
/* delete it*/);
480 m_control
->Destroy();
485 void wxGridCellEditor::Show(bool show
, wxGridCellAttr
*attr
)
487 wxASSERT_MSG(m_control
,
488 wxT("The wxGridCellEditor must be Created first!"));
489 m_control
->Show(show
);
493 // set the colours/fonts if we have any
496 m_colFgOld
= m_control
->GetForegroundColour();
497 m_control
->SetForegroundColour(attr
->GetTextColour());
499 m_colBgOld
= m_control
->GetBackgroundColour();
500 m_control
->SetBackgroundColour(attr
->GetBackgroundColour());
502 m_fontOld
= m_control
->GetFont();
503 m_control
->SetFont(attr
->GetFont());
505 // can't do anything more in the base class version, the other
506 // attributes may only be used by the derived classes
511 // restore the standard colours fonts
512 if ( m_colFgOld
.Ok() )
514 m_control
->SetForegroundColour(m_colFgOld
);
515 m_colFgOld
= wxNullColour
;
518 if ( m_colBgOld
.Ok() )
520 m_control
->SetBackgroundColour(m_colBgOld
);
521 m_colBgOld
= wxNullColour
;
524 if ( m_fontOld
.Ok() )
526 m_control
->SetFont(m_fontOld
);
527 m_fontOld
= wxNullFont
;
532 void wxGridCellEditor::SetSize(const wxRect
& rect
)
534 wxASSERT_MSG(m_control
,
535 wxT("The wxGridCellEditor must be Created first!"));
536 m_control
->SetSize(rect
, wxSIZE_ALLOW_MINUS_ONE
);
539 void wxGridCellEditor::HandleReturn(wxKeyEvent
& event
)
544 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent
& event
)
546 // accept the simple key presses, not anything with Ctrl/Alt/Meta
547 return !(event
.ControlDown() || event
.AltDown());
550 void wxGridCellEditor::StartingKey(wxKeyEvent
& event
)
555 void wxGridCellEditor::StartingClick()
561 // ----------------------------------------------------------------------------
562 // wxGridCellTextEditor
563 // ----------------------------------------------------------------------------
565 wxGridCellTextEditor::wxGridCellTextEditor()
570 void wxGridCellTextEditor::Create(wxWindow
* parent
,
572 wxEvtHandler
* evtHandler
)
574 m_control
= new wxTextCtrl(parent
, id
, wxEmptyString
,
575 wxDefaultPosition
, wxDefaultSize
576 #if defined(__WXMSW__)
577 , wxTE_PROCESS_TAB
| wxTE_MULTILINE
|
578 wxTE_NO_VSCROLL
| wxTE_AUTO_SCROLL
582 // TODO: use 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) && (isprint(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) && isdigit(keycode
) )
922 void wxGridCellNumberEditor::StartingKey(wxKeyEvent
& event
)
926 int keycode
= event
.GetKeyCode();
927 if ( isdigit(keycode
) || keycode
== '+' || keycode
== '-'
928 || keycode
== WXK_NUMPAD0
929 || keycode
== WXK_NUMPAD1
930 || keycode
== WXK_NUMPAD2
931 || keycode
== WXK_NUMPAD3
932 || keycode
== WXK_NUMPAD4
933 || keycode
== WXK_NUMPAD5
934 || keycode
== WXK_NUMPAD6
935 || keycode
== WXK_NUMPAD7
936 || keycode
== WXK_NUMPAD8
937 || keycode
== WXK_NUMPAD9
938 || keycode
== WXK_ADD
939 || keycode
== WXK_NUMPAD_ADD
940 || keycode
== WXK_SUBTRACT
941 || keycode
== WXK_NUMPAD_SUBTRACT
)
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 ( isdigit(keycode
) || keycode
== '+' || keycode
== '-' || keycode
== '.'
1068 || keycode
== WXK_NUMPAD0
1069 || keycode
== WXK_NUMPAD1
1070 || keycode
== WXK_NUMPAD2
1071 || keycode
== WXK_NUMPAD3
1072 || keycode
== WXK_NUMPAD4
1073 || keycode
== WXK_NUMPAD5
1074 || keycode
== WXK_NUMPAD6
1075 || keycode
== WXK_NUMPAD7
1076 || keycode
== WXK_NUMPAD8
1077 || keycode
== WXK_NUMPAD9
1078 || keycode
== WXK_ADD
1079 || keycode
== WXK_NUMPAD_ADD
1080 || keycode
== WXK_SUBTRACT
1081 || keycode
== WXK_NUMPAD_SUBTRACT
)
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 (isdigit(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;
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 SetDefAttr(mergefrom
->m_defGridAttr
);
2143 void wxGridCellAttr::SetSize(int num_rows
, int num_cols
)
2145 // The size of a cell is normally 1,1
2147 // If this cell is larger (2,2) then this is the top left cell
2148 // the other cells that will be covered (lower right cells) must be
2149 // set to negative or zero values such that
2150 // row + num_rows of the covered cell points to the larger cell (this cell)
2151 // same goes for the col + num_cols.
2153 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
2155 wxASSERT_MSG( (!((num_rows
>0)&&(num_cols
<=0)) ||
2156 !((num_rows
<=0)&&(num_cols
>0)) ||
2157 !((num_rows
==0)&&(num_cols
==0))),
2158 wxT("wxGridCellAttr::SetSize only takes two postive values or negative/zero values"));
2160 m_sizeRows
= num_rows
;
2161 m_sizeCols
= num_cols
;
2164 const wxColour
& wxGridCellAttr::GetTextColour() const
2166 if (HasTextColour())
2170 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2172 return m_defGridAttr
->GetTextColour();
2176 wxFAIL_MSG(wxT("Missing default cell attribute"));
2177 return wxNullColour
;
2182 const wxColour
& wxGridCellAttr::GetBackgroundColour() const
2184 if (HasBackgroundColour())
2186 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2187 return m_defGridAttr
->GetBackgroundColour();
2190 wxFAIL_MSG(wxT("Missing default cell attribute"));
2191 return wxNullColour
;
2196 const wxFont
& wxGridCellAttr::GetFont() const
2200 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2201 return m_defGridAttr
->GetFont();
2204 wxFAIL_MSG(wxT("Missing default cell attribute"));
2210 void wxGridCellAttr::GetAlignment(int *hAlign
, int *vAlign
) const
2214 if ( hAlign
) *hAlign
= m_hAlign
;
2215 if ( vAlign
) *vAlign
= m_vAlign
;
2217 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2218 m_defGridAttr
->GetAlignment(hAlign
, vAlign
);
2221 wxFAIL_MSG(wxT("Missing default cell attribute"));
2225 void wxGridCellAttr::GetSize( int *num_rows
, int *num_cols
) const
2227 if ( num_rows
) *num_rows
= m_sizeRows
;
2228 if ( num_cols
) *num_cols
= m_sizeCols
;
2231 // GetRenderer and GetEditor use a slightly different decision path about
2232 // which attribute to use. If a non-default attr object has one then it is
2233 // used, otherwise the default editor or renderer is fetched from the grid and
2234 // used. It should be the default for the data type of the cell. If it is
2235 // NULL (because the table has a type that the grid does not have in its
2236 // registry,) then the grid's default editor or renderer is used.
2238 wxGridCellRenderer
* wxGridCellAttr::GetRenderer(wxGrid
* grid
, int row
, int col
) const
2240 wxGridCellRenderer
*renderer
;
2242 if ( m_renderer
&& this != m_defGridAttr
)
2244 // use the cells renderer if it has one
2245 renderer
= m_renderer
;
2248 else // no non default cell renderer
2250 // get default renderer for the data type
2253 // GetDefaultRendererForCell() will do IncRef() for us
2254 renderer
= grid
->GetDefaultRendererForCell(row
, col
);
2263 if (m_defGridAttr
&& this != m_defGridAttr
)
2265 // if we still don't have one then use the grid default
2266 // (no need for IncRef() here neither)
2267 renderer
= m_defGridAttr
->GetRenderer(NULL
, 0, 0);
2269 else // default grid attr
2271 // use m_renderer which we had decided not to use initially
2272 renderer
= m_renderer
;
2279 // we're supposed to always find something
2280 wxASSERT_MSG(renderer
, wxT("Missing default cell renderer"));
2285 // same as above, except for s/renderer/editor/g
2286 wxGridCellEditor
* wxGridCellAttr::GetEditor(wxGrid
* grid
, int row
, int col
) const
2288 wxGridCellEditor
*editor
;
2290 if ( m_editor
&& this != m_defGridAttr
)
2292 // use the cells editor if it has one
2296 else // no non default cell editor
2298 // get default editor for the data type
2301 // GetDefaultEditorForCell() will do IncRef() for us
2302 editor
= grid
->GetDefaultEditorForCell(row
, col
);
2311 if ( m_defGridAttr
&& this != m_defGridAttr
)
2313 // if we still don't have one then use the grid default
2314 // (no need for IncRef() here neither)
2315 editor
= m_defGridAttr
->GetEditor(NULL
, 0, 0);
2317 else // default grid attr
2319 // use m_editor which we had decided not to use initially
2327 // we're supposed to always find something
2328 wxASSERT_MSG(editor
, wxT("Missing default cell editor"));
2333 // ----------------------------------------------------------------------------
2334 // wxGridCellAttrData
2335 // ----------------------------------------------------------------------------
2337 void wxGridCellAttrData::SetAttr(wxGridCellAttr
*attr
, int row
, int col
)
2339 int n
= FindIndex(row
, col
);
2340 if ( n
== wxNOT_FOUND
)
2342 // add the attribute
2343 m_attrs
.Add(new wxGridCellWithAttr(row
, col
, attr
));
2347 // free the old attribute
2348 m_attrs
[(size_t)n
].attr
->DecRef();
2352 // change the attribute
2353 m_attrs
[(size_t)n
].attr
= attr
;
2357 // remove this attribute
2358 m_attrs
.RemoveAt((size_t)n
);
2363 wxGridCellAttr
*wxGridCellAttrData::GetAttr(int row
, int col
) const
2365 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2367 int n
= FindIndex(row
, col
);
2368 if ( n
!= wxNOT_FOUND
)
2370 attr
= m_attrs
[(size_t)n
].attr
;
2377 void wxGridCellAttrData::UpdateAttrRows( size_t pos
, int numRows
)
2379 size_t count
= m_attrs
.GetCount();
2380 for ( size_t n
= 0; n
< count
; n
++ )
2382 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2383 wxCoord row
= coords
.GetRow();
2384 if ((size_t)row
>= pos
)
2388 // If rows inserted, include row counter where necessary
2389 coords
.SetRow(row
+ numRows
);
2391 else if (numRows
< 0)
2393 // If rows deleted ...
2394 if ((size_t)row
>= pos
- numRows
)
2396 // ...either decrement row counter (if row still exists)...
2397 coords
.SetRow(row
+ numRows
);
2401 // ...or remove the attribute
2402 m_attrs
.RemoveAt((size_t)n
);
2410 void wxGridCellAttrData::UpdateAttrCols( size_t pos
, int numCols
)
2412 size_t count
= m_attrs
.GetCount();
2413 for ( size_t n
= 0; n
< count
; n
++ )
2415 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2416 wxCoord col
= coords
.GetCol();
2417 if ( (size_t)col
>= pos
)
2421 // If rows inserted, include row counter where necessary
2422 coords
.SetCol(col
+ numCols
);
2424 else if (numCols
< 0)
2426 // If rows deleted ...
2427 if ((size_t)col
>= pos
- numCols
)
2429 // ...either decrement row counter (if row still exists)...
2430 coords
.SetCol(col
+ numCols
);
2434 // ...or remove the attribute
2435 m_attrs
.RemoveAt((size_t)n
);
2443 int wxGridCellAttrData::FindIndex(int row
, int col
) const
2445 size_t count
= m_attrs
.GetCount();
2446 for ( size_t n
= 0; n
< count
; n
++ )
2448 const wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2449 if ( (coords
.GetRow() == row
) && (coords
.GetCol() == col
) )
2458 // ----------------------------------------------------------------------------
2459 // wxGridRowOrColAttrData
2460 // ----------------------------------------------------------------------------
2462 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2464 size_t count
= m_attrs
.Count();
2465 for ( size_t n
= 0; n
< count
; n
++ )
2467 m_attrs
[n
]->DecRef();
2471 wxGridCellAttr
*wxGridRowOrColAttrData::GetAttr(int rowOrCol
) const
2473 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2475 int n
= m_rowsOrCols
.Index(rowOrCol
);
2476 if ( n
!= wxNOT_FOUND
)
2478 attr
= m_attrs
[(size_t)n
];
2485 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr
*attr
, int rowOrCol
)
2487 int i
= m_rowsOrCols
.Index(rowOrCol
);
2488 if ( i
== wxNOT_FOUND
)
2490 // add the attribute
2491 m_rowsOrCols
.Add(rowOrCol
);
2496 size_t n
= (size_t)i
;
2499 // change the attribute
2500 m_attrs
[n
]->DecRef();
2505 // remove this attribute
2506 m_attrs
[n
]->DecRef();
2507 m_rowsOrCols
.RemoveAt(n
);
2508 m_attrs
.RemoveAt(n
);
2513 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
)
2515 size_t count
= m_attrs
.GetCount();
2516 for ( size_t n
= 0; n
< count
; n
++ )
2518 int & rowOrCol
= m_rowsOrCols
[n
];
2519 if ( (size_t)rowOrCol
>= pos
)
2521 if ( numRowsOrCols
> 0 )
2523 // If rows inserted, include row counter where necessary
2524 rowOrCol
+= numRowsOrCols
;
2526 else if ( numRowsOrCols
< 0)
2528 // If rows deleted, either decrement row counter (if row still exists)
2529 if ((size_t)rowOrCol
>= pos
- numRowsOrCols
)
2530 rowOrCol
+= numRowsOrCols
;
2533 m_rowsOrCols
.RemoveAt((size_t)n
);
2534 m_attrs
.RemoveAt((size_t)n
);
2542 // ----------------------------------------------------------------------------
2543 // wxGridCellAttrProvider
2544 // ----------------------------------------------------------------------------
2546 wxGridCellAttrProvider::wxGridCellAttrProvider()
2548 m_data
= (wxGridCellAttrProviderData
*)NULL
;
2551 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2556 void wxGridCellAttrProvider::InitData()
2558 m_data
= new wxGridCellAttrProviderData
;
2561 wxGridCellAttr
*wxGridCellAttrProvider::GetAttr(int row
, int col
,
2562 wxGridCellAttr::wxAttrKind kind
) const
2564 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2569 case (wxGridCellAttr::Any
):
2570 //Get cached merge attributes.
2571 // Currenlty not used as no cache implemented as not mutiable
2572 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2575 //Basicaly implement old version.
2576 //Also check merge cache, so we don't have to re-merge every time..
2577 wxGridCellAttr
*attrcell
= (wxGridCellAttr
*)NULL
,
2578 *attrrow
= (wxGridCellAttr
*)NULL
,
2579 *attrcol
= (wxGridCellAttr
*)NULL
;
2581 attrcell
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2582 attrcol
= m_data
->m_colAttrs
.GetAttr(col
);
2583 attrrow
= m_data
->m_rowAttrs
.GetAttr(row
);
2585 if((attrcell
!= attrrow
) && (attrrow
!=attrcol
) && (attrcell
!= attrcol
)){
2586 // Two or move are non NULL
2587 attr
= new wxGridCellAttr
;
2588 attr
->SetKind(wxGridCellAttr::Merged
);
2592 attr
->MergeWith(attrcell
);
2596 attr
->MergeWith(attrcol
);
2600 attr
->MergeWith(attrrow
);
2603 //store merge attr if cache implemented
2605 //m_data->m_mergeAttr.SetAttr(attr, row, col);
2609 // one or none is non null return it or null.
2610 if(attrrow
) attr
= attrrow
;
2611 if(attrcol
) attr
= attrcol
;
2612 if(attrcell
) attr
= attrcell
;
2616 case (wxGridCellAttr::Cell
):
2617 attr
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2619 case (wxGridCellAttr::Col
):
2620 attr
= m_data
->m_colAttrs
.GetAttr(col
);
2622 case (wxGridCellAttr::Row
):
2623 attr
= m_data
->m_rowAttrs
.GetAttr(row
);
2627 // (wxGridCellAttr::Default):
2628 // (wxGridCellAttr::Merged):
2635 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr
*attr
,
2641 m_data
->m_cellAttrs
.SetAttr(attr
, row
, col
);
2644 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2649 m_data
->m_rowAttrs
.SetAttr(attr
, row
);
2652 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr
*attr
, int col
)
2657 m_data
->m_colAttrs
.SetAttr(attr
, col
);
2660 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos
, int numRows
)
2664 m_data
->m_cellAttrs
.UpdateAttrRows( pos
, numRows
);
2666 m_data
->m_rowAttrs
.UpdateAttrRowsOrCols( pos
, numRows
);
2670 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos
, int numCols
)
2674 m_data
->m_cellAttrs
.UpdateAttrCols( pos
, numCols
);
2676 m_data
->m_colAttrs
.UpdateAttrRowsOrCols( pos
, numCols
);
2680 // ----------------------------------------------------------------------------
2681 // wxGridTypeRegistry
2682 // ----------------------------------------------------------------------------
2684 wxGridTypeRegistry::~wxGridTypeRegistry()
2686 size_t count
= m_typeinfo
.Count();
2687 for ( size_t i
= 0; i
< count
; i
++ )
2688 delete m_typeinfo
[i
];
2692 void wxGridTypeRegistry::RegisterDataType(const wxString
& typeName
,
2693 wxGridCellRenderer
* renderer
,
2694 wxGridCellEditor
* editor
)
2696 wxGridDataTypeInfo
* info
= new wxGridDataTypeInfo(typeName
, renderer
, editor
);
2698 // is it already registered?
2699 int loc
= FindRegisteredDataType(typeName
);
2700 if ( loc
!= wxNOT_FOUND
)
2702 delete m_typeinfo
[loc
];
2703 m_typeinfo
[loc
] = info
;
2707 m_typeinfo
.Add(info
);
2711 int wxGridTypeRegistry::FindRegisteredDataType(const wxString
& typeName
)
2713 size_t count
= m_typeinfo
.GetCount();
2714 for ( size_t i
= 0; i
< count
; i
++ )
2716 if ( typeName
== m_typeinfo
[i
]->m_typeName
)
2725 int wxGridTypeRegistry::FindDataType(const wxString
& typeName
)
2727 int index
= FindRegisteredDataType(typeName
);
2728 if ( index
== wxNOT_FOUND
)
2730 // check whether this is one of the standard ones, in which case
2731 // register it "on the fly"
2733 if ( typeName
== wxGRID_VALUE_STRING
)
2735 RegisterDataType(wxGRID_VALUE_STRING
,
2736 new wxGridCellStringRenderer
,
2737 new wxGridCellTextEditor
);
2739 #endif // wxUSE_TEXTCTRL
2741 if ( typeName
== wxGRID_VALUE_BOOL
)
2743 RegisterDataType(wxGRID_VALUE_BOOL
,
2744 new wxGridCellBoolRenderer
,
2745 new wxGridCellBoolEditor
);
2747 #endif // wxUSE_CHECKBOX
2749 if ( typeName
== wxGRID_VALUE_NUMBER
)
2751 RegisterDataType(wxGRID_VALUE_NUMBER
,
2752 new wxGridCellNumberRenderer
,
2753 new wxGridCellNumberEditor
);
2755 else if ( typeName
== wxGRID_VALUE_FLOAT
)
2757 RegisterDataType(wxGRID_VALUE_FLOAT
,
2758 new wxGridCellFloatRenderer
,
2759 new wxGridCellFloatEditor
);
2761 #endif // wxUSE_TEXTCTRL
2763 if ( typeName
== wxGRID_VALUE_CHOICE
)
2765 RegisterDataType(wxGRID_VALUE_CHOICE
,
2766 new wxGridCellStringRenderer
,
2767 new wxGridCellChoiceEditor
);
2769 #endif // wxUSE_COMBOBOX
2774 // we get here only if just added the entry for this type, so return
2776 index
= m_typeinfo
.GetCount() - 1;
2782 int wxGridTypeRegistry::FindOrCloneDataType(const wxString
& typeName
)
2784 int index
= FindDataType(typeName
);
2785 if ( index
== wxNOT_FOUND
)
2787 // the first part of the typename is the "real" type, anything after ':'
2788 // are the parameters for the renderer
2789 index
= FindDataType(typeName
.BeforeFirst(_T(':')));
2790 if ( index
== wxNOT_FOUND
)
2795 wxGridCellRenderer
*renderer
= GetRenderer(index
);
2796 wxGridCellRenderer
*rendererOld
= renderer
;
2797 renderer
= renderer
->Clone();
2798 rendererOld
->DecRef();
2800 wxGridCellEditor
*editor
= GetEditor(index
);
2801 wxGridCellEditor
*editorOld
= editor
;
2802 editor
= editor
->Clone();
2803 editorOld
->DecRef();
2805 // do it even if there are no parameters to reset them to defaults
2806 wxString params
= typeName
.AfterFirst(_T(':'));
2807 renderer
->SetParameters(params
);
2808 editor
->SetParameters(params
);
2810 // register the new typename
2811 RegisterDataType(typeName
, renderer
, editor
);
2813 // we just registered it, it's the last one
2814 index
= m_typeinfo
.GetCount() - 1;
2820 wxGridCellRenderer
* wxGridTypeRegistry::GetRenderer(int index
)
2822 wxGridCellRenderer
* renderer
= m_typeinfo
[index
]->m_renderer
;
2828 wxGridCellEditor
* wxGridTypeRegistry::GetEditor(int index
)
2830 wxGridCellEditor
* editor
= m_typeinfo
[index
]->m_editor
;
2836 // ----------------------------------------------------------------------------
2838 // ----------------------------------------------------------------------------
2840 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase
, wxObject
)
2843 wxGridTableBase::wxGridTableBase()
2845 m_view
= (wxGrid
*) NULL
;
2846 m_attrProvider
= (wxGridCellAttrProvider
*) NULL
;
2849 wxGridTableBase::~wxGridTableBase()
2851 delete m_attrProvider
;
2854 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider
*attrProvider
)
2856 delete m_attrProvider
;
2857 m_attrProvider
= attrProvider
;
2860 bool wxGridTableBase::CanHaveAttributes()
2862 if ( ! GetAttrProvider() )
2864 // use the default attr provider by default
2865 SetAttrProvider(new wxGridCellAttrProvider
);
2870 wxGridCellAttr
*wxGridTableBase::GetAttr(int row
, int col
, wxGridCellAttr::wxAttrKind kind
)
2872 if ( m_attrProvider
)
2873 return m_attrProvider
->GetAttr(row
, col
, kind
);
2875 return (wxGridCellAttr
*)NULL
;
2878 void wxGridTableBase::SetAttr(wxGridCellAttr
* attr
, int row
, int col
)
2880 if ( m_attrProvider
)
2882 attr
->SetKind(wxGridCellAttr::Cell
);
2883 m_attrProvider
->SetAttr(attr
, row
, col
);
2887 // as we take ownership of the pointer and don't store it, we must
2893 void wxGridTableBase::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2895 if ( m_attrProvider
)
2897 attr
->SetKind(wxGridCellAttr::Row
);
2898 m_attrProvider
->SetRowAttr(attr
, row
);
2902 // as we take ownership of the pointer and don't store it, we must
2908 void wxGridTableBase::SetColAttr(wxGridCellAttr
*attr
, int col
)
2910 if ( m_attrProvider
)
2912 attr
->SetKind(wxGridCellAttr::Col
);
2913 m_attrProvider
->SetColAttr(attr
, col
);
2917 // as we take ownership of the pointer and don't store it, we must
2923 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos
),
2924 size_t WXUNUSED(numRows
) )
2926 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2931 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows
) )
2933 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2938 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos
),
2939 size_t WXUNUSED(numRows
) )
2941 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2946 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos
),
2947 size_t WXUNUSED(numCols
) )
2949 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2954 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols
) )
2956 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
2961 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos
),
2962 size_t WXUNUSED(numCols
) )
2964 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
2970 wxString
wxGridTableBase::GetRowLabelValue( int row
)
2973 s
<< row
+ 1; // RD: Starting the rows at zero confuses users, no matter
2974 // how much it makes sense to us geeks.
2978 wxString
wxGridTableBase::GetColLabelValue( int col
)
2980 // default col labels are:
2981 // cols 0 to 25 : A-Z
2982 // cols 26 to 675 : AA-ZZ
2987 for ( n
= 1; ; n
++ )
2989 s
+= (_T('A') + (wxChar
)( col%26
));
2991 if ( col
< 0 ) break;
2994 // reverse the string...
2996 for ( i
= 0; i
< n
; i
++ )
3005 wxString
wxGridTableBase::GetTypeName( int WXUNUSED(row
), int WXUNUSED(col
) )
3007 return wxGRID_VALUE_STRING
;
3010 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row
), int WXUNUSED(col
),
3011 const wxString
& typeName
)
3013 return typeName
== wxGRID_VALUE_STRING
;
3016 bool wxGridTableBase::CanSetValueAs( int row
, int col
, const wxString
& typeName
)
3018 return CanGetValueAs(row
, col
, typeName
);
3021 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
) )
3026 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
) )
3031 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
) )
3036 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
),
3037 long WXUNUSED(value
) )
3041 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
),
3042 double WXUNUSED(value
) )
3046 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
),
3047 bool WXUNUSED(value
) )
3052 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3053 const wxString
& WXUNUSED(typeName
) )
3058 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3059 const wxString
& WXUNUSED(typeName
),
3060 void* WXUNUSED(value
) )
3064 //////////////////////////////////////////////////////////////////////
3066 // Message class for the grid table to send requests and notifications
3070 wxGridTableMessage::wxGridTableMessage()
3072 m_table
= (wxGridTableBase
*) NULL
;
3078 wxGridTableMessage::wxGridTableMessage( wxGridTableBase
*table
, int id
,
3079 int commandInt1
, int commandInt2
)
3083 m_comInt1
= commandInt1
;
3084 m_comInt2
= commandInt2
;
3089 //////////////////////////////////////////////////////////////////////
3091 // A basic grid table for string data. An object of this class will
3092 // created by wxGrid if you don't specify an alternative table class.
3095 WX_DEFINE_OBJARRAY(wxGridStringArray
)
3097 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable
, wxGridTableBase
)
3099 wxGridStringTable::wxGridStringTable()
3104 wxGridStringTable::wxGridStringTable( int numRows
, int numCols
)
3107 m_data
.Alloc( numRows
);
3110 sa
.Alloc( numCols
);
3111 sa
.Add( wxEmptyString
, numCols
);
3113 m_data
.Add( sa
, numRows
);
3116 wxGridStringTable::~wxGridStringTable()
3120 int wxGridStringTable::GetNumberRows()
3122 return m_data
.GetCount();
3125 int wxGridStringTable::GetNumberCols()
3127 if ( m_data
.GetCount() > 0 )
3128 return m_data
[0].GetCount();
3133 wxString
wxGridStringTable::GetValue( int row
, int col
)
3135 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3136 _T("invalid row or column index in wxGridStringTable") );
3138 return m_data
[row
][col
];
3141 void wxGridStringTable::SetValue( int row
, int col
, const wxString
& value
)
3143 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3144 _T("invalid row or column index in wxGridStringTable") );
3146 m_data
[row
][col
] = value
;
3149 bool wxGridStringTable::IsEmptyCell( int row
, int col
)
3151 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3152 _T("invalid row or column index in wxGridStringTable") );
3154 return (m_data
[row
][col
] == wxEmptyString
);
3157 void wxGridStringTable::Clear()
3160 int numRows
, numCols
;
3162 numRows
= m_data
.GetCount();
3165 numCols
= m_data
[0].GetCount();
3167 for ( row
= 0; row
< numRows
; row
++ )
3169 for ( col
= 0; col
< numCols
; col
++ )
3171 m_data
[row
][col
] = wxEmptyString
;
3178 bool wxGridStringTable::InsertRows( size_t pos
, size_t numRows
)
3180 size_t curNumRows
= m_data
.GetCount();
3181 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3182 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3184 if ( pos
>= curNumRows
)
3186 return AppendRows( numRows
);
3190 sa
.Alloc( curNumCols
);
3191 sa
.Add( wxEmptyString
, curNumCols
);
3192 m_data
.Insert( sa
, pos
, numRows
);
3195 wxGridTableMessage
msg( this,
3196 wxGRIDTABLE_NOTIFY_ROWS_INSERTED
,
3200 GetView()->ProcessTableMessage( msg
);
3206 bool wxGridStringTable::AppendRows( size_t numRows
)
3208 size_t curNumRows
= m_data
.GetCount();
3209 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3210 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3213 if ( curNumCols
> 0 )
3215 sa
.Alloc( curNumCols
);
3216 sa
.Add( wxEmptyString
, curNumCols
);
3219 m_data
.Add( sa
, numRows
);
3223 wxGridTableMessage
msg( this,
3224 wxGRIDTABLE_NOTIFY_ROWS_APPENDED
,
3227 GetView()->ProcessTableMessage( msg
);
3233 bool wxGridStringTable::DeleteRows( size_t pos
, size_t numRows
)
3235 size_t curNumRows
= m_data
.GetCount();
3237 if ( pos
>= curNumRows
)
3239 wxFAIL_MSG( wxString::Format
3241 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
3243 (unsigned long)numRows
,
3244 (unsigned long)curNumRows
3250 if ( numRows
> curNumRows
- pos
)
3252 numRows
= curNumRows
- pos
;
3255 if ( numRows
>= curNumRows
)
3261 m_data
.RemoveAt( pos
, numRows
);
3265 wxGridTableMessage
msg( this,
3266 wxGRIDTABLE_NOTIFY_ROWS_DELETED
,
3270 GetView()->ProcessTableMessage( msg
);
3276 bool wxGridStringTable::InsertCols( size_t pos
, size_t numCols
)
3280 size_t curNumRows
= m_data
.GetCount();
3281 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3282 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3284 if ( pos
>= curNumCols
)
3286 return AppendCols( numCols
);
3289 for ( row
= 0; row
< curNumRows
; row
++ )
3291 for ( col
= pos
; col
< pos
+ numCols
; col
++ )
3293 m_data
[row
].Insert( wxEmptyString
, col
);
3298 wxGridTableMessage
msg( this,
3299 wxGRIDTABLE_NOTIFY_COLS_INSERTED
,
3303 GetView()->ProcessTableMessage( msg
);
3309 bool wxGridStringTable::AppendCols( size_t numCols
)
3313 size_t curNumRows
= m_data
.GetCount();
3317 // TODO: something better than this ?
3319 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3324 for ( row
= 0; row
< curNumRows
; row
++ )
3326 m_data
[row
].Add( wxEmptyString
, numCols
);
3331 wxGridTableMessage
msg( this,
3332 wxGRIDTABLE_NOTIFY_COLS_APPENDED
,
3335 GetView()->ProcessTableMessage( msg
);
3341 bool wxGridStringTable::DeleteCols( size_t pos
, size_t numCols
)
3345 size_t curNumRows
= m_data
.GetCount();
3346 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3347 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3349 if ( pos
>= curNumCols
)
3351 wxFAIL_MSG( wxString::Format
3353 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
3355 (unsigned long)numCols
,
3356 (unsigned long)curNumCols
3361 if ( numCols
> curNumCols
- pos
)
3363 numCols
= curNumCols
- pos
;
3366 for ( row
= 0; row
< curNumRows
; row
++ )
3368 if ( numCols
>= curNumCols
)
3370 m_data
[row
].Clear();
3374 m_data
[row
].RemoveAt( pos
, numCols
);
3379 wxGridTableMessage
msg( this,
3380 wxGRIDTABLE_NOTIFY_COLS_DELETED
,
3384 GetView()->ProcessTableMessage( msg
);
3390 wxString
wxGridStringTable::GetRowLabelValue( int row
)
3392 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3394 // using default label
3396 return wxGridTableBase::GetRowLabelValue( row
);
3400 return m_rowLabels
[ row
];
3404 wxString
wxGridStringTable::GetColLabelValue( int col
)
3406 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3408 // using default label
3410 return wxGridTableBase::GetColLabelValue( col
);
3414 return m_colLabels
[ col
];
3418 void wxGridStringTable::SetRowLabelValue( int row
, const wxString
& value
)
3420 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3422 int n
= m_rowLabels
.GetCount();
3424 for ( i
= n
; i
<= row
; i
++ )
3426 m_rowLabels
.Add( wxGridTableBase::GetRowLabelValue(i
) );
3430 m_rowLabels
[row
] = value
;
3433 void wxGridStringTable::SetColLabelValue( int col
, const wxString
& value
)
3435 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3437 int n
= m_colLabels
.GetCount();
3439 for ( i
= n
; i
<= col
; i
++ )
3441 m_colLabels
.Add( wxGridTableBase::GetColLabelValue(i
) );
3445 m_colLabels
[col
] = value
;
3450 //////////////////////////////////////////////////////////////////////
3451 //////////////////////////////////////////////////////////////////////
3453 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow
, wxWindow
)
3455 BEGIN_EVENT_TABLE( wxGridRowLabelWindow
, wxWindow
)
3456 EVT_PAINT( wxGridRowLabelWindow::OnPaint
)
3457 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel
)
3458 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent
)
3459 EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown
)
3460 EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp
)
3463 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid
*parent
,
3465 const wxPoint
&pos
, const wxSize
&size
)
3466 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
)
3471 void wxGridRowLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3475 // NO - don't do this because it will set both the x and y origin
3476 // coords to match the parent scrolled window and we just want to
3477 // set the y coord - MB
3479 // m_owner->PrepareDC( dc );
3482 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3483 dc
.SetDeviceOrigin( 0, -y
);
3485 wxArrayInt rows
= m_owner
->CalcRowLabelsExposed( GetUpdateRegion() );
3486 m_owner
->DrawRowLabels( dc
, rows
);
3490 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3492 m_owner
->ProcessRowLabelMouseEvent( event
);
3496 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3498 m_owner
->GetEventHandler()->ProcessEvent(event
);
3502 // This seems to be required for wxMotif otherwise the mouse
3503 // cursor must be in the cell edit control to get key events
3505 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3507 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3510 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3512 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3517 //////////////////////////////////////////////////////////////////////
3519 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow
, wxWindow
)
3521 BEGIN_EVENT_TABLE( wxGridColLabelWindow
, wxWindow
)
3522 EVT_PAINT( wxGridColLabelWindow::OnPaint
)
3523 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel
)
3524 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent
)
3525 EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown
)
3526 EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp
)
3529 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid
*parent
,
3531 const wxPoint
&pos
, const wxSize
&size
)
3532 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
)
3537 void wxGridColLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3541 // NO - don't do this because it will set both the x and y origin
3542 // coords to match the parent scrolled window and we just want to
3543 // set the x coord - MB
3545 // m_owner->PrepareDC( dc );
3548 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3549 dc
.SetDeviceOrigin( -x
, 0 );
3551 wxArrayInt cols
= m_owner
->CalcColLabelsExposed( GetUpdateRegion() );
3552 m_owner
->DrawColLabels( dc
, cols
);
3556 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3558 m_owner
->ProcessColLabelMouseEvent( event
);
3561 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3563 m_owner
->GetEventHandler()->ProcessEvent(event
);
3567 // This seems to be required for wxMotif otherwise the mouse
3568 // cursor must be in the cell edit control to get key events
3570 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3572 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3575 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3577 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3582 //////////////////////////////////////////////////////////////////////
3584 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow
, wxWindow
)
3586 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow
, wxWindow
)
3587 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel
)
3588 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent
)
3589 EVT_PAINT( wxGridCornerLabelWindow::OnPaint
)
3590 EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown
)
3591 EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp
)
3594 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid
*parent
,
3596 const wxPoint
&pos
, const wxSize
&size
)
3597 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
)
3602 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3606 int client_height
= 0;
3607 int client_width
= 0;
3608 GetClientSize( &client_width
, &client_height
);
3610 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW
),1, wxSOLID
) );
3611 dc
.DrawLine( client_width
-1, client_height
-1, client_width
-1, 0 );
3612 dc
.DrawLine( client_width
-1, client_height
-1, 0, client_height
-1 );
3613 dc
.DrawLine( 0, 0, client_width
, 0 );
3614 dc
.DrawLine( 0, 0, 0, client_height
);
3616 dc
.SetPen( *wxWHITE_PEN
);
3617 dc
.DrawLine( 1, 1, client_width
-1, 1 );
3618 dc
.DrawLine( 1, 1, 1, client_height
-1 );
3622 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3624 m_owner
->ProcessCornerLabelMouseEvent( event
);
3628 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3630 m_owner
->GetEventHandler()->ProcessEvent(event
);
3633 // This seems to be required for wxMotif otherwise the mouse
3634 // cursor must be in the cell edit control to get key events
3636 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3638 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3641 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3643 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3648 //////////////////////////////////////////////////////////////////////
3650 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow
, wxWindow
)
3652 BEGIN_EVENT_TABLE( wxGridWindow
, wxWindow
)
3653 EVT_PAINT( wxGridWindow::OnPaint
)
3654 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel
)
3655 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent
)
3656 EVT_KEY_DOWN( wxGridWindow::OnKeyDown
)
3657 EVT_KEY_UP( wxGridWindow::OnKeyUp
)
3658 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground
)
3661 wxGridWindow::wxGridWindow( wxGrid
*parent
,
3662 wxGridRowLabelWindow
*rowLblWin
,
3663 wxGridColLabelWindow
*colLblWin
,
3666 const wxSize
&size
)
3667 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
| wxCLIP_CHILDREN
,
3668 wxT("grid window") )
3672 m_rowLabelWin
= rowLblWin
;
3673 m_colLabelWin
= colLblWin
;
3674 SetBackgroundColour(_T("WHITE"));
3678 wxGridWindow::~wxGridWindow()
3683 void wxGridWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
3685 wxPaintDC
dc( this );
3686 m_owner
->PrepareDC( dc
);
3687 wxRegion reg
= GetUpdateRegion();
3688 wxGridCellCoordsArray DirtyCells
= m_owner
->CalcCellsExposed( reg
);
3689 m_owner
->DrawGridCellArea( dc
, DirtyCells
);
3690 #if WXGRID_DRAW_LINES
3691 m_owner
->DrawAllGridLines( dc
, reg
);
3693 m_owner
->DrawGridSpace( dc
);
3694 m_owner
->DrawHighlight( dc
, DirtyCells
);
3698 void wxGridWindow::ScrollWindow( int dx
, int dy
, const wxRect
*rect
)
3700 wxWindow::ScrollWindow( dx
, dy
, rect
);
3701 m_rowLabelWin
->ScrollWindow( 0, dy
, rect
);
3702 m_colLabelWin
->ScrollWindow( dx
, 0, rect
);
3706 void wxGridWindow::OnMouseEvent( wxMouseEvent
& event
)
3708 m_owner
->ProcessGridCellMouseEvent( event
);
3711 void wxGridWindow::OnMouseWheel( wxMouseEvent
& event
)
3713 m_owner
->GetEventHandler()->ProcessEvent(event
);
3716 // This seems to be required for wxMotif/wxGTK otherwise the mouse
3717 // cursor must be in the cell edit control to get key events
3719 void wxGridWindow::OnKeyDown( wxKeyEvent
& event
)
3721 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3724 void wxGridWindow::OnKeyUp( wxKeyEvent
& event
)
3726 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3729 void wxGridWindow::OnEraseBackground( wxEraseEvent
& WXUNUSED(event
) )
3734 //////////////////////////////////////////////////////////////////////
3736 // Internal Helper function for computing row or column from some
3737 // (unscrolled) coordinate value, using either
3738 // m_defaultRowHeight/m_defaultColWidth or binary search on array
3739 // of m_rowBottoms/m_ColRights to speed up the search!
3741 // Internal helper macros for simpler use of that function
3743 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
3744 const wxArrayInt
& BorderArray
, int nMax
,
3745 bool maxOnOverflow
);
3747 #define internalXToCol(x) CoordToRowOrCol(x, m_defaultColWidth, \
3748 WXGRID_MIN_COL_WIDTH, \
3749 m_colRights, m_numCols, TRUE)
3750 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
3751 WXGRID_MIN_ROW_HEIGHT, \
3752 m_rowBottoms, m_numRows, TRUE)
3753 /////////////////////////////////////////////////////////////////////
3755 IMPLEMENT_DYNAMIC_CLASS( wxGrid
, wxScrolledWindow
)
3757 BEGIN_EVENT_TABLE( wxGrid
, wxScrolledWindow
)
3758 EVT_PAINT( wxGrid::OnPaint
)
3759 EVT_SIZE( wxGrid::OnSize
)
3760 EVT_KEY_DOWN( wxGrid::OnKeyDown
)
3761 EVT_KEY_UP( wxGrid::OnKeyUp
)
3762 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground
)
3765 wxGrid::wxGrid( wxWindow
*parent
,
3770 const wxString
& name
)
3771 : wxScrolledWindow( parent
, id
, pos
, size
, (style
| wxWANTS_CHARS
), name
),
3772 m_colMinWidths(GRID_HASH_SIZE
),
3773 m_rowMinHeights(GRID_HASH_SIZE
)
3781 // Must do this or ~wxScrollHelper will pop the wrong event handler
3782 SetTargetWindow(this);
3784 wxSafeDecRef(m_defaultCellAttr
);
3786 #ifdef DEBUG_ATTR_CACHE
3787 size_t total
= gs_nAttrCacheHits
+ gs_nAttrCacheMisses
;
3788 wxPrintf(_T("wxGrid attribute cache statistics: "
3789 "total: %u, hits: %u (%u%%)\n"),
3790 total
, gs_nAttrCacheHits
,
3791 total
? (gs_nAttrCacheHits
*100) / total
: 0);
3797 delete m_typeRegistry
;
3803 // ----- internal init and update functions
3806 void wxGrid::Create()
3808 m_created
= FALSE
; // set to TRUE by CreateGrid
3810 m_table
= (wxGridTableBase
*) NULL
;
3813 m_cellEditCtrlEnabled
= FALSE
;
3815 m_defaultCellAttr
= new wxGridCellAttr();
3817 // Set default cell attributes
3818 m_defaultCellAttr
->SetDefAttr(m_defaultCellAttr
);
3819 m_defaultCellAttr
->SetKind(wxGridCellAttr::Default
);
3820 m_defaultCellAttr
->SetFont(GetFont());
3821 m_defaultCellAttr
->SetAlignment(wxALIGN_LEFT
, wxALIGN_TOP
);
3822 m_defaultCellAttr
->SetTextColour(
3823 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
3824 m_defaultCellAttr
->SetBackgroundColour(
3825 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
3826 m_defaultCellAttr
->SetRenderer(new wxGridCellStringRenderer
);
3827 m_defaultCellAttr
->SetEditor(new wxGridCellTextEditor
);
3832 m_currentCellCoords
= wxGridNoCellCoords
;
3834 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
3835 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
3837 // create the type registry
3838 m_typeRegistry
= new wxGridTypeRegistry
;
3841 // subwindow components that make up the wxGrid
3842 m_cornerLabelWin
= new wxGridCornerLabelWindow( this,
3847 m_rowLabelWin
= new wxGridRowLabelWindow( this,
3852 m_colLabelWin
= new wxGridColLabelWindow( this,
3857 m_gridWin
= new wxGridWindow( this,
3864 SetTargetWindow( m_gridWin
);
3870 bool wxGrid::CreateGrid( int numRows
, int numCols
,
3871 wxGrid::wxGridSelectionModes selmode
)
3873 wxCHECK_MSG( !m_created
,
3875 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3877 m_numRows
= numRows
;
3878 m_numCols
= numCols
;
3880 m_table
= new wxGridStringTable( m_numRows
, m_numCols
);
3881 m_table
->SetView( this );
3883 m_selection
= new wxGridSelection( this, selmode
);
3892 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode
)
3894 wxCHECK_RET( m_created
,
3895 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3897 m_selection
->SetSelectionMode( selmode
);
3900 wxGrid::wxGridSelectionModes
wxGrid::GetSelectionMode() const
3902 wxCHECK_MSG( m_created
, wxGrid::wxGridSelectCells
,
3903 wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
3905 return m_selection
->GetSelectionMode();
3908 bool wxGrid::SetTable( wxGridTableBase
*table
, bool takeOwnership
,
3909 wxGrid::wxGridSelectionModes selmode
)
3913 // RD: Actually, this should probably be allowed. I think it would be
3914 // nice to be able to switch multiple Tables in and out of a single
3915 // View at runtime. Is there anything in the implementation that
3916 // would prevent this?
3918 // At least, you now have to cope with m_selection
3919 wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3924 m_numRows
= table
->GetNumberRows();
3925 m_numCols
= table
->GetNumberCols();
3928 m_table
->SetView( this );
3931 m_selection
= new wxGridSelection( this, selmode
);
3944 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
3945 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
3947 if ( m_rowLabelWin
)
3949 m_labelBackgroundColour
= m_rowLabelWin
->GetBackgroundColour();
3953 m_labelBackgroundColour
= wxColour( _T("WHITE") );
3956 m_labelTextColour
= wxColour( _T("BLACK") );
3959 m_attrCache
.row
= -1;
3960 m_attrCache
.col
= -1;
3961 m_attrCache
.attr
= NULL
;
3963 // TODO: something better than this ?
3965 m_labelFont
= this->GetFont();
3966 m_labelFont
.SetWeight( wxBOLD
);
3968 m_rowLabelHorizAlign
= wxALIGN_CENTRE
;
3969 m_rowLabelVertAlign
= wxALIGN_CENTRE
;
3971 m_colLabelHorizAlign
= wxALIGN_CENTRE
;
3972 m_colLabelVertAlign
= wxALIGN_CENTRE
;
3973 m_colLabelTextOrientation
= wxHORIZONTAL
;
3975 m_defaultColWidth
= WXGRID_DEFAULT_COL_WIDTH
;
3976 m_defaultRowHeight
= m_gridWin
->GetCharHeight();
3978 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
3979 m_defaultRowHeight
+= 8;
3981 m_defaultRowHeight
+= 4;
3984 m_gridLineColour
= wxColour( 192,192,192 );
3985 m_gridLinesEnabled
= TRUE
;
3986 m_cellHighlightColour
= *wxBLACK
;
3987 m_cellHighlightPenWidth
= 2;
3988 m_cellHighlightROPenWidth
= 1;
3990 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
3991 m_winCapture
= (wxWindow
*)NULL
;
3992 m_canDragRowSize
= TRUE
;
3993 m_canDragColSize
= TRUE
;
3994 m_canDragGridSize
= TRUE
;
3996 m_dragRowOrCol
= -1;
3997 m_isDragging
= FALSE
;
3998 m_startDragPos
= wxDefaultPosition
;
4000 m_waitForSlowClick
= FALSE
;
4002 m_rowResizeCursor
= wxCursor( wxCURSOR_SIZENS
);
4003 m_colResizeCursor
= wxCursor( wxCURSOR_SIZEWE
);
4005 m_currentCellCoords
= wxGridNoCellCoords
;
4007 m_selectingTopLeft
= wxGridNoCellCoords
;
4008 m_selectingBottomRight
= wxGridNoCellCoords
;
4009 m_selectionBackground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
4010 m_selectionForeground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
4012 m_editable
= TRUE
; // default for whole grid
4014 m_inOnKeyDown
= FALSE
;
4021 // ----------------------------------------------------------------------------
4022 // the idea is to call these functions only when necessary because they create
4023 // quite big arrays which eat memory mostly unnecessary - in particular, if
4024 // default widths/heights are used for all rows/columns, we may not use these
4027 // with some extra code, it should be possible to only store the
4028 // widths/heights different from default ones but this will be done later...
4029 // ----------------------------------------------------------------------------
4031 void wxGrid::InitRowHeights()
4033 m_rowHeights
.Empty();
4034 m_rowBottoms
.Empty();
4036 m_rowHeights
.Alloc( m_numRows
);
4037 m_rowBottoms
.Alloc( m_numRows
);
4041 m_rowHeights
.Add( m_defaultRowHeight
, m_numRows
);
4043 for ( int i
= 0; i
< m_numRows
; i
++ )
4045 rowBottom
+= m_defaultRowHeight
;
4046 m_rowBottoms
.Add( rowBottom
);
4050 void wxGrid::InitColWidths()
4052 m_colWidths
.Empty();
4053 m_colRights
.Empty();
4055 m_colWidths
.Alloc( m_numCols
);
4056 m_colRights
.Alloc( m_numCols
);
4059 m_colWidths
.Add( m_defaultColWidth
, m_numCols
);
4061 for ( int i
= 0; i
< m_numCols
; i
++ )
4063 colRight
+= m_defaultColWidth
;
4064 m_colRights
.Add( colRight
);
4068 int wxGrid::GetColWidth(int col
) const
4070 return m_colWidths
.IsEmpty() ? m_defaultColWidth
: m_colWidths
[col
];
4073 int wxGrid::GetColLeft(int col
) const
4075 return m_colRights
.IsEmpty() ? col
* m_defaultColWidth
4076 : m_colRights
[col
] - m_colWidths
[col
];
4079 int wxGrid::GetColRight(int col
) const
4081 return m_colRights
.IsEmpty() ? (col
+ 1) * m_defaultColWidth
4085 int wxGrid::GetRowHeight(int row
) const
4087 return m_rowHeights
.IsEmpty() ? m_defaultRowHeight
: m_rowHeights
[row
];
4090 int wxGrid::GetRowTop(int row
) const
4092 return m_rowBottoms
.IsEmpty() ? row
* m_defaultRowHeight
4093 : m_rowBottoms
[row
] - m_rowHeights
[row
];
4096 int wxGrid::GetRowBottom(int row
) const
4098 return m_rowBottoms
.IsEmpty() ? (row
+ 1) * m_defaultRowHeight
4099 : m_rowBottoms
[row
];
4102 void wxGrid::CalcDimensions()
4105 GetClientSize( &cw
, &ch
);
4107 if ( m_rowLabelWin
->IsShown() )
4108 cw
-= m_rowLabelWidth
;
4109 if ( m_colLabelWin
->IsShown() )
4110 ch
-= m_colLabelHeight
;
4113 int w
= m_numCols
> 0 ? GetColRight(m_numCols
- 1) + m_extraWidth
+ 1 : 0;
4114 int h
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) + m_extraHeight
+ 1 : 0;
4116 // take into account editor if shown
4117 if( IsCellEditControlShown() )
4120 int r
= m_currentCellCoords
.GetRow();
4121 int c
= m_currentCellCoords
.GetCol();
4122 int x
= GetColLeft(c
);
4123 int y
= GetRowTop(r
);
4125 // how big is the editor
4126 wxGridCellAttr
* attr
= GetCellAttr(r
, c
);
4127 wxGridCellEditor
* editor
= attr
->GetEditor(this, r
, c
);
4128 editor
->GetControl()->GetSize(&w2
, &h2
);
4131 if( w2
> w
) w
= w2
;
4132 if( h2
> h
) h
= h2
;
4137 // preserve (more or less) the previous position
4139 GetViewStart( &x
, &y
);
4141 // maybe we don't need scrollbars at all?
4143 // also adjust the position to be valid for the new scroll rangs
4164 // do set scrollbar parameters
4165 SetScrollbars( GRID_SCROLL_LINE_X
, GRID_SCROLL_LINE_Y
,
4166 GetScrollX(w
), GetScrollY(h
), x
, y
,
4167 GetBatchCount() != 0);
4169 // if our OnSize() hadn't been called (it would if we have scrollbars), we
4170 // still must reposition the children
4175 void wxGrid::CalcWindowSizes()
4178 GetClientSize( &cw
, &ch
);
4180 if ( m_cornerLabelWin
->IsShown() )
4181 m_cornerLabelWin
->SetSize( 0, 0, m_rowLabelWidth
, m_colLabelHeight
);
4183 if ( m_colLabelWin
->IsShown() )
4184 m_colLabelWin
->SetSize( m_rowLabelWidth
, 0, cw
-m_rowLabelWidth
, m_colLabelHeight
);
4186 if ( m_rowLabelWin
->IsShown() )
4187 m_rowLabelWin
->SetSize( 0, m_colLabelHeight
, m_rowLabelWidth
, ch
-m_colLabelHeight
);
4189 if ( m_gridWin
->IsShown() )
4190 m_gridWin
->SetSize( m_rowLabelWidth
, m_colLabelHeight
, cw
-m_rowLabelWidth
, ch
-m_colLabelHeight
);
4194 // this is called when the grid table sends a message to say that it
4195 // has been redimensioned
4197 bool wxGrid::Redimension( wxGridTableMessage
& msg
)
4200 bool result
= FALSE
;
4202 // Clear the attribute cache as the attribute might refer to a different
4203 // cell than stored in the cache after adding/removing rows/columns.
4205 // By the same reasoning, the editor should be dismissed if columns are
4206 // added or removed. And for consistency, it should IMHO always be
4207 // removed, not only if the cell "underneath" it actually changes.
4208 // For now, I intentionally do not save the editor's content as the
4209 // cell it might want to save that stuff to might no longer exist.
4210 HideCellEditControl();
4212 // if we were using the default widths/heights so far, we must change them
4214 if ( m_colWidths
.IsEmpty() )
4219 if ( m_rowHeights
.IsEmpty() )
4225 switch ( msg
.GetId() )
4227 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
4229 size_t pos
= msg
.GetCommandInt();
4230 int numRows
= msg
.GetCommandInt2();
4232 m_numRows
+= numRows
;
4234 if ( !m_rowHeights
.IsEmpty() )
4236 m_rowHeights
.Insert( m_defaultRowHeight
, pos
, numRows
);
4237 m_rowBottoms
.Insert( 0, pos
, numRows
);
4240 if ( pos
> 0 ) bottom
= m_rowBottoms
[pos
-1];
4242 for ( i
= pos
; i
< m_numRows
; i
++ )
4244 bottom
+= m_rowHeights
[i
];
4245 m_rowBottoms
[i
] = bottom
;
4248 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4250 // if we have just inserted cols into an empty grid the current
4251 // cell will be undefined...
4253 SetCurrentCell( 0, 0 );
4257 m_selection
->UpdateRows( pos
, numRows
);
4258 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4260 attrProvider
->UpdateAttrRows( pos
, numRows
);
4262 if ( !GetBatchCount() )
4265 m_rowLabelWin
->Refresh();
4271 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
4273 int numRows
= msg
.GetCommandInt();
4274 int oldNumRows
= m_numRows
;
4275 m_numRows
+= numRows
;
4277 if ( !m_rowHeights
.IsEmpty() )
4279 m_rowHeights
.Add( m_defaultRowHeight
, numRows
);
4280 m_rowBottoms
.Add( 0, numRows
);
4283 if ( oldNumRows
> 0 ) bottom
= m_rowBottoms
[oldNumRows
-1];
4285 for ( i
= oldNumRows
; i
< m_numRows
; i
++ )
4287 bottom
+= m_rowHeights
[i
];
4288 m_rowBottoms
[i
] = bottom
;
4291 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4293 // if we have just inserted cols into an empty grid the current
4294 // cell will be undefined...
4296 SetCurrentCell( 0, 0 );
4298 if ( !GetBatchCount() )
4301 m_rowLabelWin
->Refresh();
4307 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
4309 size_t pos
= msg
.GetCommandInt();
4310 int numRows
= msg
.GetCommandInt2();
4311 m_numRows
-= numRows
;
4313 if ( !m_rowHeights
.IsEmpty() )
4315 m_rowHeights
.RemoveAt( pos
, numRows
);
4316 m_rowBottoms
.RemoveAt( pos
, numRows
);
4319 for ( i
= 0; i
< m_numRows
; i
++ )
4321 h
+= m_rowHeights
[i
];
4322 m_rowBottoms
[i
] = h
;
4327 m_currentCellCoords
= wxGridNoCellCoords
;
4331 if ( m_currentCellCoords
.GetRow() >= m_numRows
)
4332 m_currentCellCoords
.Set( 0, 0 );
4336 m_selection
->UpdateRows( pos
, -((int)numRows
) );
4337 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4339 attrProvider
->UpdateAttrRows( pos
, -((int)numRows
) );
4340 // ifdef'd out following patch from Paul Gammans
4342 // No need to touch column attributes, unless we
4343 // removed _all_ rows, in this case, we remove
4344 // all column attributes.
4345 // I hate to do this here, but the
4346 // needed data is not available inside UpdateAttrRows.
4347 if ( !GetNumberRows() )
4348 attrProvider
->UpdateAttrCols( 0, -GetNumberCols() );
4351 if ( !GetBatchCount() )
4354 m_rowLabelWin
->Refresh();
4360 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
4362 size_t pos
= msg
.GetCommandInt();
4363 int numCols
= msg
.GetCommandInt2();
4364 m_numCols
+= numCols
;
4366 if ( !m_colWidths
.IsEmpty() )
4368 m_colWidths
.Insert( m_defaultColWidth
, pos
, numCols
);
4369 m_colRights
.Insert( 0, pos
, numCols
);
4372 if ( pos
> 0 ) right
= m_colRights
[pos
-1];
4374 for ( i
= pos
; i
< m_numCols
; i
++ )
4376 right
+= m_colWidths
[i
];
4377 m_colRights
[i
] = right
;
4380 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4382 // if we have just inserted cols into an empty grid the current
4383 // cell will be undefined...
4385 SetCurrentCell( 0, 0 );
4389 m_selection
->UpdateCols( pos
, numCols
);
4390 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4392 attrProvider
->UpdateAttrCols( pos
, numCols
);
4393 if ( !GetBatchCount() )
4396 m_colLabelWin
->Refresh();
4403 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
4405 int numCols
= msg
.GetCommandInt();
4406 int oldNumCols
= m_numCols
;
4407 m_numCols
+= numCols
;
4408 if ( !m_colWidths
.IsEmpty() )
4410 m_colWidths
.Add( m_defaultColWidth
, numCols
);
4411 m_colRights
.Add( 0, numCols
);
4414 if ( oldNumCols
> 0 ) right
= m_colRights
[oldNumCols
-1];
4416 for ( i
= oldNumCols
; i
< m_numCols
; i
++ )
4418 right
+= m_colWidths
[i
];
4419 m_colRights
[i
] = right
;
4422 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4424 // if we have just inserted cols into an empty grid the current
4425 // cell will be undefined...
4427 SetCurrentCell( 0, 0 );
4429 if ( !GetBatchCount() )
4432 m_colLabelWin
->Refresh();
4438 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
4440 size_t pos
= msg
.GetCommandInt();
4441 int numCols
= msg
.GetCommandInt2();
4442 m_numCols
-= numCols
;
4444 if ( !m_colWidths
.IsEmpty() )
4446 m_colWidths
.RemoveAt( pos
, numCols
);
4447 m_colRights
.RemoveAt( pos
, numCols
);
4450 for ( i
= 0; i
< m_numCols
; i
++ )
4452 w
+= m_colWidths
[i
];
4458 m_currentCellCoords
= wxGridNoCellCoords
;
4462 if ( m_currentCellCoords
.GetCol() >= m_numCols
)
4463 m_currentCellCoords
.Set( 0, 0 );
4467 m_selection
->UpdateCols( pos
, -((int)numCols
) );
4468 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4470 attrProvider
->UpdateAttrCols( pos
, -((int)numCols
) );
4471 // ifdef'd out following patch from Paul Gammans
4473 // No need to touch row attributes, unless we
4474 // removed _all_ columns, in this case, we remove
4475 // all row attributes.
4476 // I hate to do this here, but the
4477 // needed data is not available inside UpdateAttrCols.
4478 if ( !GetNumberCols() )
4479 attrProvider
->UpdateAttrRows( 0, -GetNumberRows() );
4482 if ( !GetBatchCount() )
4485 m_colLabelWin
->Refresh();
4492 if (result
&& !GetBatchCount() )
4493 m_gridWin
->Refresh();
4498 wxArrayInt
wxGrid::CalcRowLabelsExposed( const wxRegion
& reg
)
4500 wxRegionIterator
iter( reg
);
4503 wxArrayInt rowlabels
;
4510 // TODO: remove this when we can...
4511 // There is a bug in wxMotif that gives garbage update
4512 // rectangles if you jump-scroll a long way by clicking the
4513 // scrollbar with middle button. This is a work-around
4515 #if defined(__WXMOTIF__)
4517 m_gridWin
->GetClientSize( &cw
, &ch
);
4518 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
4519 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
4522 // logical bounds of update region
4525 CalcUnscrolledPosition( 0, r
.GetTop(), &dummy
, &top
);
4526 CalcUnscrolledPosition( 0, r
.GetBottom(), &dummy
, &bottom
);
4528 // find the row labels within these bounds
4531 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
4533 if ( GetRowBottom(row
) < top
)
4536 if ( GetRowTop(row
) > bottom
)
4539 rowlabels
.Add( row
);
4549 wxArrayInt
wxGrid::CalcColLabelsExposed( const wxRegion
& reg
)
4551 wxRegionIterator
iter( reg
);
4554 wxArrayInt colLabels
;
4561 // TODO: remove this when we can...
4562 // There is a bug in wxMotif that gives garbage update
4563 // rectangles if you jump-scroll a long way by clicking the
4564 // scrollbar with middle button. This is a work-around
4566 #if defined(__WXMOTIF__)
4568 m_gridWin
->GetClientSize( &cw
, &ch
);
4569 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
4570 r
.SetRight( wxMin( r
.GetRight(), cw
) );
4573 // logical bounds of update region
4576 CalcUnscrolledPosition( r
.GetLeft(), 0, &left
, &dummy
);
4577 CalcUnscrolledPosition( r
.GetRight(), 0, &right
, &dummy
);
4579 // find the cells within these bounds
4582 for ( col
= internalXToCol(left
); col
< m_numCols
; col
++ )
4584 if ( GetColRight(col
) < left
)
4587 if ( GetColLeft(col
) > right
)
4590 colLabels
.Add( col
);
4599 wxGridCellCoordsArray
wxGrid::CalcCellsExposed( const wxRegion
& reg
)
4601 wxRegionIterator
iter( reg
);
4604 wxGridCellCoordsArray cellsExposed
;
4606 int left
, top
, right
, bottom
;
4611 // TODO: remove this when we can...
4612 // There is a bug in wxMotif that gives garbage update
4613 // rectangles if you jump-scroll a long way by clicking the
4614 // scrollbar with middle button. This is a work-around
4616 #if defined(__WXMOTIF__)
4618 m_gridWin
->GetClientSize( &cw
, &ch
);
4619 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
4620 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
4621 r
.SetRight( wxMin( r
.GetRight(), cw
) );
4622 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
4625 // logical bounds of update region
4627 CalcUnscrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
4628 CalcUnscrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
4630 // find the cells within these bounds
4633 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
4635 if ( GetRowBottom(row
) <= top
)
4638 if ( GetRowTop(row
) > bottom
)
4641 for ( col
= internalXToCol(left
); col
< m_numCols
; col
++ )
4643 if ( GetColRight(col
) <= left
)
4646 if ( GetColLeft(col
) > right
)
4649 cellsExposed
.Add( wxGridCellCoords( row
, col
) );
4656 return cellsExposed
;
4660 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent
& event
)
4663 wxPoint
pos( event
.GetPosition() );
4664 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
4666 if ( event
.Dragging() )
4670 m_isDragging
= TRUE
;
4671 m_rowLabelWin
->CaptureMouse();
4674 if ( event
.LeftIsDown() )
4676 switch( m_cursorMode
)
4678 case WXGRID_CURSOR_RESIZE_ROW
:
4680 int cw
, ch
, left
, dummy
;
4681 m_gridWin
->GetClientSize( &cw
, &ch
);
4682 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
4684 wxClientDC
dc( m_gridWin
);
4687 GetRowTop(m_dragRowOrCol
) +
4688 GetRowMinimalHeight(m_dragRowOrCol
) );
4689 dc
.SetLogicalFunction(wxINVERT
);
4690 if ( m_dragLastPos
>= 0 )
4692 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
4694 dc
.DrawLine( left
, y
, left
+cw
, y
);
4699 case WXGRID_CURSOR_SELECT_ROW
:
4700 if ( (row
= YToRow( y
)) >= 0 )
4704 m_selection
->SelectRow( row
,
4705 event
.ControlDown(),
4712 // default label to suppress warnings about "enumeration value
4713 // 'xxx' not handled in switch
4721 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
4726 if (m_rowLabelWin
->HasCapture()) m_rowLabelWin
->ReleaseMouse();
4727 m_isDragging
= FALSE
;
4730 // ------------ Entering or leaving the window
4732 if ( event
.Entering() || event
.Leaving() )
4734 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
4738 // ------------ Left button pressed
4740 else if ( event
.LeftDown() )
4742 // don't send a label click event for a hit on the
4743 // edge of the row label - this is probably the user
4744 // wanting to resize the row
4746 if ( YToEdgeOfRow(y
) < 0 )
4750 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, row
, -1, event
) )
4752 if ( !event
.ShiftDown() && !event
.ControlDown() )
4756 if ( event
.ShiftDown() )
4758 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
4761 GetNumberCols() - 1,
4762 event
.ControlDown(),
4769 m_selection
->SelectRow( row
,
4770 event
.ControlDown(),
4777 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW
, m_rowLabelWin
);
4782 // starting to drag-resize a row
4784 if ( CanDragRowSize() )
4785 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
);
4790 // ------------ Left double click
4792 else if (event
.LeftDClick() )
4794 int row
= YToEdgeOfRow(y
);
4798 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, row
, -1, event
);
4802 // adjust row height depending on label text
4803 AutoSizeRowLabelSize( row
);
4805 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
4811 // ------------ Left button released
4813 else if ( event
.LeftUp() )
4815 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
4817 DoEndDragResizeRow();
4819 // Note: we are ending the event *after* doing
4820 // default processing in this case
4822 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
4825 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
4830 // ------------ Right button down
4832 else if ( event
.RightDown() )
4835 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, row
, -1, event
) )
4837 // no default action at the moment
4842 // ------------ Right double click
4844 else if ( event
.RightDClick() )
4847 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, row
, -1, event
) )
4849 // no default action at the moment
4854 // ------------ No buttons down and mouse moving
4856 else if ( event
.Moving() )
4858 m_dragRowOrCol
= YToEdgeOfRow( y
);
4859 if ( m_dragRowOrCol
>= 0 )
4861 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4863 // don't capture the mouse yet
4864 if ( CanDragRowSize() )
4865 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
, FALSE
);
4868 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
4870 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
, FALSE
);
4876 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent
& event
)
4879 wxPoint
pos( event
.GetPosition() );
4880 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
4882 if ( event
.Dragging() )
4886 m_isDragging
= TRUE
;
4887 m_colLabelWin
->CaptureMouse();
4890 if ( event
.LeftIsDown() )
4892 switch( m_cursorMode
)
4894 case WXGRID_CURSOR_RESIZE_COL
:
4896 int cw
, ch
, dummy
, top
;
4897 m_gridWin
->GetClientSize( &cw
, &ch
);
4898 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
4900 wxClientDC
dc( m_gridWin
);
4903 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
4904 GetColMinimalWidth(m_dragRowOrCol
));
4905 dc
.SetLogicalFunction(wxINVERT
);
4906 if ( m_dragLastPos
>= 0 )
4908 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
4910 dc
.DrawLine( x
, top
, x
, top
+ch
);
4915 case WXGRID_CURSOR_SELECT_COL
:
4916 if ( (col
= XToCol( x
)) >= 0 )
4920 m_selection
->SelectCol( col
,
4921 event
.ControlDown(),
4928 // default label to suppress warnings about "enumeration value
4929 // 'xxx' not handled in switch
4937 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
4942 if (m_colLabelWin
->HasCapture()) m_colLabelWin
->ReleaseMouse();
4943 m_isDragging
= FALSE
;
4946 // ------------ Entering or leaving the window
4948 if ( event
.Entering() || event
.Leaving() )
4950 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
4954 // ------------ Left button pressed
4956 else if ( event
.LeftDown() )
4958 // don't send a label click event for a hit on the
4959 // edge of the col label - this is probably the user
4960 // wanting to resize the col
4962 if ( XToEdgeOfCol(x
) < 0 )
4966 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, col
, event
) )
4968 if ( !event
.ShiftDown() && !event
.ControlDown() )
4972 if ( event
.ShiftDown() )
4974 m_selection
->SelectBlock( 0,
4975 m_currentCellCoords
.GetCol(),
4976 GetNumberRows() - 1, col
,
4977 event
.ControlDown(),
4984 m_selection
->SelectCol( col
,
4985 event
.ControlDown(),
4992 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL
, m_colLabelWin
);
4997 // starting to drag-resize a col
4999 if ( CanDragColSize() )
5000 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
);
5005 // ------------ Left double click
5007 if ( event
.LeftDClick() )
5009 int col
= XToEdgeOfCol(x
);
5013 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, col
, event
);
5017 // adjust column width depending on label text
5018 AutoSizeColLabelSize( col
);
5020 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5026 // ------------ Left button released
5028 else if ( event
.LeftUp() )
5030 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
5032 DoEndDragResizeCol();
5034 // Note: we are ending the event *after* doing
5035 // default processing in this case
5037 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
5040 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5045 // ------------ Right button down
5047 else if ( event
.RightDown() )
5050 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, col
, event
) )
5052 // no default action at the moment
5057 // ------------ Right double click
5059 else if ( event
.RightDClick() )
5062 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, col
, event
) )
5064 // no default action at the moment
5069 // ------------ No buttons down and mouse moving
5071 else if ( event
.Moving() )
5073 m_dragRowOrCol
= XToEdgeOfCol( x
);
5074 if ( m_dragRowOrCol
>= 0 )
5076 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5078 // don't capture the cursor yet
5079 if ( CanDragColSize() )
5080 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
, FALSE
);
5083 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5085 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
, FALSE
);
5091 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent
& event
)
5093 if ( event
.LeftDown() )
5095 // indicate corner label by having both row and
5098 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, -1, event
) )
5104 else if ( event
.LeftDClick() )
5106 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, -1, event
);
5109 else if ( event
.RightDown() )
5111 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, -1, event
) )
5113 // no default action at the moment
5117 else if ( event
.RightDClick() )
5119 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, -1, event
) )
5121 // no default action at the moment
5126 void wxGrid::ChangeCursorMode(CursorMode mode
,
5131 static const wxChar
*cursorModes
[] =
5140 wxLogTrace(_T("grid"),
5141 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
5142 win
== m_colLabelWin
? _T("colLabelWin")
5143 : win
? _T("rowLabelWin")
5145 cursorModes
[m_cursorMode
], cursorModes
[mode
]);
5146 #endif // __WXDEBUG__
5148 if ( mode
== m_cursorMode
&&
5149 win
== m_winCapture
&&
5150 captureMouse
== (m_winCapture
!= NULL
))
5155 // by default use the grid itself
5161 if (m_winCapture
->HasCapture()) m_winCapture
->ReleaseMouse();
5162 m_winCapture
= (wxWindow
*)NULL
;
5165 m_cursorMode
= mode
;
5167 switch ( m_cursorMode
)
5169 case WXGRID_CURSOR_RESIZE_ROW
:
5170 win
->SetCursor( m_rowResizeCursor
);
5173 case WXGRID_CURSOR_RESIZE_COL
:
5174 win
->SetCursor( m_colResizeCursor
);
5178 win
->SetCursor( *wxSTANDARD_CURSOR
);
5181 // we need to capture mouse when resizing
5182 bool resize
= m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
||
5183 m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
;
5185 if ( captureMouse
&& resize
)
5187 win
->CaptureMouse();
5192 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent
& event
)
5195 wxPoint
pos( event
.GetPosition() );
5196 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5198 wxGridCellCoords coords
;
5199 XYToCell( x
, y
, coords
);
5201 int cell_rows
, cell_cols
;
5202 GetCellSize( coords
.GetRow(), coords
.GetCol(), &cell_rows
, &cell_cols
);
5203 if ((cell_rows
< 0) || (cell_cols
< 0))
5205 coords
.SetRow(coords
.GetRow() + cell_rows
);
5206 coords
.SetCol(coords
.GetCol() + cell_cols
);
5209 if ( event
.Dragging() )
5211 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
5213 // Don't start doing anything until the mouse has been drug at
5214 // least 3 pixels in any direction...
5217 if (m_startDragPos
== wxDefaultPosition
)
5219 m_startDragPos
= pos
;
5222 if (abs(m_startDragPos
.x
- pos
.x
) < 4 && abs(m_startDragPos
.y
- pos
.y
) < 4)
5226 m_isDragging
= TRUE
;
5227 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5229 // Hide the edit control, so it
5230 // won't interfer with drag-shrinking.
5231 if ( IsCellEditControlShown() )
5233 HideCellEditControl();
5234 SaveEditControlValue();
5237 // Have we captured the mouse yet?
5240 m_winCapture
= m_gridWin
;
5241 m_winCapture
->CaptureMouse();
5244 if ( coords
!= wxGridNoCellCoords
)
5246 if ( event
.ControlDown() )
5248 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
5249 m_selectingKeyboard
= coords
;
5250 HighlightBlock ( m_selectingKeyboard
, coords
);
5254 if ( !IsSelection() )
5256 HighlightBlock( coords
, coords
);
5260 HighlightBlock( m_currentCellCoords
, coords
);
5264 if (! IsVisible(coords
))
5266 MakeCellVisible(coords
);
5267 // TODO: need to introduce a delay or something here. The
5268 // scrolling is way to fast, at least on MSW - also on GTK.
5272 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
5274 int cw
, ch
, left
, dummy
;
5275 m_gridWin
->GetClientSize( &cw
, &ch
);
5276 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
5278 wxClientDC
dc( m_gridWin
);
5280 y
= wxMax( y
, GetRowTop(m_dragRowOrCol
) +
5281 GetRowMinimalHeight(m_dragRowOrCol
) );
5282 dc
.SetLogicalFunction(wxINVERT
);
5283 if ( m_dragLastPos
>= 0 )
5285 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
5287 dc
.DrawLine( left
, y
, left
+cw
, y
);
5290 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
5292 int cw
, ch
, dummy
, top
;
5293 m_gridWin
->GetClientSize( &cw
, &ch
);
5294 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
5296 wxClientDC
dc( m_gridWin
);
5298 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
5299 GetColMinimalWidth(m_dragRowOrCol
) );
5300 dc
.SetLogicalFunction(wxINVERT
);
5301 if ( m_dragLastPos
>= 0 )
5303 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
5305 dc
.DrawLine( x
, top
, x
, top
+ch
);
5312 m_isDragging
= FALSE
;
5313 m_startDragPos
= wxDefaultPosition
;
5315 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
5316 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
5319 if ( event
.Entering() || event
.Leaving() )
5321 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5322 m_gridWin
->SetCursor( *wxSTANDARD_CURSOR
);
5327 // ------------ Left button pressed
5329 if ( event
.LeftDown() && coords
!= wxGridNoCellCoords
)
5331 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK
,
5336 if ( !event
.ControlDown() )
5338 if ( event
.ShiftDown() )
5342 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
5343 m_currentCellCoords
.GetCol(),
5346 event
.ControlDown(),
5352 else if ( XToEdgeOfCol(x
) < 0 &&
5353 YToEdgeOfRow(y
) < 0 )
5355 DisableCellEditControl();
5356 MakeCellVisible( coords
);
5358 if ( event
.ControlDown() )
5362 m_selection
->ToggleCellSelection( coords
.GetRow(),
5364 event
.ControlDown(),
5369 m_selectingTopLeft
= wxGridNoCellCoords
;
5370 m_selectingBottomRight
= wxGridNoCellCoords
;
5371 m_selectingKeyboard
= coords
;
5375 m_waitForSlowClick
= m_currentCellCoords
== coords
&& coords
!= wxGridNoCellCoords
;
5376 SetCurrentCell( coords
);
5379 if ( m_selection
->GetSelectionMode() !=
5380 wxGrid::wxGridSelectCells
)
5382 HighlightBlock( coords
, coords
);
5391 // ------------ Left double click
5393 else if ( event
.LeftDClick() && coords
!= wxGridNoCellCoords
)
5395 DisableCellEditControl();
5397 if ( XToEdgeOfCol(x
) < 0 && YToEdgeOfRow(y
) < 0 )
5399 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK
,
5407 // ------------ Left button released
5409 else if ( event
.LeftUp() )
5411 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5413 if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
5414 m_selectingBottomRight
!= wxGridNoCellCoords
)
5418 if (m_winCapture
->HasCapture()) m_winCapture
->ReleaseMouse();
5419 m_winCapture
= NULL
;
5424 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
5425 m_selectingTopLeft
.GetCol(),
5426 m_selectingBottomRight
.GetRow(),
5427 m_selectingBottomRight
.GetCol(),
5428 event
.ControlDown(),
5434 m_selectingTopLeft
= wxGridNoCellCoords
;
5435 m_selectingBottomRight
= wxGridNoCellCoords
;
5437 // Show the edit control, if it has been hidden for
5439 ShowCellEditControl();
5443 if( m_waitForSlowClick
&& CanEnableCellControl())
5445 EnableCellEditControl();
5447 wxGridCellAttr
* attr
= GetCellAttr(coords
);
5448 wxGridCellEditor
*editor
= attr
->GetEditor(this, coords
.GetRow(), coords
.GetCol());
5449 editor
->StartingClick();
5453 m_waitForSlowClick
= FALSE
;
5457 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
5459 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5460 DoEndDragResizeRow();
5462 // Note: we are ending the event *after* doing
5463 // default processing in this case
5465 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
5467 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
5469 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5470 DoEndDragResizeCol();
5472 // Note: we are ending the event *after* doing
5473 // default processing in this case
5475 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
5482 // ------------ Right button down
5484 else if ( event
.RightDown() && coords
!= wxGridNoCellCoords
)
5486 DisableCellEditControl();
5487 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK
,
5492 // no default action at the moment
5497 // ------------ Right double click
5499 else if ( event
.RightDClick() && coords
!= wxGridNoCellCoords
)
5501 DisableCellEditControl();
5502 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK
,
5507 // no default action at the moment
5511 // ------------ Moving and no button action
5513 else if ( event
.Moving() && !event
.IsButton() )
5515 if( coords
.GetRow() < 0 || coords
.GetCol() < 0 )
5517 // out of grid cell area
5518 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5522 int dragRow
= YToEdgeOfRow( y
);
5523 int dragCol
= XToEdgeOfCol( x
);
5525 // Dragging on the corner of a cell to resize in both
5526 // directions is not implemented yet...
5528 if ( dragRow
>= 0 && dragCol
>= 0 )
5530 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5536 m_dragRowOrCol
= dragRow
;
5538 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5540 if ( CanDragRowSize() && CanDragGridSize() )
5541 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
);
5546 m_dragRowOrCol
= dragCol
;
5554 m_dragRowOrCol
= dragCol
;
5556 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5558 if ( CanDragColSize() && CanDragGridSize() )
5559 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
);
5565 // Neither on a row or col edge
5567 if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5569 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5575 void wxGrid::DoEndDragResizeRow()
5577 if ( m_dragLastPos
>= 0 )
5579 // erase the last line and resize the row
5581 int cw
, ch
, left
, dummy
;
5582 m_gridWin
->GetClientSize( &cw
, &ch
);
5583 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
5585 wxClientDC
dc( m_gridWin
);
5587 dc
.SetLogicalFunction( wxINVERT
);
5588 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
5589 HideCellEditControl();
5590 SaveEditControlValue();
5592 int rowTop
= GetRowTop(m_dragRowOrCol
);
5593 SetRowSize( m_dragRowOrCol
,
5594 wxMax( m_dragLastPos
- rowTop
, WXGRID_MIN_ROW_HEIGHT
) );
5596 if ( !GetBatchCount() )
5598 // Only needed to get the correct rect.y:
5599 wxRect
rect ( CellToRect( m_dragRowOrCol
, 0 ) );
5601 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
5602 rect
.width
= m_rowLabelWidth
;
5603 rect
.height
= ch
- rect
.y
;
5604 m_rowLabelWin
->Refresh( TRUE
, &rect
);
5606 // if there is a multicell block, paint all of it
5609 int i
, cell_rows
, cell_cols
, subtract_rows
= 0;
5610 int leftCol
= XToCol(left
);
5611 int rightCol
= XToCol(left
+cw
);
5614 if (rightCol
< 0) rightCol
= m_numCols
;
5615 for (i
=leftCol
; i
<rightCol
; i
++)
5617 GetCellSize(m_dragRowOrCol
, i
, &cell_rows
, &cell_cols
);
5618 if (cell_rows
< subtract_rows
)
5619 subtract_rows
= cell_rows
;
5621 rect
.y
= GetRowTop(m_dragRowOrCol
+ subtract_rows
);
5622 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
5623 rect
.height
= ch
- rect
.y
;
5626 m_gridWin
->Refresh( FALSE
, &rect
);
5629 ShowCellEditControl();
5634 void wxGrid::DoEndDragResizeCol()
5636 if ( m_dragLastPos
>= 0 )
5638 // erase the last line and resize the col
5640 int cw
, ch
, dummy
, top
;
5641 m_gridWin
->GetClientSize( &cw
, &ch
);
5642 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
5644 wxClientDC
dc( m_gridWin
);
5646 dc
.SetLogicalFunction( wxINVERT
);
5647 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
5648 HideCellEditControl();
5649 SaveEditControlValue();
5651 int colLeft
= GetColLeft(m_dragRowOrCol
);
5652 SetColSize( m_dragRowOrCol
,
5653 wxMax( m_dragLastPos
- colLeft
,
5654 GetColMinimalWidth(m_dragRowOrCol
) ) );
5656 if ( !GetBatchCount() )
5658 // Only needed to get the correct rect.x:
5659 wxRect
rect ( CellToRect( 0, m_dragRowOrCol
) );
5661 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
5662 rect
.width
= cw
- rect
.x
;
5663 rect
.height
= m_colLabelHeight
;
5664 m_colLabelWin
->Refresh( TRUE
, &rect
);
5666 // if there is a multicell block, paint all of it
5669 int i
, cell_rows
, cell_cols
, subtract_cols
= 0;
5670 int topRow
= YToRow(top
);
5671 int bottomRow
= YToRow(top
+cw
);
5674 if (bottomRow
< 0) bottomRow
= m_numRows
;
5675 for (i
=topRow
; i
<bottomRow
; i
++)
5677 GetCellSize(i
, m_dragRowOrCol
, &cell_rows
, &cell_cols
);
5678 if (cell_cols
< subtract_cols
)
5679 subtract_cols
= cell_cols
;
5681 rect
.x
= GetColLeft(m_dragRowOrCol
+ subtract_cols
);
5682 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
5683 rect
.width
= cw
- rect
.x
;
5686 m_gridWin
->Refresh( FALSE
, &rect
);
5689 ShowCellEditControl();
5696 // ------ interaction with data model
5698 bool wxGrid::ProcessTableMessage( wxGridTableMessage
& msg
)
5700 switch ( msg
.GetId() )
5702 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES
:
5703 return GetModelValues();
5705 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES
:
5706 return SetModelValues();
5708 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
5709 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
5710 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
5711 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
5712 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
5713 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
5714 return Redimension( msg
);
5723 // The behaviour of this function depends on the grid table class
5724 // Clear() function. For the default wxGridStringTable class the
5725 // behavious is to replace all cell contents with wxEmptyString but
5726 // not to change the number of rows or cols.
5728 void wxGrid::ClearGrid()
5732 if (IsCellEditControlEnabled())
5733 DisableCellEditControl();
5736 if ( !GetBatchCount() ) m_gridWin
->Refresh();
5741 bool wxGrid::InsertRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
5743 // TODO: something with updateLabels flag
5747 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5753 if (IsCellEditControlEnabled())
5754 DisableCellEditControl();
5756 return m_table
->InsertRows( pos
, numRows
);
5758 // the table will have sent the results of the insert row
5759 // operation to this view object as a grid table message
5765 bool wxGrid::AppendRows( int numRows
, bool WXUNUSED(updateLabels
) )
5767 // TODO: something with updateLabels flag
5771 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5775 return ( m_table
&& m_table
->AppendRows( numRows
) );
5776 // the table will have sent the results of the append row
5777 // operation to this view object as a grid table message
5781 bool wxGrid::DeleteRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
5783 // TODO: something with updateLabels flag
5787 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5793 if (IsCellEditControlEnabled())
5794 DisableCellEditControl();
5796 return (m_table
->DeleteRows( pos
, numRows
));
5797 // the table will have sent the results of the delete row
5798 // operation to this view object as a grid table message
5804 bool wxGrid::InsertCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
5806 // TODO: something with updateLabels flag
5810 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5816 if (IsCellEditControlEnabled())
5817 DisableCellEditControl();
5819 return m_table
->InsertCols( pos
, numCols
);
5820 // the table will have sent the results of the insert col
5821 // operation to this view object as a grid table message
5827 bool wxGrid::AppendCols( int numCols
, bool WXUNUSED(updateLabels
) )
5829 // TODO: something with updateLabels flag
5833 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5837 return ( m_table
&& m_table
->AppendCols( numCols
) );
5838 // the table will have sent the results of the append col
5839 // operation to this view object as a grid table message
5843 bool wxGrid::DeleteCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
5845 // TODO: something with updateLabels flag
5849 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5855 if (IsCellEditControlEnabled())
5856 DisableCellEditControl();
5858 return ( m_table
->DeleteCols( pos
, numCols
) );
5859 // the table will have sent the results of the delete col
5860 // operation to this view object as a grid table message
5868 // ----- event handlers
5871 // Generate a grid event based on a mouse event and
5872 // return the result of ProcessEvent()
5874 int wxGrid::SendEvent( const wxEventType type
,
5876 wxMouseEvent
& mouseEv
)
5881 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
5883 int rowOrCol
= (row
== -1 ? col
: row
);
5885 wxGridSizeEvent
gridEvt( GetId(),
5889 mouseEv
.GetX() + GetRowLabelSize(),
5890 mouseEv
.GetY() + GetColLabelSize(),
5891 mouseEv
.ControlDown(),
5892 mouseEv
.ShiftDown(),
5894 mouseEv
.MetaDown() );
5896 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5897 vetoed
= !gridEvt
.IsAllowed();
5899 else if ( type
== wxEVT_GRID_RANGE_SELECT
)
5901 // Right now, it should _never_ end up here!
5902 wxGridRangeSelectEvent
gridEvt( GetId(),
5906 m_selectingBottomRight
,
5908 mouseEv
.ControlDown(),
5909 mouseEv
.ShiftDown(),
5911 mouseEv
.MetaDown() );
5913 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5914 vetoed
= !gridEvt
.IsAllowed();
5918 wxGridEvent
gridEvt( GetId(),
5922 mouseEv
.GetX() + GetRowLabelSize(),
5923 mouseEv
.GetY() + GetColLabelSize(),
5925 mouseEv
.ControlDown(),
5926 mouseEv
.ShiftDown(),
5928 mouseEv
.MetaDown() );
5929 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5930 vetoed
= !gridEvt
.IsAllowed();
5933 // A Veto'd event may not be `claimed' so test this first
5934 if (vetoed
) return -1;
5935 return claimed
? 1 : 0;
5939 // Generate a grid event of specified type and return the result
5940 // of ProcessEvent().
5942 int wxGrid::SendEvent( const wxEventType type
,
5948 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
5950 int rowOrCol
= (row
== -1 ? col
: row
);
5952 wxGridSizeEvent
gridEvt( GetId(),
5957 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5958 vetoed
= !gridEvt
.IsAllowed();
5962 wxGridEvent
gridEvt( GetId(),
5967 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5968 vetoed
= !gridEvt
.IsAllowed();
5971 // A Veto'd event may not be `claimed' so test this first
5972 if (vetoed
) return -1;
5973 return claimed
? 1 : 0;
5977 void wxGrid::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
5979 wxPaintDC
dc(this); // needed to prevent zillions of paint events on MSW
5982 void wxGrid::Refresh(bool eraseb
, const wxRect
* rect
)
5984 // Don't do anything if between Begin/EndBatch...
5985 // EndBatch() will do all this on the last nested one anyway.
5986 if (! GetBatchCount())
5988 // Refresh to get correct scrolled position:
5989 wxScrolledWindow::Refresh(eraseb
,rect
);
5993 int rect_x
, rect_y
, rectWidth
, rectHeight
;
5994 int width_label
, width_cell
, height_label
, height_cell
;
5997 //Copy rectangle can get scroll offsets..
5998 rect_x
= rect
->GetX();
5999 rect_y
= rect
->GetY();
6000 rectWidth
= rect
->GetWidth();
6001 rectHeight
= rect
->GetHeight();
6003 width_label
= m_rowLabelWidth
- rect_x
;
6004 if (width_label
> rectWidth
) width_label
= rectWidth
;
6006 height_label
= m_colLabelHeight
- rect_y
;
6007 if (height_label
> rectHeight
) height_label
= rectHeight
;
6009 if (rect_x
> m_rowLabelWidth
)
6011 x
= rect_x
- m_rowLabelWidth
;
6012 width_cell
= rectWidth
;
6017 width_cell
= rectWidth
- (m_rowLabelWidth
- rect_x
);
6020 if (rect_y
> m_colLabelHeight
)
6022 y
= rect_y
- m_colLabelHeight
;
6023 height_cell
= rectHeight
;
6028 height_cell
= rectHeight
- (m_colLabelHeight
- rect_y
);
6031 // Paint corner label part intersecting rect.
6032 if ( width_label
> 0 && height_label
> 0 )
6034 wxRect
anotherrect(rect_x
, rect_y
, width_label
, height_label
);
6035 m_cornerLabelWin
->Refresh(eraseb
, &anotherrect
);
6038 // Paint col labels part intersecting rect.
6039 if ( width_cell
> 0 && height_label
> 0 )
6041 wxRect
anotherrect(x
, rect_y
, width_cell
, height_label
);
6042 m_colLabelWin
->Refresh(eraseb
, &anotherrect
);
6045 // Paint row labels part intersecting rect.
6046 if ( width_label
> 0 && height_cell
> 0 )
6048 wxRect
anotherrect(rect_x
, y
, width_label
, height_cell
);
6049 m_rowLabelWin
->Refresh(eraseb
, &anotherrect
);
6052 // Paint cell area part intersecting rect.
6053 if ( width_cell
> 0 && height_cell
> 0 )
6055 wxRect
anotherrect(x
, y
, width_cell
, height_cell
);
6056 m_gridWin
->Refresh(eraseb
, &anotherrect
);
6061 m_cornerLabelWin
->Refresh(eraseb
, NULL
);
6062 m_colLabelWin
->Refresh(eraseb
, NULL
);
6063 m_rowLabelWin
->Refresh(eraseb
, NULL
);
6064 m_gridWin
->Refresh(eraseb
, NULL
);
6069 void wxGrid::OnSize( wxSizeEvent
& event
)
6071 // position the child windows
6074 // don't call CalcDimensions() from here, the base class handles the size
6080 void wxGrid::OnKeyDown( wxKeyEvent
& event
)
6082 if ( m_inOnKeyDown
)
6084 // shouldn't be here - we are going round in circles...
6086 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
6089 m_inOnKeyDown
= TRUE
;
6091 // propagate the event up and see if it gets processed
6093 wxWindow
*parent
= GetParent();
6094 wxKeyEvent
keyEvt( event
);
6095 keyEvt
.SetEventObject( parent
);
6097 if ( !parent
->GetEventHandler()->ProcessEvent( keyEvt
) )
6100 // try local handlers
6102 switch ( event
.GetKeyCode() )
6105 if ( event
.ControlDown() )
6107 MoveCursorUpBlock( event
.ShiftDown() );
6111 MoveCursorUp( event
.ShiftDown() );
6116 if ( event
.ControlDown() )
6118 MoveCursorDownBlock( event
.ShiftDown() );
6122 MoveCursorDown( event
.ShiftDown() );
6127 if ( event
.ControlDown() )
6129 MoveCursorLeftBlock( event
.ShiftDown() );
6133 MoveCursorLeft( event
.ShiftDown() );
6138 if ( event
.ControlDown() )
6140 MoveCursorRightBlock( event
.ShiftDown() );
6144 MoveCursorRight( event
.ShiftDown() );
6149 case WXK_NUMPAD_ENTER
:
6150 if ( event
.ControlDown() )
6152 event
.Skip(); // to let the edit control have the return
6156 if ( GetGridCursorRow() < GetNumberRows()-1 )
6158 MoveCursorDown( event
.ShiftDown() );
6162 // at the bottom of a column
6163 HideCellEditControl();
6164 SaveEditControlValue();
6174 if (event
.ShiftDown())
6176 if ( GetGridCursorCol() > 0 )
6178 MoveCursorLeft( FALSE
);
6183 HideCellEditControl();
6184 SaveEditControlValue();
6189 if ( GetGridCursorCol() < GetNumberCols()-1 )
6191 MoveCursorRight( FALSE
);
6196 HideCellEditControl();
6197 SaveEditControlValue();
6203 if ( event
.ControlDown() )
6205 MakeCellVisible( 0, 0 );
6206 SetCurrentCell( 0, 0 );
6215 if ( event
.ControlDown() )
6217 MakeCellVisible( m_numRows
-1, m_numCols
-1 );
6218 SetCurrentCell( m_numRows
-1, m_numCols
-1 );
6235 if ( event
.ControlDown() )
6239 m_selection
->ToggleCellSelection( m_currentCellCoords
.GetRow(),
6240 m_currentCellCoords
.GetCol(),
6241 event
.ControlDown(),
6248 if ( !IsEditable() )
6250 MoveCursorRight( FALSE
);
6253 // Otherwise fall through to default
6256 // is it possible to edit the current cell at all?
6257 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
6259 // yes, now check whether the cells editor accepts the key
6260 int row
= m_currentCellCoords
.GetRow();
6261 int col
= m_currentCellCoords
.GetCol();
6262 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6263 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
6265 // <F2> is special and will always start editing, for
6266 // other keys - ask the editor itself
6267 if ( (event
.GetKeyCode() == WXK_F2
&& !event
.HasModifiers())
6268 || editor
->IsAcceptedKey(event
) )
6270 // ensure cell is visble
6271 MakeCellVisible(row
, col
);
6272 EnableCellEditControl();
6274 // a problem can arise if the cell is not completely
6275 // visible (even after calling MakeCellVisible the
6276 // control is not created and calling StartingKey will
6278 if( editor
->IsCreated() && m_cellEditCtrlEnabled
) editor
->StartingKey(event
);
6290 // let others process char events with modifiers or all
6291 // char events for readonly cells
6298 m_inOnKeyDown
= FALSE
;
6301 void wxGrid::OnKeyUp( wxKeyEvent
& event
)
6303 // try local handlers
6305 if ( event
.GetKeyCode() == WXK_SHIFT
)
6307 if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
6308 m_selectingBottomRight
!= wxGridNoCellCoords
)
6312 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
6313 m_selectingTopLeft
.GetCol(),
6314 m_selectingBottomRight
.GetRow(),
6315 m_selectingBottomRight
.GetCol(),
6316 event
.ControlDown(),
6323 m_selectingTopLeft
= wxGridNoCellCoords
;
6324 m_selectingBottomRight
= wxGridNoCellCoords
;
6325 m_selectingKeyboard
= wxGridNoCellCoords
;
6329 void wxGrid::OnEraseBackground(wxEraseEvent
&)
6333 void wxGrid::SetCurrentCell( const wxGridCellCoords
& coords
)
6335 if ( SendEvent( wxEVT_GRID_SELECT_CELL
, coords
.GetRow(), coords
.GetCol() ) )
6337 // the event has been intercepted - do nothing
6341 wxClientDC
dc(m_gridWin
);
6344 if ( m_currentCellCoords
!= wxGridNoCellCoords
)
6346 HideCellEditControl();
6347 DisableCellEditControl();
6349 if ( IsVisible( m_currentCellCoords
, FALSE
) )
6352 r
= BlockToDeviceRect(m_currentCellCoords
, m_currentCellCoords
);
6353 if ( !m_gridLinesEnabled
)
6361 wxGridCellCoordsArray cells
= CalcCellsExposed( r
);
6363 // Otherwise refresh redraws the highlight!
6364 m_currentCellCoords
= coords
;
6366 DrawGridCellArea(dc
,cells
);
6367 DrawAllGridLines( dc
, r
);
6371 m_currentCellCoords
= coords
;
6373 wxGridCellAttr
* attr
= GetCellAttr(coords
);
6374 DrawCellHighlight(dc
, attr
);
6379 void wxGrid::HighlightBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
)
6382 wxGridCellCoords updateTopLeft
, updateBottomRight
;
6386 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
6389 rightCol
= GetNumberCols() - 1;
6391 else if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
6394 bottomRow
= GetNumberRows() - 1;
6398 if ( topRow
> bottomRow
)
6405 if ( leftCol
> rightCol
)
6412 updateTopLeft
= wxGridCellCoords( topRow
, leftCol
);
6413 updateBottomRight
= wxGridCellCoords( bottomRow
, rightCol
);
6415 // First the case that we selected a completely new area
6416 if ( m_selectingTopLeft
== wxGridNoCellCoords
||
6417 m_selectingBottomRight
== wxGridNoCellCoords
)
6420 rect
= BlockToDeviceRect( wxGridCellCoords ( topRow
, leftCol
),
6421 wxGridCellCoords ( bottomRow
, rightCol
) );
6422 m_gridWin
->Refresh( FALSE
, &rect
);
6424 // Now handle changing an existing selection area.
6425 else if ( m_selectingTopLeft
!= updateTopLeft
||
6426 m_selectingBottomRight
!= updateBottomRight
)
6428 // Compute two optimal update rectangles:
6429 // Either one rectangle is a real subset of the
6430 // other, or they are (almost) disjoint!
6432 bool need_refresh
[4];
6436 need_refresh
[3] = FALSE
;
6439 // Store intermediate values
6440 wxCoord oldLeft
= m_selectingTopLeft
.GetCol();
6441 wxCoord oldTop
= m_selectingTopLeft
.GetRow();
6442 wxCoord oldRight
= m_selectingBottomRight
.GetCol();
6443 wxCoord oldBottom
= m_selectingBottomRight
.GetRow();
6445 // Determine the outer/inner coordinates.
6446 if (oldLeft
> leftCol
)
6452 if (oldTop
> topRow
)
6458 if (oldRight
< rightCol
)
6461 oldRight
= rightCol
;
6464 if (oldBottom
< bottomRow
)
6467 oldBottom
= bottomRow
;
6471 // Now, either the stuff marked old is the outer
6472 // rectangle or we don't have a situation where one
6473 // is contained in the other.
6475 if ( oldLeft
< leftCol
)
6477 // Refresh the newly selected or deselected
6478 // area to the left of the old or new selection.
6479 need_refresh
[0] = TRUE
;
6480 rect
[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
6482 wxGridCellCoords ( oldBottom
,
6486 if ( oldTop
< topRow
)
6488 // Refresh the newly selected or deselected
6489 // area above the old or new selection.
6490 need_refresh
[1] = TRUE
;
6491 rect
[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
6493 wxGridCellCoords ( topRow
- 1,
6497 if ( oldRight
> rightCol
)
6499 // Refresh the newly selected or deselected
6500 // area to the right of the old or new selection.
6501 need_refresh
[2] = TRUE
;
6502 rect
[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
6504 wxGridCellCoords ( oldBottom
,
6508 if ( oldBottom
> bottomRow
)
6510 // Refresh the newly selected or deselected
6511 // area below the old or new selection.
6512 need_refresh
[3] = TRUE
;
6513 rect
[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow
+ 1,
6515 wxGridCellCoords ( oldBottom
,
6519 // various Refresh() calls
6520 for (i
= 0; i
< 4; i
++ )
6521 if ( need_refresh
[i
] && rect
[i
] != wxGridNoCellRect
)
6522 m_gridWin
->Refresh( FALSE
, &(rect
[i
]) );
6525 m_selectingTopLeft
= updateTopLeft
;
6526 m_selectingBottomRight
= updateBottomRight
;
6530 // ------ functions to get/send data (see also public functions)
6533 bool wxGrid::GetModelValues()
6535 // Hide the editor, so it won't hide a changed value.
6536 HideCellEditControl();
6540 // all we need to do is repaint the grid
6542 m_gridWin
->Refresh();
6550 bool wxGrid::SetModelValues()
6554 // Disable the editor, so it won't hide a changed value.
6555 // Do we also want to save the current value of the editor first?
6557 DisableCellEditControl();
6561 for ( row
= 0; row
< m_numRows
; row
++ )
6563 for ( col
= 0; col
< m_numCols
; col
++ )
6565 m_table
->SetValue( row
, col
, GetCellValue(row
, col
) );
6577 // Note - this function only draws cells that are in the list of
6578 // exposed cells (usually set from the update region by
6579 // CalcExposedCells)
6581 void wxGrid::DrawGridCellArea( wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
6583 if ( !m_numRows
|| !m_numCols
) return;
6585 int i
, numCells
= cells
.GetCount();
6586 int row
, col
, cell_rows
, cell_cols
;
6587 wxGridCellCoordsArray redrawCells
;
6589 for ( i
= numCells
-1; i
>= 0; i
-- )
6591 row
= cells
[i
].GetRow();
6592 col
= cells
[i
].GetCol();
6593 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
6595 // If this cell is part of a multicell block, find owner for repaint
6596 if ( cell_rows
<= 0 || cell_cols
<= 0 )
6598 wxGridCellCoords
cell(row
+cell_rows
, col
+cell_cols
);
6599 bool marked
= FALSE
;
6600 for ( int j
= 0; j
< numCells
; j
++ )
6602 if ( cell
== cells
[j
] )
6610 int count
= redrawCells
.GetCount();
6611 for (int j
= 0; j
< count
; j
++)
6613 if ( cell
== redrawCells
[j
] )
6619 if (!marked
) redrawCells
.Add( cell
);
6621 continue; // don't bother drawing this cell
6624 // If this cell is empty, find cell to left that might want to overflow
6625 if (m_table
&& m_table
->IsEmptyCell(row
, col
))
6627 for ( int l
= 0; l
< cell_rows
; l
++ )
6629 // find a cell in this row to left alreay marked for repaint
6631 for (int k
= 0; k
< int(redrawCells
.GetCount()); k
++)
6632 if ((redrawCells
[k
].GetCol() < left
) &&
6633 (redrawCells
[k
].GetRow() == row
))
6634 left
=redrawCells
[k
].GetCol();
6636 if (left
== col
) left
= 0; // oh well
6638 for (int j
= col
-1; j
>= left
; j
--)
6640 if (!m_table
->IsEmptyCell(row
+l
, j
))
6642 if (GetCellOverflow(row
+l
, j
))
6644 wxGridCellCoords
cell(row
+l
, j
);
6645 bool marked
= FALSE
;
6647 for (int k
= 0; k
< numCells
; k
++)
6649 if ( cell
== cells
[k
] )
6657 int count
= redrawCells
.GetCount();
6658 for (int k
= 0; k
< count
; k
++)
6660 if ( cell
== redrawCells
[k
] )
6666 if (!marked
) redrawCells
.Add( cell
);
6674 DrawCell( dc
, cells
[i
] );
6677 numCells
= redrawCells
.GetCount();
6679 for ( i
= numCells
- 1; i
>= 0; i
-- )
6681 DrawCell( dc
, redrawCells
[i
] );
6686 void wxGrid::DrawGridSpace( wxDC
& dc
)
6689 m_gridWin
->GetClientSize( &cw
, &ch
);
6692 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6694 int rightCol
= m_numCols
> 0 ? GetColRight(m_numCols
- 1) : 0;
6695 int bottomRow
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0 ;
6697 if ( right
> rightCol
|| bottom
> bottomRow
)
6700 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6702 dc
.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID
) );
6703 dc
.SetPen( *wxTRANSPARENT_PEN
);
6705 if ( right
> rightCol
)
6707 dc
.DrawRectangle( rightCol
, top
, right
- rightCol
, ch
);
6710 if ( bottom
> bottomRow
)
6712 dc
.DrawRectangle( left
, bottomRow
, cw
, bottom
- bottomRow
);
6718 void wxGrid::DrawCell( wxDC
& dc
, const wxGridCellCoords
& coords
)
6720 int row
= coords
.GetRow();
6721 int col
= coords
.GetCol();
6723 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6726 // we draw the cell border ourselves
6727 #if !WXGRID_DRAW_LINES
6728 if ( m_gridLinesEnabled
)
6729 DrawCellBorder( dc
, coords
);
6732 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6734 bool isCurrent
= coords
== m_currentCellCoords
;
6736 wxRect rect
= CellToRect( row
, col
);
6738 // if the editor is shown, we should use it and not the renderer
6739 // Note: However, only if it is really _shown_, i.e. not hidden!
6740 if ( isCurrent
&& IsCellEditControlShown() )
6742 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
6743 editor
->PaintBackground(rect
, attr
);
6748 // but all the rest is drawn by the cell renderer and hence may be
6750 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
6751 renderer
->Draw(*this, *attr
, dc
, rect
, row
, col
, IsInSelection(coords
));
6758 void wxGrid::DrawCellHighlight( wxDC
& dc
, const wxGridCellAttr
*attr
)
6760 int row
= m_currentCellCoords
.GetRow();
6761 int col
= m_currentCellCoords
.GetCol();
6763 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6766 wxRect rect
= CellToRect(row
, col
);
6768 // hmmm... what could we do here to show that the cell is disabled?
6769 // for now, I just draw a thinner border than for the other ones, but
6770 // it doesn't look really good
6772 int penWidth
= attr
->IsReadOnly() ? m_cellHighlightROPenWidth
: m_cellHighlightPenWidth
;
6776 // The center of th drawn line is where the position/width/height of
6777 // the rectangle is actually at, (on wxMSW atr least,) so we will
6778 // reduce the size of the rectangle to compensate for the thickness of
6779 // the line. If this is too strange on non wxMSW platforms then
6780 // please #ifdef this appropriately.
6781 rect
.x
+= penWidth
/2;
6782 rect
.y
+= penWidth
/2;
6783 rect
.width
-= penWidth
-1;
6784 rect
.height
-= penWidth
-1;
6787 // Now draw the rectangle
6788 // use the cellHighlightColour if the cell is inside a selection, this
6789 // will ensure the cell is always visible.
6790 dc
.SetPen(wxPen(IsInSelection(row
,col
)?m_selectionForeground
:m_cellHighlightColour
, penWidth
, wxSOLID
));
6791 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
6792 dc
.DrawRectangle(rect
);
6796 // VZ: my experiments with 3d borders...
6798 // how to properly set colours for arbitrary bg?
6799 wxCoord x1
= rect
.x
,
6801 x2
= rect
.x
+ rect
.width
-1,
6802 y2
= rect
.y
+ rect
.height
-1;
6804 dc
.SetPen(*wxWHITE_PEN
);
6805 dc
.DrawLine(x1
, y1
, x2
, y1
);
6806 dc
.DrawLine(x1
, y1
, x1
, y2
);
6808 dc
.DrawLine(x1
+ 1, y2
- 1, x2
- 1, y2
- 1);
6809 dc
.DrawLine(x2
- 1, y1
+ 1, x2
- 1, y2
);
6811 dc
.SetPen(*wxBLACK_PEN
);
6812 dc
.DrawLine(x1
, y2
, x2
, y2
);
6813 dc
.DrawLine(x2
, y1
, x2
, y2
+1);
6818 void wxGrid::DrawCellBorder( wxDC
& dc
, const wxGridCellCoords
& coords
)
6820 int row
= coords
.GetRow();
6821 int col
= coords
.GetCol();
6822 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6825 dc
.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID
) );
6827 wxRect rect
= CellToRect( row
, col
);
6829 // right hand border
6831 dc
.DrawLine( rect
.x
+ rect
.width
, rect
.y
,
6832 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
+ 1 );
6836 dc
.DrawLine( rect
.x
, rect
.y
+ rect
.height
,
6837 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
6840 void wxGrid::DrawHighlight(wxDC
& dc
,const wxGridCellCoordsArray
& cells
)
6842 // This if block was previously in wxGrid::OnPaint but that doesn't
6843 // seem to get called under wxGTK - MB
6845 if ( m_currentCellCoords
== wxGridNoCellCoords
&&
6846 m_numRows
&& m_numCols
)
6848 m_currentCellCoords
.Set(0, 0);
6851 if ( IsCellEditControlShown() )
6853 // don't show highlight when the edit control is shown
6857 // if the active cell was repainted, repaint its highlight too because it
6858 // might have been damaged by the grid lines
6859 size_t count
= cells
.GetCount();
6860 for ( size_t n
= 0; n
< count
; n
++ )
6862 if ( cells
[n
] == m_currentCellCoords
)
6864 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
6865 DrawCellHighlight(dc
, attr
);
6873 // TODO: remove this ???
6874 // This is used to redraw all grid lines e.g. when the grid line colour
6877 void wxGrid::DrawAllGridLines( wxDC
& dc
, const wxRegion
& WXUNUSED(reg
) )
6879 #if !WXGRID_DRAW_LINES
6883 if ( !m_gridLinesEnabled
||
6885 !m_numCols
) return;
6887 int top
, bottom
, left
, right
;
6889 #if 0 //#ifndef __WXGTK__
6893 m_gridWin
->GetClientSize(&cw
, &ch
);
6895 // virtual coords of visible area
6897 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6898 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6903 reg
.GetBox(x
, y
, w
, h
);
6904 CalcUnscrolledPosition( x
, y
, &left
, &top
);
6905 CalcUnscrolledPosition( x
+ w
, y
+ h
, &right
, &bottom
);
6909 m_gridWin
->GetClientSize(&cw
, &ch
);
6910 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6911 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6914 // avoid drawing grid lines past the last row and col
6916 right
= wxMin( right
, GetColRight(m_numCols
- 1) );
6917 bottom
= wxMin( bottom
, GetRowBottom(m_numRows
- 1) );
6919 // no gridlines inside multicells, clip them out
6920 int leftCol
= XToCol(left
);
6921 int topRow
= YToRow(top
);
6922 int rightCol
= XToCol(right
);
6923 int bottomRow
= YToRow(bottom
);
6924 wxRegion
clippedcells(0, 0, cw
, ch
);
6926 if ((leftCol
>= 0) && (topRow
>= 0))
6928 if (rightCol
< 0) rightCol
= m_numCols
;
6929 if (bottomRow
< 0) bottomRow
= m_numRows
;
6931 int i
, j
, cell_rows
, cell_cols
;
6934 for (j
=topRow
; j
<bottomRow
; j
++)
6936 for (i
=leftCol
; i
<rightCol
; i
++)
6938 GetCellSize( j
, i
, &cell_rows
, &cell_cols
);
6939 if ((cell_rows
> 1) || (cell_cols
> 1))
6941 rect
= CellToRect(j
,i
);
6942 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
6943 clippedcells
.Subtract(rect
);
6945 else if ((cell_rows
< 0) || (cell_cols
< 0))
6947 rect
= CellToRect(j
+cell_rows
, i
+cell_cols
);
6948 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
6949 clippedcells
.Subtract(rect
);
6954 dc
.SetClippingRegion( clippedcells
);
6956 dc
.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID
) );
6958 // horizontal grid lines
6961 for ( i
= internalYToRow(top
); i
< m_numRows
; i
++ )
6963 int bot
= GetRowBottom(i
) - 1;
6972 dc
.DrawLine( left
, bot
, right
, bot
);
6977 // vertical grid lines
6979 for ( i
= internalXToCol(left
); i
< m_numCols
; i
++ )
6981 int colRight
= GetColRight(i
) - 1;
6982 if ( colRight
> right
)
6987 if ( colRight
>= left
)
6989 dc
.DrawLine( colRight
, top
, colRight
, bottom
);
6992 dc
.DestroyClippingRegion();
6996 void wxGrid::DrawRowLabels( wxDC
& dc
,const wxArrayInt
& rows
)
6998 if ( !m_numRows
) return;
7001 size_t numLabels
= rows
.GetCount();
7003 for ( i
= 0; i
< numLabels
; i
++ )
7005 DrawRowLabel( dc
, rows
[i
] );
7010 void wxGrid::DrawRowLabel( wxDC
& dc
, int row
)
7012 if ( GetRowHeight(row
) <= 0 )
7015 int rowTop
= GetRowTop(row
),
7016 rowBottom
= GetRowBottom(row
) - 1;
7018 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW
),1, wxSOLID
) );
7019 dc
.DrawLine( m_rowLabelWidth
-1, rowTop
,
7020 m_rowLabelWidth
-1, rowBottom
);
7022 dc
.DrawLine( 0, rowTop
, 0, rowBottom
);
7024 dc
.DrawLine( 0, rowBottom
, m_rowLabelWidth
, rowBottom
);
7026 dc
.SetPen( *wxWHITE_PEN
);
7027 dc
.DrawLine( 1, rowTop
, 1, rowBottom
);
7028 dc
.DrawLine( 1, rowTop
, m_rowLabelWidth
-1, rowTop
);
7030 dc
.SetBackgroundMode( wxTRANSPARENT
);
7031 dc
.SetTextForeground( GetLabelTextColour() );
7032 dc
.SetFont( GetLabelFont() );
7035 GetRowLabelAlignment( &hAlign
, &vAlign
);
7039 rect
.SetY( GetRowTop(row
) + 2 );
7040 rect
.SetWidth( m_rowLabelWidth
- 4 );
7041 rect
.SetHeight( GetRowHeight(row
) - 4 );
7042 DrawTextRectangle( dc
, GetRowLabelValue( row
), rect
, hAlign
, vAlign
);
7046 void wxGrid::DrawColLabels( wxDC
& dc
,const wxArrayInt
& cols
)
7048 if ( !m_numCols
) return;
7051 size_t numLabels
= cols
.GetCount();
7053 for ( i
= 0; i
< numLabels
; i
++ )
7055 DrawColLabel( dc
, cols
[i
] );
7060 void wxGrid::DrawColLabel( wxDC
& dc
, int col
)
7062 if ( GetColWidth(col
) <= 0 )
7065 int colLeft
= GetColLeft(col
),
7066 colRight
= GetColRight(col
) - 1;
7068 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW
),1, wxSOLID
) );
7069 dc
.DrawLine( colRight
, 0,
7070 colRight
, m_colLabelHeight
-1 );
7072 dc
.DrawLine( colLeft
, 0, colRight
, 0 );
7074 dc
.DrawLine( colLeft
, m_colLabelHeight
-1,
7075 colRight
+1, m_colLabelHeight
-1 );
7077 dc
.SetPen( *wxWHITE_PEN
);
7078 dc
.DrawLine( colLeft
, 1, colLeft
, m_colLabelHeight
-1 );
7079 dc
.DrawLine( colLeft
, 1, colRight
, 1 );
7081 dc
.SetBackgroundMode( wxTRANSPARENT
);
7082 dc
.SetTextForeground( GetLabelTextColour() );
7083 dc
.SetFont( GetLabelFont() );
7085 int hAlign
, vAlign
, orient
;
7086 GetColLabelAlignment( &hAlign
, &vAlign
);
7087 orient
= GetColLabelTextOrientation();
7090 rect
.SetX( colLeft
+ 2 );
7092 rect
.SetWidth( GetColWidth(col
) - 4 );
7093 rect
.SetHeight( m_colLabelHeight
- 4 );
7094 DrawTextRectangle( dc
, GetColLabelValue( col
), rect
, hAlign
, vAlign
, orient
);
7097 void wxGrid::DrawTextRectangle( wxDC
& dc
,
7098 const wxString
& value
,
7102 int textOrientation
)
7104 wxArrayString lines
;
7106 StringToLines( value
, lines
);
7109 //Forward to new API.
7110 DrawTextRectangle( dc
,
7119 void wxGrid::DrawTextRectangle( wxDC
& dc
,
7120 const wxArrayString
& lines
,
7124 int textOrientation
)
7126 long textWidth
, textHeight
;
7127 long lineWidth
, lineHeight
;
7130 dc
.SetClippingRegion( rect
);
7132 nLines
= lines
.GetCount();
7138 if( textOrientation
== wxHORIZONTAL
)
7139 GetTextBoxSize(dc
, lines
, &textWidth
, &textHeight
);
7141 GetTextBoxSize( dc
, lines
, &textHeight
, &textWidth
);
7145 case wxALIGN_BOTTOM
:
7146 if( textOrientation
== wxHORIZONTAL
)
7147 y
= rect
.y
+ (rect
.height
- textHeight
- 1);
7149 x
= rect
.x
+ rect
.width
- textWidth
;
7152 case wxALIGN_CENTRE
:
7153 if( textOrientation
== wxHORIZONTAL
)
7154 y
= rect
.y
+ ((rect
.height
- textHeight
)/2);
7156 x
= rect
.x
+ ((rect
.width
- textWidth
)/2);
7161 if( textOrientation
== wxHORIZONTAL
)
7168 // Align each line of a multi-line label
7169 for( l
= 0; l
< nLines
; l
++ )
7171 dc
.GetTextExtent(lines
[l
], &lineWidth
, &lineHeight
);
7173 switch( horizAlign
)
7176 if( textOrientation
== wxHORIZONTAL
)
7177 x
= rect
.x
+ (rect
.width
- lineWidth
- 1);
7179 y
= rect
.y
+ lineWidth
+ 1;
7182 case wxALIGN_CENTRE
:
7183 if( textOrientation
== wxHORIZONTAL
)
7184 x
= rect
.x
+ ((rect
.width
- lineWidth
)/2);
7186 y
= rect
.y
+ rect
.height
- ((rect
.height
- lineWidth
)/2);
7191 if( textOrientation
== wxHORIZONTAL
)
7194 y
= rect
.y
+ rect
.height
- 1;
7198 if( textOrientation
== wxHORIZONTAL
)
7200 dc
.DrawText( lines
[l
], (int)x
, (int)y
);
7205 dc
.DrawRotatedText( lines
[l
], (int)x
, (int)y
, 90.0 );
7210 dc
.DestroyClippingRegion();
7214 // Split multi line text up into an array of strings. Any existing
7215 // contents of the string array are preserved.
7217 void wxGrid::StringToLines( const wxString
& value
, wxArrayString
& lines
)
7221 wxString eol
= wxTextFile::GetEOL( wxTextFileType_Unix
);
7222 wxString tVal
= wxTextFile::Translate( value
, wxTextFileType_Unix
);
7224 while ( startPos
< (int)tVal
.Length() )
7226 pos
= tVal
.Mid(startPos
).Find( eol
);
7231 else if ( pos
== 0 )
7233 lines
.Add( wxEmptyString
);
7237 lines
.Add( value
.Mid(startPos
, pos
) );
7241 if ( startPos
< (int)value
.Length() )
7243 lines
.Add( value
.Mid( startPos
) );
7248 void wxGrid::GetTextBoxSize( wxDC
& dc
,
7249 const wxArrayString
& lines
,
7250 long *width
, long *height
)
7257 for ( i
= 0; i
< lines
.GetCount(); i
++ )
7259 dc
.GetTextExtent( lines
[i
], &lineW
, &lineH
);
7260 w
= wxMax( w
, lineW
);
7269 // ------ Batch processing.
7271 void wxGrid::EndBatch()
7273 if ( m_batchCount
> 0 )
7276 if ( !m_batchCount
)
7279 m_rowLabelWin
->Refresh();
7280 m_colLabelWin
->Refresh();
7281 m_cornerLabelWin
->Refresh();
7282 m_gridWin
->Refresh();
7287 // Use this, rather than wxWindow::Refresh(), to force an immediate
7288 // repainting of the grid. Has no effect if you are already inside a
7289 // BeginBatch / EndBatch block.
7291 void wxGrid::ForceRefresh()
7299 // ------ Edit control functions
7303 void wxGrid::EnableEditing( bool edit
)
7305 // TODO: improve this ?
7307 if ( edit
!= m_editable
)
7309 if(!edit
) EnableCellEditControl(edit
);
7315 void wxGrid::EnableCellEditControl( bool enable
)
7320 if ( m_currentCellCoords
== wxGridNoCellCoords
)
7321 SetCurrentCell( 0, 0 );
7323 if ( enable
!= m_cellEditCtrlEnabled
)
7327 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN
) <0)
7330 // this should be checked by the caller!
7331 wxASSERT_MSG( CanEnableCellControl(),
7332 _T("can't enable editing for this cell!") );
7334 // do it before ShowCellEditControl()
7335 m_cellEditCtrlEnabled
= enable
;
7337 ShowCellEditControl();
7341 //FIXME:add veto support
7342 SendEvent( wxEVT_GRID_EDITOR_HIDDEN
);
7344 HideCellEditControl();
7345 SaveEditControlValue();
7347 // do it after HideCellEditControl()
7348 m_cellEditCtrlEnabled
= enable
;
7353 bool wxGrid::IsCurrentCellReadOnly() const
7356 wxGridCellAttr
* attr
= ((wxGrid
*)this)->GetCellAttr(m_currentCellCoords
);
7357 bool readonly
= attr
->IsReadOnly();
7363 bool wxGrid::CanEnableCellControl() const
7365 return m_editable
&& !IsCurrentCellReadOnly();
7368 bool wxGrid::IsCellEditControlEnabled() const
7370 // the cell edit control might be disable for all cells or just for the
7371 // current one if it's read only
7372 return m_cellEditCtrlEnabled
? !IsCurrentCellReadOnly() : FALSE
;
7375 bool wxGrid::IsCellEditControlShown() const
7377 bool isShown
= FALSE
;
7379 if ( m_cellEditCtrlEnabled
)
7381 int row
= m_currentCellCoords
.GetRow();
7382 int col
= m_currentCellCoords
.GetCol();
7383 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7384 wxGridCellEditor
* editor
= attr
->GetEditor((wxGrid
*) this, row
, col
);
7389 if ( editor
->IsCreated() )
7391 isShown
= editor
->GetControl()->IsShown();
7401 void wxGrid::ShowCellEditControl()
7403 if ( IsCellEditControlEnabled() )
7405 if ( !IsVisible( m_currentCellCoords
) )
7407 m_cellEditCtrlEnabled
= FALSE
;
7412 wxRect rect
= CellToRect( m_currentCellCoords
);
7413 int row
= m_currentCellCoords
.GetRow();
7414 int col
= m_currentCellCoords
.GetCol();
7416 // if this is part of a multicell, find owner (topleft)
7417 int cell_rows
, cell_cols
;
7418 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7419 if ( cell_rows
<= 0 || cell_cols
<= 0 )
7423 m_currentCellCoords
.SetRow( row
);
7424 m_currentCellCoords
.SetCol( col
);
7427 // convert to scrolled coords
7429 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7431 // done in PaintBackground()
7433 // erase the highlight and the cell contents because the editor
7434 // might not cover the entire cell
7435 wxClientDC
dc( m_gridWin
);
7437 dc
.SetBrush(*wxLIGHT_GREY_BRUSH
); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
7438 dc
.SetPen(*wxTRANSPARENT_PEN
);
7439 dc
.DrawRectangle(rect
);
7442 // cell is shifted by one pixel
7443 // However, don't allow x or y to become negative
7444 // since the SetSize() method interprets that as
7451 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7452 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
7453 if ( !editor
->IsCreated() )
7455 editor
->Create(m_gridWin
, -1,
7456 new wxGridCellEditorEvtHandler(this, editor
));
7458 wxGridEditorCreatedEvent
evt(GetId(),
7459 wxEVT_GRID_EDITOR_CREATED
,
7463 editor
->GetControl());
7464 GetEventHandler()->ProcessEvent(evt
);
7468 // resize editor to overflow into righthand cells if allowed
7469 int maxWidth
= rect
.width
;
7470 wxString value
= GetCellValue(row
, col
);
7471 if ( (value
!= wxEmptyString
) && (attr
->GetOverflow()) )
7474 GetTextExtent(value
, &maxWidth
, &y
,
7475 NULL
, NULL
, &attr
->GetFont());
7476 if (maxWidth
< rect
.width
) maxWidth
= rect
.width
;
7478 int client_right
= m_gridWin
->GetClientSize().GetWidth();
7479 if (rect
.x
+maxWidth
> client_right
)
7480 maxWidth
= client_right
- rect
.x
;
7482 if ((maxWidth
> rect
.width
) && (col
< m_numCols
) && m_table
)
7484 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7485 // may have changed earlier
7486 for (int i
= col
+cell_cols
; i
< m_numCols
; i
++)
7489 GetCellSize( row
, i
, &c_rows
, &c_cols
);
7490 // looks weird going over a multicell
7491 if (m_table
->IsEmptyCell(row
,i
) &&
7492 (rect
.width
< maxWidth
) && (c_rows
== 1))
7493 rect
.width
+= GetColWidth(i
);
7497 if (rect
.GetRight() > client_right
)
7498 rect
.SetRight(client_right
-1);
7501 editor
->SetCellAttr(attr
);
7502 editor
->SetSize( rect
);
7503 editor
->Show( TRUE
, attr
);
7505 // recalc dimensions in case we need to
7506 // expand the scrolled window to account for editor
7509 editor
->BeginEdit(row
, col
, this);
7510 editor
->SetCellAttr(NULL
);
7519 void wxGrid::HideCellEditControl()
7521 if ( IsCellEditControlEnabled() )
7523 int row
= m_currentCellCoords
.GetRow();
7524 int col
= m_currentCellCoords
.GetCol();
7526 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7527 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
7528 editor
->Show( FALSE
);
7531 m_gridWin
->SetFocus();
7532 // refresh whole row to the right
7533 wxRect
rect( CellToRect(row
, col
) );
7534 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7535 rect
.width
= m_gridWin
->GetClientSize().GetWidth() - rect
.x
;
7536 m_gridWin
->Refresh( FALSE
, &rect
);
7541 void wxGrid::SaveEditControlValue()
7543 if ( IsCellEditControlEnabled() )
7545 int row
= m_currentCellCoords
.GetRow();
7546 int col
= m_currentCellCoords
.GetCol();
7548 wxString oldval
= GetCellValue(row
,col
);
7550 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7551 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
7552 bool changed
= editor
->EndEdit(row
, col
, this);
7559 if ( SendEvent( wxEVT_GRID_CELL_CHANGE
,
7560 m_currentCellCoords
.GetRow(),
7561 m_currentCellCoords
.GetCol() ) < 0 ) {
7563 // Event has been vetoed, set the data back.
7564 SetCellValue(row
,col
,oldval
);
7572 // ------ Grid location functions
7573 // Note that all of these functions work with the logical coordinates of
7574 // grid cells and labels so you will need to convert from device
7575 // coordinates for mouse events etc.
7578 void wxGrid::XYToCell( int x
, int y
, wxGridCellCoords
& coords
)
7580 int row
= YToRow(y
);
7581 int col
= XToCol(x
);
7583 if ( row
== -1 || col
== -1 )
7585 coords
= wxGridNoCellCoords
;
7589 coords
.Set( row
, col
);
7594 // Internal Helper function for computing row or column from some
7595 // (unscrolled) coordinate value, using either
7596 // m_defaultRowHeight/m_defaultColWidth or binary search on array
7597 // of m_rowBottoms/m_ColRights to speed up the search!
7599 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
7600 const wxArrayInt
& BorderArray
, int nMax
,
7605 size_t i_max
= coord
/ defaultDist
,
7608 if (BorderArray
.IsEmpty())
7610 if((int) i_max
< nMax
)
7612 return maxOnOverflow
? nMax
- 1 : -1;
7615 if ( i_max
>= BorderArray
.GetCount())
7616 i_max
= BorderArray
.GetCount() - 1;
7619 if ( coord
>= BorderArray
[i_max
])
7622 i_max
= coord
/ minDist
;
7624 if ( i_max
>= BorderArray
.GetCount())
7625 i_max
= BorderArray
.GetCount() - 1;
7627 if ( coord
>= BorderArray
[i_max
])
7628 return maxOnOverflow
? (int)i_max
: -1;
7629 if ( coord
< BorderArray
[0] )
7632 while ( i_max
- i_min
> 0 )
7634 wxCHECK_MSG(BorderArray
[i_min
] <= coord
&& coord
< BorderArray
[i_max
],
7635 0, _T("wxGrid: internal error in CoordToRowOrCol"));
7636 if (coord
>= BorderArray
[ i_max
- 1])
7640 int median
= i_min
+ (i_max
- i_min
+ 1) / 2;
7641 if (coord
< BorderArray
[median
])
7649 int wxGrid::YToRow( int y
)
7651 return CoordToRowOrCol(y
, m_defaultRowHeight
,
7652 WXGRID_MIN_ROW_HEIGHT
, m_rowBottoms
, m_numRows
, FALSE
);
7656 int wxGrid::XToCol( int x
)
7658 return CoordToRowOrCol(x
, m_defaultColWidth
,
7659 WXGRID_MIN_COL_WIDTH
, m_colRights
, m_numCols
, FALSE
);
7663 // return the row number that that the y coord is near the edge of, or
7664 // -1 if not near an edge
7666 int wxGrid::YToEdgeOfRow( int y
)
7669 i
= internalYToRow(y
);
7671 if ( GetRowHeight(i
) > WXGRID_LABEL_EDGE_ZONE
)
7673 // We know that we are in row i, test whether we are
7674 // close enough to lower or upper border, respectively.
7675 if ( abs(GetRowBottom(i
) - y
) < WXGRID_LABEL_EDGE_ZONE
)
7677 else if( i
> 0 && y
- GetRowTop(i
) < WXGRID_LABEL_EDGE_ZONE
)
7685 // return the col number that that the x coord is near the edge of, or
7686 // -1 if not near an edge
7688 int wxGrid::XToEdgeOfCol( int x
)
7691 i
= internalXToCol(x
);
7693 if ( GetColWidth(i
) > WXGRID_LABEL_EDGE_ZONE
)
7695 // We know that we are in column i, test whether we are
7696 // close enough to right or left border, respectively.
7697 if ( abs(GetColRight(i
) - x
) < WXGRID_LABEL_EDGE_ZONE
)
7699 else if( i
> 0 && x
- GetColLeft(i
) < WXGRID_LABEL_EDGE_ZONE
)
7707 wxRect
wxGrid::CellToRect( int row
, int col
)
7709 wxRect
rect( -1, -1, -1, -1 );
7711 if ( row
>= 0 && row
< m_numRows
&&
7712 col
>= 0 && col
< m_numCols
)
7714 int i
, cell_rows
, cell_cols
;
7715 rect
.width
= rect
.height
= 0;
7716 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7717 // if negative then find multicell owner
7718 if (cell_rows
< 0) row
+= cell_rows
;
7719 if (cell_cols
< 0) col
+= cell_cols
;
7720 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7722 rect
.x
= GetColLeft(col
);
7723 rect
.y
= GetRowTop(row
);
7724 for (i
=col
; i
<col
+cell_cols
; i
++)
7725 rect
.width
+= GetColWidth(i
);
7726 for (i
=row
; i
<row
+cell_rows
; i
++)
7727 rect
.height
+= GetRowHeight(i
);
7730 // if grid lines are enabled, then the area of the cell is a bit smaller
7731 if (m_gridLinesEnabled
) {
7739 bool wxGrid::IsVisible( int row
, int col
, bool wholeCellVisible
)
7741 // get the cell rectangle in logical coords
7743 wxRect
r( CellToRect( row
, col
) );
7745 // convert to device coords
7747 int left
, top
, right
, bottom
;
7748 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
7749 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
7751 // check against the client area of the grid window
7754 m_gridWin
->GetClientSize( &cw
, &ch
);
7756 if ( wholeCellVisible
)
7758 // is the cell wholly visible ?
7760 return ( left
>= 0 && right
<= cw
&&
7761 top
>= 0 && bottom
<= ch
);
7765 // is the cell partly visible ?
7767 return ( ((left
>=0 && left
< cw
) || (right
> 0 && right
<= cw
)) &&
7768 ((top
>=0 && top
< ch
) || (bottom
> 0 && bottom
<= ch
)) );
7773 // make the specified cell location visible by doing a minimal amount
7776 void wxGrid::MakeCellVisible( int row
, int col
)
7780 int xpos
= -1, ypos
= -1;
7782 if ( row
>= 0 && row
< m_numRows
&&
7783 col
>= 0 && col
< m_numCols
)
7785 // get the cell rectangle in logical coords
7787 wxRect
r( CellToRect( row
, col
) );
7789 // convert to device coords
7791 int left
, top
, right
, bottom
;
7792 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
7793 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
7796 m_gridWin
->GetClientSize( &cw
, &ch
);
7802 else if ( bottom
> ch
)
7804 int h
= r
.GetHeight();
7806 for ( i
= row
-1; i
>= 0; i
-- )
7808 int rowHeight
= GetRowHeight(i
);
7809 if ( h
+ rowHeight
> ch
)
7816 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7817 // have rounding errors (this is important, because if we do, we
7818 // might not scroll at all and some cells won't be redrawn)
7820 // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7822 ypos
+= GRID_SCROLL_LINE_Y
;
7829 else if ( right
> cw
)
7831 // position the view so that the cell is on the right
7833 CalcUnscrolledPosition(0, 0, &x0
, &y0
);
7834 xpos
= x0
+ (right
- cw
);
7836 // see comment for ypos above
7837 xpos
+= GRID_SCROLL_LINE_X
;
7840 if ( xpos
!= -1 || ypos
!= -1 )
7843 xpos
/= GRID_SCROLL_LINE_X
;
7845 ypos
/= GRID_SCROLL_LINE_Y
;
7846 Scroll( xpos
, ypos
);
7854 // ------ Grid cursor movement functions
7857 bool wxGrid::MoveCursorUp( bool expandSelection
)
7859 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7860 m_currentCellCoords
.GetRow() >= 0 )
7862 if ( expandSelection
)
7864 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7865 m_selectingKeyboard
= m_currentCellCoords
;
7866 if ( m_selectingKeyboard
.GetRow() > 0 )
7868 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() - 1 );
7869 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7870 m_selectingKeyboard
.GetCol() );
7871 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7874 else if ( m_currentCellCoords
.GetRow() > 0 )
7877 MakeCellVisible( m_currentCellCoords
.GetRow() - 1,
7878 m_currentCellCoords
.GetCol() );
7879 SetCurrentCell( m_currentCellCoords
.GetRow() - 1,
7880 m_currentCellCoords
.GetCol() );
7891 bool wxGrid::MoveCursorDown( bool expandSelection
)
7893 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7894 m_currentCellCoords
.GetRow() < m_numRows
)
7896 if ( expandSelection
)
7898 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7899 m_selectingKeyboard
= m_currentCellCoords
;
7900 if ( m_selectingKeyboard
.GetRow() < m_numRows
-1 )
7902 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() + 1 );
7903 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7904 m_selectingKeyboard
.GetCol() );
7905 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7908 else if ( m_currentCellCoords
.GetRow() < m_numRows
- 1 )
7911 MakeCellVisible( m_currentCellCoords
.GetRow() + 1,
7912 m_currentCellCoords
.GetCol() );
7913 SetCurrentCell( m_currentCellCoords
.GetRow() + 1,
7914 m_currentCellCoords
.GetCol() );
7925 bool wxGrid::MoveCursorLeft( bool expandSelection
)
7927 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7928 m_currentCellCoords
.GetCol() >= 0 )
7930 if ( expandSelection
)
7932 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7933 m_selectingKeyboard
= m_currentCellCoords
;
7934 if ( m_selectingKeyboard
.GetCol() > 0 )
7936 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() - 1 );
7937 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7938 m_selectingKeyboard
.GetCol() );
7939 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7942 else if ( m_currentCellCoords
.GetCol() > 0 )
7945 MakeCellVisible( m_currentCellCoords
.GetRow(),
7946 m_currentCellCoords
.GetCol() - 1 );
7947 SetCurrentCell( m_currentCellCoords
.GetRow(),
7948 m_currentCellCoords
.GetCol() - 1 );
7959 bool wxGrid::MoveCursorRight( bool expandSelection
)
7961 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7962 m_currentCellCoords
.GetCol() < m_numCols
)
7964 if ( expandSelection
)
7966 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7967 m_selectingKeyboard
= m_currentCellCoords
;
7968 if ( m_selectingKeyboard
.GetCol() < m_numCols
- 1 )
7970 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() + 1 );
7971 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7972 m_selectingKeyboard
.GetCol() );
7973 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7976 else if ( m_currentCellCoords
.GetCol() < m_numCols
- 1 )
7979 MakeCellVisible( m_currentCellCoords
.GetRow(),
7980 m_currentCellCoords
.GetCol() + 1 );
7981 SetCurrentCell( m_currentCellCoords
.GetRow(),
7982 m_currentCellCoords
.GetCol() + 1 );
7993 bool wxGrid::MovePageUp()
7995 if ( m_currentCellCoords
== wxGridNoCellCoords
) return FALSE
;
7997 int row
= m_currentCellCoords
.GetRow();
8001 m_gridWin
->GetClientSize( &cw
, &ch
);
8003 int y
= GetRowTop(row
);
8004 int newRow
= YToRow( y
- ch
+ 1 );
8009 else if ( newRow
== row
)
8014 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
8015 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
8023 bool wxGrid::MovePageDown()
8025 if ( m_currentCellCoords
== wxGridNoCellCoords
) return FALSE
;
8027 int row
= m_currentCellCoords
.GetRow();
8028 if ( row
< m_numRows
)
8031 m_gridWin
->GetClientSize( &cw
, &ch
);
8033 int y
= GetRowTop(row
);
8034 int newRow
= YToRow( y
+ ch
);
8037 newRow
= m_numRows
- 1;
8039 else if ( newRow
== row
)
8044 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
8045 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
8053 bool wxGrid::MoveCursorUpBlock( bool expandSelection
)
8056 m_currentCellCoords
!= wxGridNoCellCoords
&&
8057 m_currentCellCoords
.GetRow() > 0 )
8059 int row
= m_currentCellCoords
.GetRow();
8060 int col
= m_currentCellCoords
.GetCol();
8062 if ( m_table
->IsEmptyCell(row
, col
) )
8064 // starting in an empty cell: find the next block of
8070 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8073 else if ( m_table
->IsEmptyCell(row
-1, col
) )
8075 // starting at the top of a block: find the next block
8081 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8086 // starting within a block: find the top of the block
8091 if ( m_table
->IsEmptyCell(row
, col
) )
8099 MakeCellVisible( row
, col
);
8100 if ( expandSelection
)
8102 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8103 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8108 SetCurrentCell( row
, col
);
8116 bool wxGrid::MoveCursorDownBlock( bool expandSelection
)
8119 m_currentCellCoords
!= wxGridNoCellCoords
&&
8120 m_currentCellCoords
.GetRow() < m_numRows
-1 )
8122 int row
= m_currentCellCoords
.GetRow();
8123 int col
= m_currentCellCoords
.GetCol();
8125 if ( m_table
->IsEmptyCell(row
, col
) )
8127 // starting in an empty cell: find the next block of
8130 while ( row
< m_numRows
-1 )
8133 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8136 else if ( m_table
->IsEmptyCell(row
+1, col
) )
8138 // starting at the bottom of a block: find the next block
8141 while ( row
< m_numRows
-1 )
8144 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8149 // starting within a block: find the bottom of the block
8151 while ( row
< m_numRows
-1 )
8154 if ( m_table
->IsEmptyCell(row
, col
) )
8162 MakeCellVisible( row
, col
);
8163 if ( expandSelection
)
8165 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8166 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8171 SetCurrentCell( row
, col
);
8180 bool wxGrid::MoveCursorLeftBlock( bool expandSelection
)
8183 m_currentCellCoords
!= wxGridNoCellCoords
&&
8184 m_currentCellCoords
.GetCol() > 0 )
8186 int row
= m_currentCellCoords
.GetRow();
8187 int col
= m_currentCellCoords
.GetCol();
8189 if ( m_table
->IsEmptyCell(row
, col
) )
8191 // starting in an empty cell: find the next block of
8197 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8200 else if ( m_table
->IsEmptyCell(row
, col
-1) )
8202 // starting at the left of a block: find the next block
8208 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8213 // starting within a block: find the left of the block
8218 if ( m_table
->IsEmptyCell(row
, col
) )
8226 MakeCellVisible( row
, col
);
8227 if ( expandSelection
)
8229 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8230 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8235 SetCurrentCell( row
, col
);
8244 bool wxGrid::MoveCursorRightBlock( bool expandSelection
)
8247 m_currentCellCoords
!= wxGridNoCellCoords
&&
8248 m_currentCellCoords
.GetCol() < m_numCols
-1 )
8250 int row
= m_currentCellCoords
.GetRow();
8251 int col
= m_currentCellCoords
.GetCol();
8253 if ( m_table
->IsEmptyCell(row
, col
) )
8255 // starting in an empty cell: find the next block of
8258 while ( col
< m_numCols
-1 )
8261 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8264 else if ( m_table
->IsEmptyCell(row
, col
+1) )
8266 // starting at the right of a block: find the next block
8269 while ( col
< m_numCols
-1 )
8272 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
8277 // starting within a block: find the right of the block
8279 while ( col
< m_numCols
-1 )
8282 if ( m_table
->IsEmptyCell(row
, col
) )
8290 MakeCellVisible( row
, col
);
8291 if ( expandSelection
)
8293 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
8294 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8299 SetCurrentCell( row
, col
);
8311 // ------ Label values and formatting
8314 void wxGrid::GetRowLabelAlignment( int *horiz
, int *vert
)
8316 *horiz
= m_rowLabelHorizAlign
;
8317 *vert
= m_rowLabelVertAlign
;
8320 void wxGrid::GetColLabelAlignment( int *horiz
, int *vert
)
8322 *horiz
= m_colLabelHorizAlign
;
8323 *vert
= m_colLabelVertAlign
;
8326 int wxGrid::GetColLabelTextOrientation()
8328 return m_colLabelTextOrientation
;
8331 wxString
wxGrid::GetRowLabelValue( int row
)
8335 return m_table
->GetRowLabelValue( row
);
8345 wxString
wxGrid::GetColLabelValue( int col
)
8349 return m_table
->GetColLabelValue( col
);
8360 void wxGrid::SetRowLabelSize( int width
)
8362 width
= wxMax( width
, 0 );
8363 if ( width
!= m_rowLabelWidth
)
8367 m_rowLabelWin
->Show( FALSE
);
8368 m_cornerLabelWin
->Show( FALSE
);
8370 else if ( m_rowLabelWidth
== 0 )
8372 m_rowLabelWin
->Show( TRUE
);
8373 if ( m_colLabelHeight
> 0 ) m_cornerLabelWin
->Show( TRUE
);
8376 m_rowLabelWidth
= width
;
8378 wxScrolledWindow::Refresh( TRUE
);
8383 void wxGrid::SetColLabelSize( int height
)
8385 height
= wxMax( height
, 0 );
8386 if ( height
!= m_colLabelHeight
)
8390 m_colLabelWin
->Show( FALSE
);
8391 m_cornerLabelWin
->Show( FALSE
);
8393 else if ( m_colLabelHeight
== 0 )
8395 m_colLabelWin
->Show( TRUE
);
8396 if ( m_rowLabelWidth
> 0 ) m_cornerLabelWin
->Show( TRUE
);
8399 m_colLabelHeight
= height
;
8401 wxScrolledWindow::Refresh( TRUE
);
8406 void wxGrid::SetLabelBackgroundColour( const wxColour
& colour
)
8408 if ( m_labelBackgroundColour
!= colour
)
8410 m_labelBackgroundColour
= colour
;
8411 m_rowLabelWin
->SetBackgroundColour( colour
);
8412 m_colLabelWin
->SetBackgroundColour( colour
);
8413 m_cornerLabelWin
->SetBackgroundColour( colour
);
8415 if ( !GetBatchCount() )
8417 m_rowLabelWin
->Refresh();
8418 m_colLabelWin
->Refresh();
8419 m_cornerLabelWin
->Refresh();
8424 void wxGrid::SetLabelTextColour( const wxColour
& colour
)
8426 if ( m_labelTextColour
!= colour
)
8428 m_labelTextColour
= colour
;
8429 if ( !GetBatchCount() )
8431 m_rowLabelWin
->Refresh();
8432 m_colLabelWin
->Refresh();
8437 void wxGrid::SetLabelFont( const wxFont
& font
)
8440 if ( !GetBatchCount() )
8442 m_rowLabelWin
->Refresh();
8443 m_colLabelWin
->Refresh();
8447 void wxGrid::SetRowLabelAlignment( int horiz
, int vert
)
8449 // allow old (incorrect) defs to be used
8452 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
8453 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
8454 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
8459 case wxTOP
: vert
= wxALIGN_TOP
; break;
8460 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
8461 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
8464 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
8466 m_rowLabelHorizAlign
= horiz
;
8469 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
8471 m_rowLabelVertAlign
= vert
;
8474 if ( !GetBatchCount() )
8476 m_rowLabelWin
->Refresh();
8480 void wxGrid::SetColLabelAlignment( int horiz
, int vert
)
8482 // allow old (incorrect) defs to be used
8485 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
8486 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
8487 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
8492 case wxTOP
: vert
= wxALIGN_TOP
; break;
8493 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
8494 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
8497 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
8499 m_colLabelHorizAlign
= horiz
;
8502 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
8504 m_colLabelVertAlign
= vert
;
8507 if ( !GetBatchCount() )
8509 m_colLabelWin
->Refresh();
8513 // Note: under MSW, the default column label font must be changed because it
8514 // does not support vertical printing
8516 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
8517 // pGrid->SetLabelFont(font);
8518 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
8520 void wxGrid::SetColLabelTextOrientation( int textOrientation
)
8522 if( textOrientation
== wxHORIZONTAL
|| textOrientation
== wxVERTICAL
)
8524 m_colLabelTextOrientation
= textOrientation
;
8527 if ( !GetBatchCount() )
8529 m_colLabelWin
->Refresh();
8533 void wxGrid::SetRowLabelValue( int row
, const wxString
& s
)
8537 m_table
->SetRowLabelValue( row
, s
);
8538 if ( !GetBatchCount() )
8540 wxRect rect
= CellToRect( row
, 0);
8541 if ( rect
.height
> 0 )
8543 CalcScrolledPosition(0, rect
.y
, &rect
.x
, &rect
.y
);
8545 rect
.width
= m_rowLabelWidth
;
8546 m_rowLabelWin
->Refresh( TRUE
, &rect
);
8552 void wxGrid::SetColLabelValue( int col
, const wxString
& s
)
8556 m_table
->SetColLabelValue( col
, s
);
8557 if ( !GetBatchCount() )
8559 wxRect rect
= CellToRect( 0, col
);
8560 if ( rect
.width
> 0 )
8562 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &rect
.y
);
8564 rect
.height
= m_colLabelHeight
;
8565 m_colLabelWin
->Refresh( TRUE
, &rect
);
8571 void wxGrid::SetGridLineColour( const wxColour
& colour
)
8573 if ( m_gridLineColour
!= colour
)
8575 m_gridLineColour
= colour
;
8577 wxClientDC
dc( m_gridWin
);
8579 DrawAllGridLines( dc
, wxRegion() );
8584 void wxGrid::SetCellHighlightColour( const wxColour
& colour
)
8586 if ( m_cellHighlightColour
!= colour
)
8588 m_cellHighlightColour
= colour
;
8590 wxClientDC
dc( m_gridWin
);
8592 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
8593 DrawCellHighlight(dc
, attr
);
8598 void wxGrid::SetCellHighlightPenWidth(int width
)
8600 if (m_cellHighlightPenWidth
!= width
) {
8601 m_cellHighlightPenWidth
= width
;
8603 // Just redrawing the cell highlight is not enough since that won't
8604 // make any visible change if the the thickness is getting smaller.
8605 int row
= m_currentCellCoords
.GetRow();
8606 int col
= m_currentCellCoords
.GetCol();
8607 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
8609 wxRect rect
= CellToRect(row
, col
);
8610 m_gridWin
->Refresh(TRUE
, &rect
);
8614 void wxGrid::SetCellHighlightROPenWidth(int width
)
8616 if (m_cellHighlightROPenWidth
!= width
) {
8617 m_cellHighlightROPenWidth
= width
;
8619 // Just redrawing the cell highlight is not enough since that won't
8620 // make any visible change if the the thickness is getting smaller.
8621 int row
= m_currentCellCoords
.GetRow();
8622 int col
= m_currentCellCoords
.GetCol();
8623 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
8625 wxRect rect
= CellToRect(row
, col
);
8626 m_gridWin
->Refresh(TRUE
, &rect
);
8630 void wxGrid::EnableGridLines( bool enable
)
8632 if ( enable
!= m_gridLinesEnabled
)
8634 m_gridLinesEnabled
= enable
;
8636 if ( !GetBatchCount() )
8640 wxClientDC
dc( m_gridWin
);
8642 DrawAllGridLines( dc
, wxRegion() );
8646 m_gridWin
->Refresh();
8653 int wxGrid::GetDefaultRowSize()
8655 return m_defaultRowHeight
;
8658 int wxGrid::GetRowSize( int row
)
8660 wxCHECK_MSG( row
>= 0 && row
< m_numRows
, 0, _T("invalid row index") );
8662 return GetRowHeight(row
);
8665 int wxGrid::GetDefaultColSize()
8667 return m_defaultColWidth
;
8670 int wxGrid::GetColSize( int col
)
8672 wxCHECK_MSG( col
>= 0 && col
< m_numCols
, 0, _T("invalid column index") );
8674 return GetColWidth(col
);
8677 // ============================================================================
8678 // access to the grid attributes: each of them has a default value in the grid
8679 // itself and may be overidden on a per-cell basis
8680 // ============================================================================
8682 // ----------------------------------------------------------------------------
8683 // setting default attributes
8684 // ----------------------------------------------------------------------------
8686 void wxGrid::SetDefaultCellBackgroundColour( const wxColour
& col
)
8688 m_defaultCellAttr
->SetBackgroundColour(col
);
8690 m_gridWin
->SetBackgroundColour(col
);
8694 void wxGrid::SetDefaultCellTextColour( const wxColour
& col
)
8696 m_defaultCellAttr
->SetTextColour(col
);
8699 void wxGrid::SetDefaultCellAlignment( int horiz
, int vert
)
8701 m_defaultCellAttr
->SetAlignment(horiz
, vert
);
8704 void wxGrid::SetDefaultCellOverflow( bool allow
)
8706 m_defaultCellAttr
->SetOverflow(allow
);
8709 void wxGrid::SetDefaultCellFont( const wxFont
& font
)
8711 m_defaultCellAttr
->SetFont(font
);
8714 void wxGrid::SetDefaultRenderer(wxGridCellRenderer
*renderer
)
8716 m_defaultCellAttr
->SetRenderer(renderer
);
8719 void wxGrid::SetDefaultEditor(wxGridCellEditor
*editor
)
8721 m_defaultCellAttr
->SetEditor(editor
);
8724 // ----------------------------------------------------------------------------
8725 // access to the default attrbiutes
8726 // ----------------------------------------------------------------------------
8728 wxColour
wxGrid::GetDefaultCellBackgroundColour()
8730 return m_defaultCellAttr
->GetBackgroundColour();
8733 wxColour
wxGrid::GetDefaultCellTextColour()
8735 return m_defaultCellAttr
->GetTextColour();
8738 wxFont
wxGrid::GetDefaultCellFont()
8740 return m_defaultCellAttr
->GetFont();
8743 void wxGrid::GetDefaultCellAlignment( int *horiz
, int *vert
)
8745 m_defaultCellAttr
->GetAlignment(horiz
, vert
);
8748 bool wxGrid::GetDefaultCellOverflow()
8750 return m_defaultCellAttr
->GetOverflow();
8753 wxGridCellRenderer
*wxGrid::GetDefaultRenderer() const
8755 return m_defaultCellAttr
->GetRenderer(NULL
, 0, 0);
8758 wxGridCellEditor
*wxGrid::GetDefaultEditor() const
8760 return m_defaultCellAttr
->GetEditor(NULL
,0,0);
8763 // ----------------------------------------------------------------------------
8764 // access to cell attributes
8765 // ----------------------------------------------------------------------------
8767 wxColour
wxGrid::GetCellBackgroundColour(int row
, int col
)
8769 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8770 wxColour colour
= attr
->GetBackgroundColour();
8775 wxColour
wxGrid::GetCellTextColour( int row
, int col
)
8777 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8778 wxColour colour
= attr
->GetTextColour();
8783 wxFont
wxGrid::GetCellFont( int row
, int col
)
8785 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8786 wxFont font
= attr
->GetFont();
8791 void wxGrid::GetCellAlignment( int row
, int col
, int *horiz
, int *vert
)
8793 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8794 attr
->GetAlignment(horiz
, vert
);
8798 bool wxGrid::GetCellOverflow( int row
, int col
)
8800 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8801 bool allow
= attr
->GetOverflow();
8806 void wxGrid::GetCellSize( int row
, int col
, int *num_rows
, int *num_cols
)
8808 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8809 attr
->GetSize( num_rows
, num_cols
);
8813 wxGridCellRenderer
* wxGrid::GetCellRenderer(int row
, int col
)
8815 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8816 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
8822 wxGridCellEditor
* wxGrid::GetCellEditor(int row
, int col
)
8824 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8825 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
8831 bool wxGrid::IsReadOnly(int row
, int col
) const
8833 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8834 bool isReadOnly
= attr
->IsReadOnly();
8839 // ----------------------------------------------------------------------------
8840 // attribute support: cache, automatic provider creation, ...
8841 // ----------------------------------------------------------------------------
8843 bool wxGrid::CanHaveAttributes()
8850 return m_table
->CanHaveAttributes();
8853 void wxGrid::ClearAttrCache()
8855 if ( m_attrCache
.row
!= -1 )
8857 wxSafeDecRef(m_attrCache
.attr
);
8858 m_attrCache
.attr
= NULL
;
8859 m_attrCache
.row
= -1;
8863 void wxGrid::CacheAttr(int row
, int col
, wxGridCellAttr
*attr
) const
8867 wxGrid
*self
= (wxGrid
*)this; // const_cast
8869 self
->ClearAttrCache();
8870 self
->m_attrCache
.row
= row
;
8871 self
->m_attrCache
.col
= col
;
8872 self
->m_attrCache
.attr
= attr
;
8877 bool wxGrid::LookupAttr(int row
, int col
, wxGridCellAttr
**attr
) const
8879 if ( row
== m_attrCache
.row
&& col
== m_attrCache
.col
)
8881 *attr
= m_attrCache
.attr
;
8882 wxSafeIncRef(m_attrCache
.attr
);
8884 #ifdef DEBUG_ATTR_CACHE
8885 gs_nAttrCacheHits
++;
8892 #ifdef DEBUG_ATTR_CACHE
8893 gs_nAttrCacheMisses
++;
8899 wxGridCellAttr
*wxGrid::GetCellAttr(int row
, int col
) const
8901 wxGridCellAttr
*attr
= NULL
;
8902 // Additional test to avoid looking at the cache e.g. for
8903 // wxNoCellCoords, as this will confuse memory management.
8906 if ( !LookupAttr(row
, col
, &attr
) )
8908 attr
= m_table
? m_table
->GetAttr(row
, col
, wxGridCellAttr::Any
)
8909 : (wxGridCellAttr
*)NULL
;
8910 CacheAttr(row
, col
, attr
);
8915 attr
->SetDefAttr(m_defaultCellAttr
);
8919 attr
= m_defaultCellAttr
;
8926 wxGridCellAttr
*wxGrid::GetOrCreateCellAttr(int row
, int col
) const
8928 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
8930 wxCHECK_MSG( m_table
, attr
,
8931 _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
8933 attr
= m_table
->GetAttr(row
, col
, wxGridCellAttr::Cell
);
8936 attr
= new wxGridCellAttr(m_defaultCellAttr
);
8938 // artificially inc the ref count to match DecRef() in caller
8940 m_table
->SetAttr(attr
, row
, col
);
8946 // ----------------------------------------------------------------------------
8947 // setting column attributes (wrappers around SetColAttr)
8948 // ----------------------------------------------------------------------------
8950 void wxGrid::SetColFormatBool(int col
)
8952 SetColFormatCustom(col
, wxGRID_VALUE_BOOL
);
8955 void wxGrid::SetColFormatNumber(int col
)
8957 SetColFormatCustom(col
, wxGRID_VALUE_NUMBER
);
8960 void wxGrid::SetColFormatFloat(int col
, int width
, int precision
)
8962 wxString typeName
= wxGRID_VALUE_FLOAT
;
8963 if ( (width
!= -1) || (precision
!= -1) )
8965 typeName
<< _T(':') << width
<< _T(',') << precision
;
8968 SetColFormatCustom(col
, typeName
);
8971 void wxGrid::SetColFormatCustom(int col
, const wxString
& typeName
)
8973 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
8975 attr
= m_table
->GetAttr(-1, col
, wxGridCellAttr::Col
);
8977 attr
= new wxGridCellAttr
;
8978 wxGridCellRenderer
*renderer
= GetDefaultRendererForType(typeName
);
8979 attr
->SetRenderer(renderer
);
8981 SetColAttr(col
, attr
);
8985 // ----------------------------------------------------------------------------
8986 // setting cell attributes: this is forwarded to the table
8987 // ----------------------------------------------------------------------------
8989 void wxGrid::SetAttr(int row
, int col
, wxGridCellAttr
*attr
)
8991 if ( CanHaveAttributes() )
8993 m_table
->SetAttr(attr
, row
, col
);
9002 void wxGrid::SetRowAttr(int row
, wxGridCellAttr
*attr
)
9004 if ( CanHaveAttributes() )
9006 m_table
->SetRowAttr(attr
, row
);
9015 void wxGrid::SetColAttr(int col
, wxGridCellAttr
*attr
)
9017 if ( CanHaveAttributes() )
9019 m_table
->SetColAttr(attr
, col
);
9028 void wxGrid::SetCellBackgroundColour( int row
, int col
, const wxColour
& colour
)
9030 if ( CanHaveAttributes() )
9032 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9033 attr
->SetBackgroundColour(colour
);
9038 void wxGrid::SetCellTextColour( int row
, int col
, const wxColour
& colour
)
9040 if ( CanHaveAttributes() )
9042 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9043 attr
->SetTextColour(colour
);
9048 void wxGrid::SetCellFont( int row
, int col
, const wxFont
& font
)
9050 if ( CanHaveAttributes() )
9052 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9053 attr
->SetFont(font
);
9058 void wxGrid::SetCellAlignment( int row
, int col
, int horiz
, int vert
)
9060 if ( CanHaveAttributes() )
9062 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9063 attr
->SetAlignment(horiz
, vert
);
9068 void wxGrid::SetCellOverflow( int row
, int col
, bool allow
)
9070 if ( CanHaveAttributes() )
9072 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9073 attr
->SetOverflow(allow
);
9078 void wxGrid::SetCellSize( int row
, int col
, int num_rows
, int num_cols
)
9080 if ( CanHaveAttributes() )
9082 int cell_rows
, cell_cols
;
9084 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9085 attr
->GetSize(&cell_rows
, &cell_cols
);
9086 attr
->SetSize(num_rows
, num_cols
);
9089 // Cannot set the size of a cell to 0 or negative values
9090 // While it is perfectly legal to do that, this function cannot
9091 // handle all the possibilies, do it by hand by getting the CellAttr.
9092 // You can only set the size of a cell to 1,1 or greater with this fn
9093 wxASSERT_MSG( !((cell_rows
< 1) || (cell_cols
< 1)),
9094 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
9095 wxASSERT_MSG( !((num_rows
< 1) || (num_cols
< 1)),
9096 wxT("wxGrid::SetCellSize setting cell size to < 1"));
9098 // if this was already a multicell then "turn off" the other cells first
9099 if ((cell_rows
> 1) || (cell_rows
> 1))
9102 for (j
=row
; j
<row
+cell_rows
; j
++)
9104 for (i
=col
; i
<col
+cell_cols
; i
++)
9106 if ((i
!= col
) || (j
!= row
))
9108 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
9109 attr_stub
->SetSize( 1, 1 );
9110 attr_stub
->DecRef();
9116 // mark the cells that will be covered by this cell to
9117 // negative or zero values to point back at this cell
9118 if (((num_rows
> 1) || (num_cols
> 1)) && (num_rows
>= 1) && (num_cols
>= 1))
9121 for (j
=row
; j
<row
+num_rows
; j
++)
9123 for (i
=col
; i
<col
+num_cols
; i
++)
9125 if ((i
!= col
) || (j
!= row
))
9127 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
9128 attr_stub
->SetSize( row
-j
, col
-i
);
9129 attr_stub
->DecRef();
9137 void wxGrid::SetCellRenderer(int row
, int col
, wxGridCellRenderer
*renderer
)
9139 if ( CanHaveAttributes() )
9141 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9142 attr
->SetRenderer(renderer
);
9147 void wxGrid::SetCellEditor(int row
, int col
, wxGridCellEditor
* editor
)
9149 if ( CanHaveAttributes() )
9151 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9152 attr
->SetEditor(editor
);
9157 void wxGrid::SetReadOnly(int row
, int col
, bool isReadOnly
)
9159 if ( CanHaveAttributes() )
9161 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
9162 attr
->SetReadOnly(isReadOnly
);
9167 // ----------------------------------------------------------------------------
9168 // Data type registration
9169 // ----------------------------------------------------------------------------
9171 void wxGrid::RegisterDataType(const wxString
& typeName
,
9172 wxGridCellRenderer
* renderer
,
9173 wxGridCellEditor
* editor
)
9175 m_typeRegistry
->RegisterDataType(typeName
, renderer
, editor
);
9179 wxGridCellEditor
* wxGrid::GetDefaultEditorForCell(int row
, int col
) const
9181 wxString typeName
= m_table
->GetTypeName(row
, col
);
9182 return GetDefaultEditorForType(typeName
);
9185 wxGridCellRenderer
* wxGrid::GetDefaultRendererForCell(int row
, int col
) const
9187 wxString typeName
= m_table
->GetTypeName(row
, col
);
9188 return GetDefaultRendererForType(typeName
);
9192 wxGrid::GetDefaultEditorForType(const wxString
& typeName
) const
9194 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
9195 if ( index
== wxNOT_FOUND
)
9197 wxFAIL_MSG(wxT("Unknown data type name"));
9202 return m_typeRegistry
->GetEditor(index
);
9206 wxGrid::GetDefaultRendererForType(const wxString
& typeName
) const
9208 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
9209 if ( index
== wxNOT_FOUND
)
9211 wxFAIL_MSG(wxT("Unknown data type name"));
9216 return m_typeRegistry
->GetRenderer(index
);
9220 // ----------------------------------------------------------------------------
9222 // ----------------------------------------------------------------------------
9224 void wxGrid::EnableDragRowSize( bool enable
)
9226 m_canDragRowSize
= enable
;
9230 void wxGrid::EnableDragColSize( bool enable
)
9232 m_canDragColSize
= enable
;
9235 void wxGrid::EnableDragGridSize( bool enable
)
9237 m_canDragGridSize
= enable
;
9241 void wxGrid::SetDefaultRowSize( int height
, bool resizeExistingRows
)
9243 m_defaultRowHeight
= wxMax( height
, WXGRID_MIN_ROW_HEIGHT
);
9245 if ( resizeExistingRows
)
9247 // since we are resizing all rows to the default row size,
9248 // we can simply clear the row heights and row bottoms
9249 // arrays (which also allows us to take advantage of
9250 // some speed optimisations)
9251 m_rowHeights
.Empty();
9252 m_rowBottoms
.Empty();
9253 if ( !GetBatchCount() )
9258 void wxGrid::SetRowSize( int row
, int height
)
9260 wxCHECK_RET( row
>= 0 && row
< m_numRows
, _T("invalid row index") );
9262 if ( m_rowHeights
.IsEmpty() )
9264 // need to really create the array
9268 int h
= wxMax( 0, height
);
9269 int diff
= h
- m_rowHeights
[row
];
9271 m_rowHeights
[row
] = h
;
9273 for ( i
= row
; i
< m_numRows
; i
++ )
9275 m_rowBottoms
[i
] += diff
;
9277 if ( !GetBatchCount() )
9281 void wxGrid::SetDefaultColSize( int width
, bool resizeExistingCols
)
9283 m_defaultColWidth
= wxMax( width
, WXGRID_MIN_COL_WIDTH
);
9285 if ( resizeExistingCols
)
9287 // since we are resizing all columns to the default column size,
9288 // we can simply clear the col widths and col rights
9289 // arrays (which also allows us to take advantage of
9290 // some speed optimisations)
9291 m_colWidths
.Empty();
9292 m_colRights
.Empty();
9293 if ( !GetBatchCount() )
9298 void wxGrid::SetColSize( int col
, int width
)
9300 wxCHECK_RET( col
>= 0 && col
< m_numCols
, _T("invalid column index") );
9302 // should we check that it's bigger than GetColMinimalWidth(col) here?
9304 if ( m_colWidths
.IsEmpty() )
9306 // need to really create the array
9310 // if < 0 calc new width from label
9314 wxArrayString lines
;
9315 wxClientDC
dc(m_colLabelWin
);
9316 dc
.SetFont(GetLabelFont());
9317 StringToLines(GetColLabelValue(col
), lines
);
9318 GetTextBoxSize(dc
, lines
, &w
, &h
);
9321 int w
= wxMax( 0, width
);
9322 int diff
= w
- m_colWidths
[col
];
9323 m_colWidths
[col
] = w
;
9326 for ( i
= col
; i
< m_numCols
; i
++ )
9328 m_colRights
[i
] += diff
;
9330 if ( !GetBatchCount() )
9335 void wxGrid::SetColMinimalWidth( int col
, int width
)
9337 m_colMinWidths
.Put(col
, width
);
9340 void wxGrid::SetRowMinimalHeight( int row
, int width
)
9342 m_rowMinHeights
.Put(row
, width
);
9345 int wxGrid::GetColMinimalWidth(int col
) const
9347 long value
= m_colMinWidths
.Get(col
);
9348 return value
!= wxNOT_FOUND
? (int)value
: WXGRID_MIN_COL_WIDTH
;
9351 int wxGrid::GetRowMinimalHeight(int row
) const
9353 long value
= m_rowMinHeights
.Get(row
);
9354 return value
!= wxNOT_FOUND
? (int)value
: WXGRID_MIN_ROW_HEIGHT
;
9357 // ----------------------------------------------------------------------------
9359 // ----------------------------------------------------------------------------
9361 void wxGrid::AutoSizeColOrRow( int colOrRow
, bool setAsMin
, bool column
)
9363 wxClientDC
dc(m_gridWin
);
9365 // init both of them to avoid compiler warnings, even if weo nly need one
9373 wxCoord extent
, extentMax
= 0;
9374 int max
= column
? m_numRows
: m_numCols
;
9375 for ( int rowOrCol
= 0; rowOrCol
< max
; rowOrCol
++ )
9382 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
9383 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
9386 wxSize size
= renderer
->GetBestSize(*this, *attr
, dc
, row
, col
);
9387 extent
= column
? size
.x
: size
.y
;
9388 if ( extent
> extentMax
)
9399 // now also compare with the column label extent
9401 dc
.SetFont( GetLabelFont() );
9405 dc
.GetTextExtent( GetColLabelValue(col
), &w
, &h
);
9406 if( GetColLabelTextOrientation() == wxVERTICAL
)
9410 dc
.GetTextExtent( GetRowLabelValue(row
), &w
, &h
);
9412 extent
= column
? w
: h
;
9413 if ( extent
> extentMax
)
9420 // empty column - give default extent (notice that if extentMax is less
9421 // than default extent but != 0, it's ok)
9422 extentMax
= column
? m_defaultColWidth
: m_defaultRowHeight
;
9428 // leave some space around text
9439 SetColSize(col
, extentMax
);
9440 if ( !GetBatchCount() )
9443 m_gridWin
->GetClientSize( &cw
, &ch
);
9444 wxRect
rect ( CellToRect( 0, col
) );
9446 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
9447 rect
.width
= cw
- rect
.x
;
9448 rect
.height
= m_colLabelHeight
;
9449 m_colLabelWin
->Refresh( TRUE
, &rect
);
9454 SetRowSize(row
, extentMax
);
9455 if ( !GetBatchCount() )
9458 m_gridWin
->GetClientSize( &cw
, &ch
);
9459 wxRect
rect ( CellToRect( row
, 0 ) );
9461 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
9462 rect
.width
= m_rowLabelWidth
;
9463 rect
.height
= ch
- rect
.y
;
9464 m_rowLabelWin
->Refresh( TRUE
, &rect
);
9470 SetColMinimalWidth(col
, extentMax
);
9472 SetRowMinimalHeight(row
, extentMax
);
9476 int wxGrid::SetOrCalcColumnSizes(bool calcOnly
, bool setAsMin
)
9478 int width
= m_rowLabelWidth
;
9483 for ( int col
= 0; col
< m_numCols
; col
++ )
9487 AutoSizeColumn(col
, setAsMin
);
9490 width
+= GetColWidth(col
);
9499 int wxGrid::SetOrCalcRowSizes(bool calcOnly
, bool setAsMin
)
9501 int height
= m_colLabelHeight
;
9506 for ( int row
= 0; row
< m_numRows
; row
++ )
9510 AutoSizeRow(row
, setAsMin
);
9513 height
+= GetRowHeight(row
);
9522 void wxGrid::AutoSize()
9526 wxSize
size(SetOrCalcColumnSizes(FALSE
), SetOrCalcRowSizes(FALSE
));
9528 // round up the size to a multiple of scroll step - this ensures that we
9529 // won't get the scrollbars if we're sized exactly to this width
9530 // CalcDimension adds m_extraWidth + 1 etc. to calculate the necessary
9532 wxSize
sizeFit(GetScrollX(size
.x
+ m_extraWidth
+ 1) * GRID_SCROLL_LINE_X
,
9533 GetScrollY(size
.y
+ m_extraHeight
+ 1) * GRID_SCROLL_LINE_Y
);
9535 // distribute the extra space between the columns/rows to avoid having
9536 // extra white space
9538 // Remove the extra m_extraWidth + 1 added above
9539 wxCoord diff
= sizeFit
.x
- size
.x
+ (m_extraWidth
+ 1);
9540 if ( diff
&& m_numCols
)
9542 // try to resize the columns uniformly
9543 wxCoord diffPerCol
= diff
/ m_numCols
;
9546 for ( int col
= 0; col
< m_numCols
; col
++ )
9548 SetColSize(col
, GetColWidth(col
) + diffPerCol
);
9552 // add remaining amount to the last columns
9553 diff
-= diffPerCol
* m_numCols
;
9556 for ( int col
= m_numCols
- 1; col
>= m_numCols
- diff
; col
-- )
9558 SetColSize(col
, GetColWidth(col
) + 1);
9564 diff
= sizeFit
.y
- size
.y
- (m_extraHeight
+ 1);
9565 if ( diff
&& m_numRows
)
9567 // try to resize the columns uniformly
9568 wxCoord diffPerRow
= diff
/ m_numRows
;
9571 for ( int row
= 0; row
< m_numRows
; row
++ )
9573 SetRowSize(row
, GetRowHeight(row
) + diffPerRow
);
9577 // add remaining amount to the last rows
9578 diff
-= diffPerRow
* m_numRows
;
9581 for ( int row
= m_numRows
- 1; row
>= m_numRows
- diff
; row
-- )
9583 SetRowSize(row
, GetRowHeight(row
) + 1);
9590 SetClientSize(sizeFit
);
9593 void wxGrid::AutoSizeRowLabelSize( int row
)
9595 wxArrayString lines
;
9598 // Hide the edit control, so it
9599 // won't interfer with drag-shrinking.
9600 if( IsCellEditControlShown() )
9602 HideCellEditControl();
9603 SaveEditControlValue();
9606 // autosize row height depending on label text
9607 StringToLines( GetRowLabelValue( row
), lines
);
9608 wxClientDC
dc( m_rowLabelWin
);
9609 GetTextBoxSize( dc
, lines
, &w
, &h
);
9610 if( h
< m_defaultRowHeight
)
9611 h
= m_defaultRowHeight
;
9616 void wxGrid::AutoSizeColLabelSize( int col
)
9618 wxArrayString lines
;
9621 // Hide the edit control, so it
9622 // won't interfer with drag-shrinking.
9623 if( IsCellEditControlShown() )
9625 HideCellEditControl();
9626 SaveEditControlValue();
9629 // autosize column width depending on label text
9630 StringToLines( GetColLabelValue( col
), lines
);
9631 wxClientDC
dc( m_colLabelWin
);
9632 if( GetColLabelTextOrientation() == wxHORIZONTAL
)
9633 GetTextBoxSize( dc
, lines
, &w
, &h
);
9635 GetTextBoxSize( dc
, lines
, &h
, &w
);
9636 if( w
< m_defaultColWidth
)
9637 w
= m_defaultColWidth
;
9642 wxSize
wxGrid::DoGetBestSize() const
9644 // don't set sizes, only calculate them
9645 wxGrid
*self
= (wxGrid
*)this; // const_cast
9648 width
= self
->SetOrCalcColumnSizes(TRUE
);
9649 height
= self
->SetOrCalcRowSizes(TRUE
);
9651 int maxwidth
, maxheight
;
9652 wxDisplaySize( & maxwidth
, & maxheight
);
9654 if ( width
> maxwidth
) width
= maxwidth
;
9655 if ( height
> maxheight
) height
= maxheight
;
9657 return wxSize( width
, height
);
9666 wxPen
& wxGrid::GetDividerPen() const
9671 // ----------------------------------------------------------------------------
9672 // cell value accessor functions
9673 // ----------------------------------------------------------------------------
9675 void wxGrid::SetCellValue( int row
, int col
, const wxString
& s
)
9679 m_table
->SetValue( row
, col
, s
);
9680 if ( !GetBatchCount() )
9683 wxRect
rect( CellToRect( row
, col
) );
9685 rect
.width
= m_gridWin
->GetClientSize().GetWidth();
9686 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
9687 m_gridWin
->Refresh( FALSE
, &rect
);
9690 if ( m_currentCellCoords
.GetRow() == row
&&
9691 m_currentCellCoords
.GetCol() == col
&&
9692 IsCellEditControlShown())
9693 // Note: If we are using IsCellEditControlEnabled,
9694 // this interacts badly with calling SetCellValue from
9695 // an EVT_GRID_CELL_CHANGE handler.
9697 HideCellEditControl();
9698 ShowCellEditControl(); // will reread data from table
9705 // ------ Block, row and col selection
9708 void wxGrid::SelectRow( int row
, bool addToSelected
)
9710 if ( IsSelection() && !addToSelected
)
9714 m_selection
->SelectRow( row
, FALSE
, addToSelected
);
9718 void wxGrid::SelectCol( int col
, bool addToSelected
)
9720 if ( IsSelection() && !addToSelected
)
9724 m_selection
->SelectCol( col
, FALSE
, addToSelected
);
9728 void wxGrid::SelectBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
,
9729 bool addToSelected
)
9731 if ( IsSelection() && !addToSelected
)
9735 m_selection
->SelectBlock( topRow
, leftCol
, bottomRow
, rightCol
,
9736 FALSE
, addToSelected
);
9740 void wxGrid::SelectAll()
9742 if ( m_numRows
> 0 && m_numCols
> 0 )
9745 m_selection
->SelectBlock( 0, 0, m_numRows
-1, m_numCols
-1 );
9750 // ------ Cell, row and col deselection
9753 void wxGrid::DeselectRow( int row
)
9758 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
9760 if ( m_selection
->IsInSelection(row
, 0 ) )
9761 m_selection
->ToggleCellSelection( row
, 0);
9765 int nCols
= GetNumberCols();
9766 for ( int i
= 0; i
< nCols
; i
++ )
9768 if ( m_selection
->IsInSelection(row
, i
) )
9769 m_selection
->ToggleCellSelection( row
, i
);
9774 void wxGrid::DeselectCol( int col
)
9779 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
9781 if ( m_selection
->IsInSelection(0, col
) )
9782 m_selection
->ToggleCellSelection( 0, col
);
9786 int nRows
= GetNumberRows();
9787 for ( int i
= 0; i
< nRows
; i
++ )
9789 if ( m_selection
->IsInSelection(i
, col
) )
9790 m_selection
->ToggleCellSelection(i
, col
);
9795 void wxGrid::DeselectCell( int row
, int col
)
9797 if ( m_selection
&& m_selection
->IsInSelection(row
, col
) )
9798 m_selection
->ToggleCellSelection(row
, col
);
9801 bool wxGrid::IsSelection()
9803 return ( m_selection
&& (m_selection
->IsSelection() ||
9804 ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
9805 m_selectingBottomRight
!= wxGridNoCellCoords
) ) );
9808 bool wxGrid::IsInSelection( int row
, int col
) const
9810 return ( m_selection
&& (m_selection
->IsInSelection( row
, col
) ||
9811 ( row
>= m_selectingTopLeft
.GetRow() &&
9812 col
>= m_selectingTopLeft
.GetCol() &&
9813 row
<= m_selectingBottomRight
.GetRow() &&
9814 col
<= m_selectingBottomRight
.GetCol() )) );
9817 wxGridCellCoordsArray
wxGrid::GetSelectedCells() const
9819 if (!m_selection
) { wxGridCellCoordsArray a
; return a
; }
9820 return m_selection
->m_cellSelection
;
9822 wxGridCellCoordsArray
wxGrid::GetSelectionBlockTopLeft() const
9824 if (!m_selection
) { wxGridCellCoordsArray a
; return a
; }
9825 return m_selection
->m_blockSelectionTopLeft
;
9827 wxGridCellCoordsArray
wxGrid::GetSelectionBlockBottomRight() const
9829 if (!m_selection
) { wxGridCellCoordsArray a
; return a
; }
9830 return m_selection
->m_blockSelectionBottomRight
;
9832 wxArrayInt
wxGrid::GetSelectedRows() const
9834 if (!m_selection
) { wxArrayInt a
; return a
; }
9835 return m_selection
->m_rowSelection
;
9837 wxArrayInt
wxGrid::GetSelectedCols() const
9839 if (!m_selection
) { wxArrayInt a
; return a
; }
9840 return m_selection
->m_colSelection
;
9844 void wxGrid::ClearSelection()
9846 m_selectingTopLeft
= wxGridNoCellCoords
;
9847 m_selectingBottomRight
= wxGridNoCellCoords
;
9849 m_selection
->ClearSelection();
9853 // This function returns the rectangle that encloses the given block
9854 // in device coords clipped to the client size of the grid window.
9856 wxRect
wxGrid::BlockToDeviceRect( const wxGridCellCoords
&topLeft
,
9857 const wxGridCellCoords
&bottomRight
)
9859 wxRect
rect( wxGridNoCellRect
);
9862 cellRect
= CellToRect( topLeft
);
9863 if ( cellRect
!= wxGridNoCellRect
)
9869 rect
= wxRect( 0, 0, 0, 0 );
9872 cellRect
= CellToRect( bottomRight
);
9873 if ( cellRect
!= wxGridNoCellRect
)
9879 return wxGridNoCellRect
;
9883 int left
= rect
.GetLeft();
9884 int top
= rect
.GetTop();
9885 int right
= rect
.GetRight();
9886 int bottom
= rect
.GetBottom();
9888 int leftCol
= topLeft
.GetCol();
9889 int topRow
= topLeft
.GetRow();
9890 int rightCol
= bottomRight
.GetCol();
9891 int bottomRow
= bottomRight
.GetRow();
9914 for ( j
= topRow
; j
<= bottomRow
; j
++ )
9916 for ( i
= leftCol
; i
<= rightCol
; i
++ )
9918 if ((j
==topRow
) || (j
==bottomRow
) || (i
==leftCol
) || (i
==rightCol
))
9920 cellRect
= CellToRect( j
, i
);
9922 if (cellRect
.x
< left
)
9924 if (cellRect
.y
< top
)
9926 if (cellRect
.x
+ cellRect
.width
> right
)
9927 right
= cellRect
.x
+ cellRect
.width
;
9928 if (cellRect
.y
+ cellRect
.height
> bottom
)
9929 bottom
= cellRect
.y
+ cellRect
.height
;
9931 else i
= rightCol
; // jump over inner cells.
9935 // convert to scrolled coords
9937 CalcScrolledPosition( left
, top
, &left
, &top
);
9938 CalcScrolledPosition( right
, bottom
, &right
, &bottom
);
9941 m_gridWin
->GetClientSize( &cw
, &ch
);
9943 if (right
< 0 || bottom
< 0 || left
> cw
|| top
> ch
)
9944 return wxRect( 0, 0, 0, 0);
9946 rect
.SetLeft( wxMax(0, left
) );
9947 rect
.SetTop( wxMax(0, top
) );
9948 rect
.SetRight( wxMin(cw
, right
) );
9949 rect
.SetBottom( wxMin(ch
, bottom
) );
9957 // ------ Grid event classes
9960 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent
, wxNotifyEvent
)
9962 wxGridEvent::wxGridEvent( int id
, wxEventType type
, wxObject
* obj
,
9963 int row
, int col
, int x
, int y
, bool sel
,
9964 bool control
, bool shift
, bool alt
, bool meta
)
9965 : wxNotifyEvent( type
, id
)
9972 m_control
= control
;
9977 SetEventObject(obj
);
9981 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent
, wxNotifyEvent
)
9983 wxGridSizeEvent::wxGridSizeEvent( int id
, wxEventType type
, wxObject
* obj
,
9984 int rowOrCol
, int x
, int y
,
9985 bool control
, bool shift
, bool alt
, bool meta
)
9986 : wxNotifyEvent( type
, id
)
9988 m_rowOrCol
= rowOrCol
;
9991 m_control
= control
;
9996 SetEventObject(obj
);
10000 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent
, wxNotifyEvent
)
10002 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id
, wxEventType type
, wxObject
* obj
,
10003 const wxGridCellCoords
& topLeft
,
10004 const wxGridCellCoords
& bottomRight
,
10005 bool sel
, bool control
,
10006 bool shift
, bool alt
, bool meta
)
10007 : wxNotifyEvent( type
, id
)
10009 m_topLeft
= topLeft
;
10010 m_bottomRight
= bottomRight
;
10012 m_control
= control
;
10017 SetEventObject(obj
);
10021 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent
, wxCommandEvent
)
10023 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id
, wxEventType type
,
10024 wxObject
* obj
, int row
,
10025 int col
, wxControl
* ctrl
)
10026 : wxCommandEvent(type
, id
)
10028 SetEventObject(obj
);
10035 #endif // !wxUSE_NEW_GRID/wxUSE_NEW_GRID
10037 #endif // wxUSE_GRID