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 WX_DECLARE_EXPORTED_OBJARRAY(wxGridCellWithAttr
, wxGridCellWithAttrArray
);
96 #include "wx/arrimpl.cpp"
98 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray
)
99 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray
)
101 // ----------------------------------------------------------------------------
103 // ----------------------------------------------------------------------------
105 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK
)
106 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK
)
107 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK
)
108 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK
)
109 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK
)
110 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK
)
111 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK
)
112 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK
)
113 DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE
)
114 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE
)
115 DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT
)
116 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE
)
117 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL
)
118 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN
)
119 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN
)
120 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED
)
122 // ----------------------------------------------------------------------------
124 // ----------------------------------------------------------------------------
126 class WXDLLEXPORT wxGridRowLabelWindow
: public wxWindow
129 wxGridRowLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
130 wxGridRowLabelWindow( wxGrid
*parent
, wxWindowID id
,
131 const wxPoint
&pos
, const wxSize
&size
);
136 void OnPaint( wxPaintEvent
& event
);
137 void OnMouseEvent( wxMouseEvent
& event
);
138 void OnMouseWheel( wxMouseEvent
& event
);
139 void OnKeyDown( wxKeyEvent
& event
);
140 void OnKeyUp( wxKeyEvent
& );
142 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow
)
143 DECLARE_EVENT_TABLE()
147 class WXDLLEXPORT wxGridColLabelWindow
: public wxWindow
150 wxGridColLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
151 wxGridColLabelWindow( wxGrid
*parent
, wxWindowID id
,
152 const wxPoint
&pos
, const wxSize
&size
);
157 void OnPaint( wxPaintEvent
&event
);
158 void OnMouseEvent( wxMouseEvent
& event
);
159 void OnMouseWheel( wxMouseEvent
& event
);
160 void OnKeyDown( wxKeyEvent
& event
);
161 void OnKeyUp( wxKeyEvent
& );
163 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow
)
164 DECLARE_EVENT_TABLE()
168 class WXDLLEXPORT wxGridCornerLabelWindow
: public wxWindow
171 wxGridCornerLabelWindow() { m_owner
= (wxGrid
*)NULL
; }
172 wxGridCornerLabelWindow( wxGrid
*parent
, wxWindowID id
,
173 const wxPoint
&pos
, const wxSize
&size
);
178 void OnMouseEvent( wxMouseEvent
& event
);
179 void OnMouseWheel( wxMouseEvent
& event
);
180 void OnKeyDown( wxKeyEvent
& event
);
181 void OnKeyUp( wxKeyEvent
& );
182 void OnPaint( wxPaintEvent
& event
);
184 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow
)
185 DECLARE_EVENT_TABLE()
188 class WXDLLEXPORT wxGridWindow
: public wxWindow
193 m_owner
= (wxGrid
*)NULL
;
194 m_rowLabelWin
= (wxGridRowLabelWindow
*)NULL
;
195 m_colLabelWin
= (wxGridColLabelWindow
*)NULL
;
198 wxGridWindow( wxGrid
*parent
,
199 wxGridRowLabelWindow
*rowLblWin
,
200 wxGridColLabelWindow
*colLblWin
,
201 wxWindowID id
, const wxPoint
&pos
, const wxSize
&size
);
204 void ScrollWindow( int dx
, int dy
, const wxRect
*rect
);
208 wxGridRowLabelWindow
*m_rowLabelWin
;
209 wxGridColLabelWindow
*m_colLabelWin
;
211 void OnPaint( wxPaintEvent
&event
);
212 void OnMouseWheel( wxMouseEvent
& event
);
213 void OnMouseEvent( wxMouseEvent
& event
);
214 void OnKeyDown( wxKeyEvent
& );
215 void OnKeyUp( wxKeyEvent
& );
216 void OnEraseBackground( wxEraseEvent
& );
219 DECLARE_DYNAMIC_CLASS(wxGridWindow
)
220 DECLARE_EVENT_TABLE()
225 class wxGridCellEditorEvtHandler
: public wxEvtHandler
228 wxGridCellEditorEvtHandler()
229 : m_grid(0), m_editor(0)
231 wxGridCellEditorEvtHandler(wxGrid
* grid
, wxGridCellEditor
* editor
)
232 : m_grid(grid
), m_editor(editor
)
235 void OnKeyDown(wxKeyEvent
& event
);
236 void OnChar(wxKeyEvent
& event
);
240 wxGridCellEditor
* m_editor
;
241 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler
)
242 DECLARE_EVENT_TABLE()
246 IMPLEMENT_DYNAMIC_CLASS( wxGridCellEditorEvtHandler
, wxEvtHandler
)
247 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler
, wxEvtHandler
)
248 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown
)
249 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar
)
254 // ----------------------------------------------------------------------------
255 // the internal data representation used by wxGridCellAttrProvider
256 // ----------------------------------------------------------------------------
258 // this class stores attributes set for cells
259 class WXDLLEXPORT wxGridCellAttrData
262 void SetAttr(wxGridCellAttr
*attr
, int row
, int col
);
263 wxGridCellAttr
*GetAttr(int row
, int col
) const;
264 void UpdateAttrRows( size_t pos
, int numRows
);
265 void UpdateAttrCols( size_t pos
, int numCols
);
268 // searches for the attr for given cell, returns wxNOT_FOUND if not found
269 int FindIndex(int row
, int col
) const;
271 wxGridCellWithAttrArray m_attrs
;
274 // this class stores attributes set for rows or columns
275 class WXDLLEXPORT wxGridRowOrColAttrData
278 // empty ctor to suppress warnings
279 wxGridRowOrColAttrData() { }
280 ~wxGridRowOrColAttrData();
282 void SetAttr(wxGridCellAttr
*attr
, int rowOrCol
);
283 wxGridCellAttr
*GetAttr(int rowOrCol
) const;
284 void UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
);
287 wxArrayInt m_rowsOrCols
;
288 wxArrayAttrs m_attrs
;
291 // NB: this is just a wrapper around 3 objects: one which stores cell
292 // attributes, and 2 others for row/col ones
293 class WXDLLEXPORT wxGridCellAttrProviderData
296 wxGridCellAttrData m_cellAttrs
;
297 wxGridRowOrColAttrData m_rowAttrs
,
302 // ----------------------------------------------------------------------------
303 // data structures used for the data type registry
304 // ----------------------------------------------------------------------------
306 struct wxGridDataTypeInfo
308 wxGridDataTypeInfo(const wxString
& typeName
,
309 wxGridCellRenderer
* renderer
,
310 wxGridCellEditor
* editor
)
311 : m_typeName(typeName
), m_renderer(renderer
), m_editor(editor
)
314 ~wxGridDataTypeInfo()
316 wxSafeDecRef(m_renderer
);
317 wxSafeDecRef(m_editor
);
321 wxGridCellRenderer
* m_renderer
;
322 wxGridCellEditor
* m_editor
;
326 WX_DEFINE_EXPORTED_ARRAY(wxGridDataTypeInfo
*, wxGridDataTypeInfoArray
);
329 class WXDLLEXPORT wxGridTypeRegistry
332 wxGridTypeRegistry() {}
333 ~wxGridTypeRegistry();
335 void RegisterDataType(const wxString
& typeName
,
336 wxGridCellRenderer
* renderer
,
337 wxGridCellEditor
* editor
);
339 // find one of already registered data types
340 int FindRegisteredDataType(const wxString
& typeName
);
342 // try to FindRegisteredDataType(), if this fails and typeName is one of
343 // standard typenames, register it and return its index
344 int FindDataType(const wxString
& typeName
);
346 // try to FindDataType(), if it fails see if it is not one of already
347 // registered data types with some params in which case clone the
348 // registered data type and set params for it
349 int FindOrCloneDataType(const wxString
& typeName
);
351 wxGridCellRenderer
* GetRenderer(int index
);
352 wxGridCellEditor
* GetEditor(int index
);
355 wxGridDataTypeInfoArray m_typeinfo
;
358 // ----------------------------------------------------------------------------
359 // conditional compilation
360 // ----------------------------------------------------------------------------
362 #ifndef WXGRID_DRAW_LINES
363 #define WXGRID_DRAW_LINES 1
366 // ----------------------------------------------------------------------------
368 // ----------------------------------------------------------------------------
370 //#define DEBUG_ATTR_CACHE
371 #ifdef DEBUG_ATTR_CACHE
372 static size_t gs_nAttrCacheHits
= 0;
373 static size_t gs_nAttrCacheMisses
= 0;
374 #endif // DEBUG_ATTR_CACHE
376 // ----------------------------------------------------------------------------
378 // ----------------------------------------------------------------------------
380 wxGridCellCoords
wxGridNoCellCoords( -1, -1 );
381 wxRect
wxGridNoCellRect( -1, -1, -1, -1 );
384 // TODO: this doesn't work at all, grid cells have different sizes and approx
385 // calculations don't work as because of the size mismatch scrollbars
386 // sometimes fail to be shown when they should be or vice versa
388 // The scroll bars may be a little flakey once in a while, but that is
389 // surely much less horrible than having scroll lines of only 1!!!
392 // Well, it's still seriously broken so it might be better but needs
395 static const size_t GRID_SCROLL_LINE_X
= 15; // 1;
396 static const size_t GRID_SCROLL_LINE_Y
= GRID_SCROLL_LINE_X
;
398 // the size of hash tables used a bit everywhere (the max number of elements
399 // in these hash tables is the number of rows/columns)
400 static const int GRID_HASH_SIZE
= 100;
402 // ----------------------------------------------------------------------------
404 // ----------------------------------------------------------------------------
406 static inline int GetScrollX(int x
)
408 return (x
+ GRID_SCROLL_LINE_X
- 1) / GRID_SCROLL_LINE_X
;
411 static inline int GetScrollY(int y
)
413 return (y
+ GRID_SCROLL_LINE_Y
- 1) / GRID_SCROLL_LINE_Y
;
416 // ============================================================================
418 // ============================================================================
420 // ----------------------------------------------------------------------------
422 // ----------------------------------------------------------------------------
424 wxGridCellEditor::wxGridCellEditor()
430 wxGridCellEditor::~wxGridCellEditor()
435 void wxGridCellEditor::Create(wxWindow
* WXUNUSED(parent
),
436 wxWindowID
WXUNUSED(id
),
437 wxEvtHandler
* evtHandler
)
440 m_control
->PushEventHandler(evtHandler
);
443 void wxGridCellEditor::PaintBackground(const wxRect
& rectCell
,
444 wxGridCellAttr
*attr
)
446 // erase the background because we might not fill the cell
447 wxClientDC
dc(m_control
->GetParent());
448 dc
.SetPen(*wxTRANSPARENT_PEN
);
449 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
450 dc
.DrawRectangle(rectCell
);
452 // redraw the control we just painted over
453 m_control
->Refresh();
456 void wxGridCellEditor::Destroy()
460 m_control
->PopEventHandler(TRUE
/* delete it*/);
462 m_control
->Destroy();
467 void wxGridCellEditor::Show(bool show
, wxGridCellAttr
*attr
)
469 wxASSERT_MSG(m_control
,
470 wxT("The wxGridCellEditor must be Created first!"));
471 m_control
->Show(show
);
475 // set the colours/fonts if we have any
478 m_colFgOld
= m_control
->GetForegroundColour();
479 m_control
->SetForegroundColour(attr
->GetTextColour());
481 m_colBgOld
= m_control
->GetBackgroundColour();
482 m_control
->SetBackgroundColour(attr
->GetBackgroundColour());
484 m_fontOld
= m_control
->GetFont();
485 m_control
->SetFont(attr
->GetFont());
487 // can't do anything more in the base class version, the other
488 // attributes may only be used by the derived classes
493 // restore the standard colours fonts
494 if ( m_colFgOld
.Ok() )
496 m_control
->SetForegroundColour(m_colFgOld
);
497 m_colFgOld
= wxNullColour
;
500 if ( m_colBgOld
.Ok() )
502 m_control
->SetBackgroundColour(m_colBgOld
);
503 m_colBgOld
= wxNullColour
;
506 if ( m_fontOld
.Ok() )
508 m_control
->SetFont(m_fontOld
);
509 m_fontOld
= wxNullFont
;
514 void wxGridCellEditor::SetSize(const wxRect
& rect
)
516 wxASSERT_MSG(m_control
,
517 wxT("The wxGridCellEditor must be Created first!"));
518 m_control
->SetSize(rect
, wxSIZE_ALLOW_MINUS_ONE
);
521 void wxGridCellEditor::HandleReturn(wxKeyEvent
& event
)
526 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent
& event
)
528 // accept the simple key presses, not anything with Ctrl/Alt/Meta
529 return !(event
.ControlDown() || event
.AltDown());
532 void wxGridCellEditor::StartingKey(wxKeyEvent
& event
)
537 void wxGridCellEditor::StartingClick()
543 // ----------------------------------------------------------------------------
544 // wxGridCellTextEditor
545 // ----------------------------------------------------------------------------
547 wxGridCellTextEditor::wxGridCellTextEditor()
552 void wxGridCellTextEditor::Create(wxWindow
* parent
,
554 wxEvtHandler
* evtHandler
)
556 m_control
= new wxTextCtrl(parent
, id
, wxEmptyString
,
557 wxDefaultPosition
, wxDefaultSize
558 #if defined(__WXMSW__)
559 , wxTE_PROCESS_TAB
| wxTE_MULTILINE
|
560 wxTE_NO_VSCROLL
| wxTE_AUTO_SCROLL
564 // TODO: use m_maxChars
566 wxGridCellEditor::Create(parent
, id
, evtHandler
);
569 void wxGridCellTextEditor::PaintBackground(const wxRect
& WXUNUSED(rectCell
),
570 wxGridCellAttr
* WXUNUSED(attr
))
572 // as we fill the entire client area, don't do anything here to minimize
576 void wxGridCellTextEditor::SetSize(const wxRect
& rectOrig
)
578 wxRect
rect(rectOrig
);
580 // Make the edit control large enough to allow for internal
583 // TODO: remove this if the text ctrl sizing is improved esp. for
586 #if defined(__WXGTK__)
595 int extra_x
= ( rect
.x
> 2 )? 2 : 1;
597 // MB: treat MSW separately here otherwise the caret doesn't show
598 // when the editor is in the first row.
599 #if defined(__WXMSW__)
602 int extra_y
= ( rect
.y
> 2 )? 2 : 1;
605 #if defined(__WXMOTIF__)
609 rect
.SetLeft( wxMax(0, rect
.x
- extra_x
) );
610 rect
.SetTop( wxMax(0, rect
.y
- extra_y
) );
611 rect
.SetRight( rect
.GetRight() + 2*extra_x
);
612 rect
.SetBottom( rect
.GetBottom() + 2*extra_y
);
615 wxGridCellEditor::SetSize(rect
);
618 void wxGridCellTextEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
620 wxASSERT_MSG(m_control
,
621 wxT("The wxGridCellEditor must be Created first!"));
623 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
625 DoBeginEdit(m_startValue
);
628 void wxGridCellTextEditor::DoBeginEdit(const wxString
& startValue
)
630 Text()->SetValue(startValue
);
631 Text()->SetInsertionPointEnd();
635 bool wxGridCellTextEditor::EndEdit(int row
, int col
,
638 wxASSERT_MSG(m_control
,
639 wxT("The wxGridCellEditor must be Created first!"));
641 bool changed
= FALSE
;
642 wxString value
= Text()->GetValue();
643 if (value
!= m_startValue
)
647 grid
->GetTable()->SetValue(row
, col
, value
);
649 m_startValue
= wxEmptyString
;
650 Text()->SetValue(m_startValue
);
656 void wxGridCellTextEditor::Reset()
658 wxASSERT_MSG(m_control
,
659 wxT("The wxGridCellEditor must be Created first!"));
661 DoReset(m_startValue
);
664 void wxGridCellTextEditor::DoReset(const wxString
& startValue
)
666 Text()->SetValue(startValue
);
667 Text()->SetInsertionPointEnd();
670 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent
& event
)
672 if ( wxGridCellEditor::IsAcceptedKey(event
) )
674 int keycode
= event
.GetKeyCode();
688 case WXK_NUMPAD_MULTIPLY
:
692 case WXK_NUMPAD_SUBTRACT
:
694 case WXK_NUMPAD_DECIMAL
:
696 case WXK_NUMPAD_DIVIDE
:
700 // accept 8 bit chars too if isprint() agrees
701 if ( (keycode
< 255) && (isprint(keycode
)) )
709 void wxGridCellTextEditor::StartingKey(wxKeyEvent
& event
)
711 if ( !Text()->EmulateKeyPress(event
) )
717 void wxGridCellTextEditor::HandleReturn( wxKeyEvent
&
718 WXUNUSED_GTK(WXUNUSED_MOTIF(event
)) )
720 #if defined(__WXMOTIF__) || defined(__WXGTK__)
721 // wxMotif needs a little extra help...
722 size_t pos
= (size_t)( Text()->GetInsertionPoint() );
723 wxString
s( Text()->GetValue() );
724 s
= s
.Left(pos
) + "\n" + s
.Mid(pos
);
726 Text()->SetInsertionPoint( pos
);
728 // the other ports can handle a Return key press
734 void wxGridCellTextEditor::SetParameters(const wxString
& params
)
744 if ( !params
.ToLong(&tmp
) )
746 wxLogDebug(_T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params
.c_str());
750 m_maxChars
= (size_t)tmp
;
755 // ----------------------------------------------------------------------------
756 // wxGridCellNumberEditor
757 // ----------------------------------------------------------------------------
759 wxGridCellNumberEditor::wxGridCellNumberEditor(int min
, int max
)
765 void wxGridCellNumberEditor::Create(wxWindow
* parent
,
767 wxEvtHandler
* evtHandler
)
771 // create a spin ctrl
772 m_control
= new wxSpinCtrl(parent
, -1, wxEmptyString
,
773 wxDefaultPosition
, wxDefaultSize
,
777 wxGridCellEditor::Create(parent
, id
, evtHandler
);
781 // just a text control
782 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
785 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
786 #endif // wxUSE_VALIDATORS
790 void wxGridCellNumberEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
792 // first get the value
793 wxGridTableBase
*table
= grid
->GetTable();
794 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
796 m_valueOld
= table
->GetValueAsLong(row
, col
);
800 wxString sValue
= table
->GetValue(row
, col
);
801 if (! sValue
.ToLong(&m_valueOld
))
803 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
810 Spin()->SetValue((int)m_valueOld
);
815 DoBeginEdit(GetString());
819 bool wxGridCellNumberEditor::EndEdit(int row
, int col
,
827 value
= Spin()->GetValue();
828 changed
= value
!= m_valueOld
;
832 changed
= Text()->GetValue().ToLong(&value
) && (value
!= m_valueOld
);
837 if (grid
->GetTable()->CanSetValueAs(row
, col
, wxGRID_VALUE_NUMBER
))
838 grid
->GetTable()->SetValueAsLong(row
, col
, value
);
840 grid
->GetTable()->SetValue(row
, col
, wxString::Format(wxT("%ld"), value
));
846 void wxGridCellNumberEditor::Reset()
850 Spin()->SetValue((int)m_valueOld
);
854 DoReset(GetString());
858 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent
& event
)
860 if ( wxGridCellEditor::IsAcceptedKey(event
) )
862 int keycode
= event
.GetKeyCode();
878 case WXK_NUMPAD_SUBTRACT
:
884 if ( (keycode
< 128) && isdigit(keycode
) )
892 void wxGridCellNumberEditor::StartingKey(wxKeyEvent
& event
)
896 int keycode
= (int) event
.KeyCode();
897 if ( isdigit(keycode
) || keycode
== '+' || keycode
== '-' )
899 wxGridCellTextEditor::StartingKey(event
);
909 void wxGridCellNumberEditor::SetParameters(const wxString
& params
)
920 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
924 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
928 // skip the error message below
933 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params
.c_str());
937 // ----------------------------------------------------------------------------
938 // wxGridCellFloatEditor
939 // ----------------------------------------------------------------------------
941 wxGridCellFloatEditor::wxGridCellFloatEditor(int width
, int precision
)
944 m_precision
= precision
;
947 void wxGridCellFloatEditor::Create(wxWindow
* parent
,
949 wxEvtHandler
* evtHandler
)
951 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
954 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
955 #endif // wxUSE_VALIDATORS
958 void wxGridCellFloatEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
960 // first get the value
961 wxGridTableBase
*table
= grid
->GetTable();
962 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
964 m_valueOld
= table
->GetValueAsDouble(row
, col
);
968 wxString sValue
= table
->GetValue(row
, col
);
969 if (! sValue
.ToDouble(&m_valueOld
))
971 wxFAIL_MSG( _T("this cell doesn't have float value") );
976 DoBeginEdit(GetString());
979 bool wxGridCellFloatEditor::EndEdit(int row
, int col
,
983 if ( Text()->GetValue().ToDouble(&value
) && (value
!= m_valueOld
) )
985 if (grid
->GetTable()->CanSetValueAs(row
, col
, wxGRID_VALUE_FLOAT
))
986 grid
->GetTable()->SetValueAsDouble(row
, col
, value
);
988 grid
->GetTable()->SetValue(row
, col
, wxString::Format(wxT("%f"), value
));
998 void wxGridCellFloatEditor::Reset()
1000 DoReset(GetString());
1003 void wxGridCellFloatEditor::StartingKey(wxKeyEvent
& event
)
1005 int keycode
= (int)event
.KeyCode();
1006 if ( isdigit(keycode
) ||
1007 keycode
== '+' || keycode
== '-' || keycode
== '.' )
1009 wxGridCellTextEditor::StartingKey(event
);
1011 // skip Skip() below
1018 void wxGridCellFloatEditor::SetParameters(const wxString
& params
)
1029 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
1033 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
1035 m_precision
= (int)tmp
;
1037 // skip the error message below
1042 wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params
.c_str());
1046 wxString
wxGridCellFloatEditor::GetString() const
1049 if ( m_width
== -1 )
1051 // default width/precision
1054 else if ( m_precision
== -1 )
1056 // default precision
1057 fmt
.Printf(_T("%%%d.g"), m_width
);
1061 fmt
.Printf(_T("%%%d.%dg"), m_width
, m_precision
);
1064 return wxString::Format(fmt
, m_valueOld
);
1067 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent
& event
)
1069 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1071 int keycode
= event
.GetKeyCode();
1085 case WXK_NUMPAD_ADD
:
1087 case WXK_NUMPAD_SUBTRACT
:
1089 case WXK_NUMPAD_DECIMAL
:
1093 // additionally accept 'e' as in '1e+6'
1094 if ( (keycode
< 128) &&
1095 (isdigit(keycode
) || tolower(keycode
) == 'e') )
1103 #endif // wxUSE_TEXTCTRL
1107 // ----------------------------------------------------------------------------
1108 // wxGridCellBoolEditor
1109 // ----------------------------------------------------------------------------
1111 void wxGridCellBoolEditor::Create(wxWindow
* parent
,
1113 wxEvtHandler
* evtHandler
)
1115 m_control
= new wxCheckBox(parent
, id
, wxEmptyString
,
1116 wxDefaultPosition
, wxDefaultSize
,
1119 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1122 void wxGridCellBoolEditor::SetSize(const wxRect
& r
)
1124 bool resize
= FALSE
;
1125 wxSize size
= m_control
->GetSize();
1126 wxCoord minSize
= wxMin(r
.width
, r
.height
);
1128 // check if the checkbox is not too big/small for this cell
1129 wxSize sizeBest
= m_control
->GetBestSize();
1130 if ( !(size
== sizeBest
) )
1132 // reset to default size if it had been made smaller
1138 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
1140 // leave 1 pixel margin
1141 size
.x
= size
.y
= minSize
- 2;
1148 m_control
->SetSize(size
);
1151 // position it in the centre of the rectangle (TODO: support alignment?)
1153 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1154 // the checkbox without label still has some space to the right in wxGTK,
1155 // so shift it to the right
1157 #elif defined(__WXMSW__)
1158 // here too, but in other way
1163 m_control
->Move(r
.x
+ r
.width
/2 - size
.x
/2, r
.y
+ r
.height
/2 - size
.y
/2);
1166 void wxGridCellBoolEditor::Show(bool show
, wxGridCellAttr
*attr
)
1168 m_control
->Show(show
);
1172 wxColour colBg
= attr
? attr
->GetBackgroundColour() : *wxLIGHT_GREY
;
1173 CBox()->SetBackgroundColour(colBg
);
1177 void wxGridCellBoolEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1179 wxASSERT_MSG(m_control
,
1180 wxT("The wxGridCellEditor must be Created first!"));
1182 if (grid
->GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
))
1183 m_startValue
= grid
->GetTable()->GetValueAsBool(row
, col
);
1186 wxString
cellval( grid
->GetTable()->GetValue(row
, col
) );
1187 m_startValue
= !( !cellval
|| (cellval
== "0") );
1189 CBox()->SetValue(m_startValue
);
1193 bool wxGridCellBoolEditor::EndEdit(int row
, int col
,
1196 wxASSERT_MSG(m_control
,
1197 wxT("The wxGridCellEditor must be Created first!"));
1199 bool changed
= FALSE
;
1200 bool value
= CBox()->GetValue();
1201 if ( value
!= m_startValue
)
1206 if (grid
->GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
))
1207 grid
->GetTable()->SetValueAsBool(row
, col
, value
);
1209 grid
->GetTable()->SetValue(row
, col
, value
? _T("1") : wxEmptyString
);
1215 void wxGridCellBoolEditor::Reset()
1217 wxASSERT_MSG(m_control
,
1218 wxT("The wxGridCellEditor must be Created first!"));
1220 CBox()->SetValue(m_startValue
);
1223 void wxGridCellBoolEditor::StartingClick()
1225 CBox()->SetValue(!CBox()->GetValue());
1228 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent
& event
)
1230 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1232 int keycode
= event
.GetKeyCode();
1236 case WXK_NUMPAD_MULTIPLY
:
1238 case WXK_NUMPAD_ADD
:
1240 case WXK_NUMPAD_SUBTRACT
:
1251 #endif // wxUSE_CHECKBOX
1255 // ----------------------------------------------------------------------------
1256 // wxGridCellChoiceEditor
1257 // ----------------------------------------------------------------------------
1259 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count
,
1260 const wxString choices
[],
1262 : m_allowOthers(allowOthers
)
1266 m_choices
.Alloc(count
);
1267 for ( size_t n
= 0; n
< count
; n
++ )
1269 m_choices
.Add(choices
[n
]);
1274 wxGridCellEditor
*wxGridCellChoiceEditor::Clone() const
1276 wxGridCellChoiceEditor
*editor
= new wxGridCellChoiceEditor
;
1277 editor
->m_allowOthers
= m_allowOthers
;
1278 editor
->m_choices
= m_choices
;
1283 void wxGridCellChoiceEditor::Create(wxWindow
* parent
,
1285 wxEvtHandler
* evtHandler
)
1287 size_t count
= m_choices
.GetCount();
1288 wxString
*choices
= new wxString
[count
];
1289 for ( size_t n
= 0; n
< count
; n
++ )
1291 choices
[n
] = m_choices
[n
];
1294 m_control
= new wxComboBox(parent
, id
, wxEmptyString
,
1295 wxDefaultPosition
, wxDefaultSize
,
1297 m_allowOthers
? 0 : wxCB_READONLY
);
1301 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1304 void wxGridCellChoiceEditor::PaintBackground(const wxRect
& rectCell
,
1305 wxGridCellAttr
* attr
)
1307 // as we fill the entire client area, don't do anything here to minimize
1310 // TODO: It doesn't actually fill the client area since the height of a
1311 // combo always defaults to the standard... Until someone has time to
1312 // figure out the right rectangle to paint, just do it the normal way...
1313 wxGridCellEditor::PaintBackground(rectCell
, attr
);
1316 void wxGridCellChoiceEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1318 wxASSERT_MSG(m_control
,
1319 wxT("The wxGridCellEditor must be Created first!"));
1321 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
1323 Combo()->SetValue(m_startValue
);
1324 size_t count
= m_choices
.GetCount();
1325 for (size_t i
=0; i
<count
; i
++)
1327 if (m_startValue
== m_choices
[i
])
1329 Combo()->SetSelection(i
);
1333 Combo()->SetInsertionPointEnd();
1334 Combo()->SetFocus();
1337 bool wxGridCellChoiceEditor::EndEdit(int row
, int col
,
1340 wxString value
= Combo()->GetValue();
1341 bool changed
= value
!= m_startValue
;
1344 grid
->GetTable()->SetValue(row
, col
, value
);
1346 m_startValue
= wxEmptyString
;
1347 Combo()->SetValue(m_startValue
);
1352 void wxGridCellChoiceEditor::Reset()
1354 Combo()->SetValue(m_startValue
);
1355 Combo()->SetInsertionPointEnd();
1358 void wxGridCellChoiceEditor::SetParameters(const wxString
& params
)
1368 wxStringTokenizer
tk(params
, _T(','));
1369 while ( tk
.HasMoreTokens() )
1371 m_choices
.Add(tk
.GetNextToken());
1375 #endif // wxUSE_COMBOBOX
1377 // ----------------------------------------------------------------------------
1378 // wxGridCellEditorEvtHandler
1379 // ----------------------------------------------------------------------------
1381 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent
& event
)
1383 switch ( event
.KeyCode() )
1387 m_grid
->DisableCellEditControl();
1391 m_grid
->GetEventHandler()->ProcessEvent( event
);
1395 case WXK_NUMPAD_ENTER
:
1396 if (!m_grid
->GetEventHandler()->ProcessEvent(event
))
1397 m_editor
->HandleReturn(event
);
1406 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent
& event
)
1408 switch ( event
.KeyCode() )
1413 case WXK_NUMPAD_ENTER
:
1421 // ----------------------------------------------------------------------------
1422 // wxGridCellWorker is an (almost) empty common base class for
1423 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1424 // ----------------------------------------------------------------------------
1426 void wxGridCellWorker::SetParameters(const wxString
& WXUNUSED(params
))
1431 wxGridCellWorker::~wxGridCellWorker()
1435 // ============================================================================
1437 // ============================================================================
1439 // ----------------------------------------------------------------------------
1440 // wxGridCellRenderer
1441 // ----------------------------------------------------------------------------
1443 void wxGridCellRenderer::Draw(wxGrid
& grid
,
1444 wxGridCellAttr
& attr
,
1447 int WXUNUSED(row
), int WXUNUSED(col
),
1450 dc
.SetBackgroundMode( wxSOLID
);
1454 dc
.SetBrush( wxBrush(grid
.GetSelectionBackground(), wxSOLID
) );
1458 dc
.SetBrush( wxBrush(attr
.GetBackgroundColour(), wxSOLID
) );
1461 dc
.SetPen( *wxTRANSPARENT_PEN
);
1462 dc
.DrawRectangle(rect
);
1465 // ----------------------------------------------------------------------------
1466 // wxGridCellStringRenderer
1467 // ----------------------------------------------------------------------------
1469 void wxGridCellStringRenderer::SetTextColoursAndFont(wxGrid
& grid
,
1470 wxGridCellAttr
& attr
,
1474 dc
.SetBackgroundMode( wxTRANSPARENT
);
1476 // TODO some special colours for attr.IsReadOnly() case?
1480 dc
.SetTextBackground( grid
.GetSelectionBackground() );
1481 dc
.SetTextForeground( grid
.GetSelectionForeground() );
1485 dc
.SetTextBackground( attr
.GetBackgroundColour() );
1486 dc
.SetTextForeground( attr
.GetTextColour() );
1489 dc
.SetFont( attr
.GetFont() );
1492 wxSize
wxGridCellStringRenderer::DoGetBestSize(wxGridCellAttr
& attr
,
1494 const wxString
& text
)
1496 wxCoord x
= 0, y
= 0, max_x
= 0;
1497 dc
.SetFont(attr
.GetFont());
1498 wxStringTokenizer
tk(text
, _T('\n'));
1499 while ( tk
.HasMoreTokens() )
1501 dc
.GetTextExtent(tk
.GetNextToken(), &x
, &y
);
1502 max_x
= wxMax(max_x
, x
);
1505 y
*= 1 + text
.Freq(wxT('\n')); // multiply by the number of lines.
1507 return wxSize(max_x
, y
);
1510 wxSize
wxGridCellStringRenderer::GetBestSize(wxGrid
& grid
,
1511 wxGridCellAttr
& attr
,
1515 return DoGetBestSize(attr
, dc
, grid
.GetCellValue(row
, col
));
1518 void wxGridCellStringRenderer::Draw(wxGrid
& grid
,
1519 wxGridCellAttr
& attr
,
1521 const wxRect
& rectCell
,
1525 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1527 // now we only have to draw the text
1528 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
1531 attr
.GetAlignment(&hAlign
, &vAlign
);
1533 wxRect rect
= rectCell
;
1536 grid
.DrawTextRectangle(dc
, grid
.GetCellValue(row
, col
),
1537 rect
, hAlign
, vAlign
);
1540 // ----------------------------------------------------------------------------
1541 // wxGridCellNumberRenderer
1542 // ----------------------------------------------------------------------------
1544 wxString
wxGridCellNumberRenderer::GetString(wxGrid
& grid
, int row
, int col
)
1546 wxGridTableBase
*table
= grid
.GetTable();
1548 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
1550 text
.Printf(_T("%ld"), table
->GetValueAsLong(row
, col
));
1554 text
= table
->GetValue(row
, col
);
1560 void wxGridCellNumberRenderer::Draw(wxGrid
& grid
,
1561 wxGridCellAttr
& attr
,
1563 const wxRect
& rectCell
,
1567 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1569 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
1571 // draw the text right aligned by default
1573 attr
.GetAlignment(&hAlign
, &vAlign
);
1574 hAlign
= wxALIGN_RIGHT
;
1576 wxRect rect
= rectCell
;
1579 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
1582 wxSize
wxGridCellNumberRenderer::GetBestSize(wxGrid
& grid
,
1583 wxGridCellAttr
& attr
,
1587 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
1590 // ----------------------------------------------------------------------------
1591 // wxGridCellFloatRenderer
1592 // ----------------------------------------------------------------------------
1594 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width
, int precision
)
1597 SetPrecision(precision
);
1600 wxGridCellRenderer
*wxGridCellFloatRenderer::Clone() const
1602 wxGridCellFloatRenderer
*renderer
= new wxGridCellFloatRenderer
;
1603 renderer
->m_width
= m_width
;
1604 renderer
->m_precision
= m_precision
;
1605 renderer
->m_format
= m_format
;
1610 wxString
wxGridCellFloatRenderer::GetString(wxGrid
& grid
, int row
, int col
)
1612 wxGridTableBase
*table
= grid
.GetTable();
1617 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
1619 val
= table
->GetValueAsDouble(row
, col
);
1624 text
= table
->GetValue(row
, col
);
1625 hasDouble
= text
.ToDouble(&val
);
1632 if ( m_width
== -1 )
1634 if ( m_precision
== -1 )
1636 // default width/precision
1637 m_format
= _T("%f");
1641 m_format
.Printf(_T("%%.%df"), m_precision
);
1644 else if ( m_precision
== -1 )
1646 // default precision
1647 m_format
.Printf(_T("%%%d.f"), m_width
);
1651 m_format
.Printf(_T("%%%d.%df"), m_width
, m_precision
);
1655 text
.Printf(m_format
, val
);
1658 //else: text already contains the string
1663 void wxGridCellFloatRenderer::Draw(wxGrid
& grid
,
1664 wxGridCellAttr
& attr
,
1666 const wxRect
& rectCell
,
1670 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1672 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
1674 // draw the text right aligned by default
1676 attr
.GetAlignment(&hAlign
, &vAlign
);
1677 hAlign
= wxALIGN_RIGHT
;
1679 wxRect rect
= rectCell
;
1682 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
1685 wxSize
wxGridCellFloatRenderer::GetBestSize(wxGrid
& grid
,
1686 wxGridCellAttr
& attr
,
1690 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
1693 void wxGridCellFloatRenderer::SetParameters(const wxString
& params
)
1697 // reset to defaults
1703 wxString tmp
= params
.BeforeFirst(_T(','));
1707 if ( tmp
.ToLong(&width
) )
1709 SetWidth((int)width
);
1713 wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params
.c_str());
1717 tmp
= params
.AfterFirst(_T(','));
1721 if ( tmp
.ToLong(&precision
) )
1723 SetPrecision((int)precision
);
1727 wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params
.c_str());
1735 // ----------------------------------------------------------------------------
1736 // wxGridCellBoolRenderer
1737 // ----------------------------------------------------------------------------
1739 wxSize
wxGridCellBoolRenderer::ms_sizeCheckMark
;
1741 // FIXME these checkbox size calculations are really ugly...
1743 // between checkmark and box
1744 static const wxCoord wxGRID_CHECKMARK_MARGIN
= 2;
1746 wxSize
wxGridCellBoolRenderer::GetBestSize(wxGrid
& grid
,
1747 wxGridCellAttr
& WXUNUSED(attr
),
1752 // compute it only once (no locks for MT safeness in GUI thread...)
1753 if ( !ms_sizeCheckMark
.x
)
1755 // get checkbox size
1756 wxCoord checkSize
= 0;
1757 wxCheckBox
*checkbox
= new wxCheckBox(&grid
, -1, wxEmptyString
);
1758 wxSize size
= checkbox
->GetBestSize();
1759 checkSize
= size
.y
+ 2*wxGRID_CHECKMARK_MARGIN
;
1761 // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
1762 #if defined(__WXGTK__) || defined(__WXMOTIF__)
1763 checkSize
-= size
.y
/ 2;
1768 ms_sizeCheckMark
.x
= ms_sizeCheckMark
.y
= checkSize
;
1771 return ms_sizeCheckMark
;
1774 void wxGridCellBoolRenderer::Draw(wxGrid
& grid
,
1775 wxGridCellAttr
& attr
,
1781 wxGridCellRenderer::Draw(grid
, attr
, dc
, rect
, row
, col
, isSelected
);
1783 // draw a check mark in the centre (ignoring alignment - TODO)
1784 wxSize size
= GetBestSize(grid
, attr
, dc
, row
, col
);
1786 // don't draw outside the cell
1787 wxCoord minSize
= wxMin(rect
.width
, rect
.height
);
1788 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
1790 // and even leave (at least) 1 pixel margin
1791 size
.x
= size
.y
= minSize
- 2;
1794 // draw a border around checkmark
1796 rectBorder
.x
= rect
.x
+ rect
.width
/2 - size
.x
/2;
1797 rectBorder
.y
= rect
.y
+ rect
.height
/2 - size
.y
/2;
1798 rectBorder
.width
= size
.x
;
1799 rectBorder
.height
= size
.y
;
1802 if ( grid
.GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
) )
1803 value
= grid
.GetTable()->GetValueAsBool(row
, col
);
1806 wxString
cellval( grid
.GetTable()->GetValue(row
, col
) );
1807 value
= !( !cellval
|| (cellval
== "0") );
1812 wxRect rectMark
= rectBorder
;
1814 // MSW DrawCheckMark() is weird (and should probably be changed...)
1815 rectMark
.Inflate(-wxGRID_CHECKMARK_MARGIN
/2);
1819 rectMark
.Inflate(-wxGRID_CHECKMARK_MARGIN
);
1822 dc
.SetTextForeground(attr
.GetTextColour());
1823 dc
.DrawCheckMark(rectMark
);
1826 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
1827 dc
.SetPen(wxPen(attr
.GetTextColour(), 1, wxSOLID
));
1828 dc
.DrawRectangle(rectBorder
);
1831 // ----------------------------------------------------------------------------
1833 // ----------------------------------------------------------------------------
1835 void wxGridCellAttr::Init(wxGridCellAttr
*attrDefault
)
1839 m_isReadOnly
= Unset
;
1844 m_attrkind
= wxGridCellAttr::Cell
;
1846 SetDefAttr(attrDefault
);
1849 wxGridCellAttr
*wxGridCellAttr::Clone() const
1851 wxGridCellAttr
*attr
= new wxGridCellAttr(m_defGridAttr
);
1853 if ( HasTextColour() )
1854 attr
->SetTextColour(GetTextColour());
1855 if ( HasBackgroundColour() )
1856 attr
->SetBackgroundColour(GetBackgroundColour());
1858 attr
->SetFont(GetFont());
1859 if ( HasAlignment() )
1860 attr
->SetAlignment(m_hAlign
, m_vAlign
);
1864 attr
->SetRenderer(m_renderer
);
1865 m_renderer
->IncRef();
1869 attr
->SetEditor(m_editor
);
1874 attr
->SetReadOnly();
1876 attr
->SetKind( m_attrkind
);
1881 void wxGridCellAttr::MergeWith(wxGridCellAttr
*mergefrom
)
1883 if ( !HasTextColour() && mergefrom
->HasTextColour() )
1884 SetTextColour(mergefrom
->GetTextColour());
1885 if ( !HasBackgroundColour() && mergefrom
->HasBackgroundColour() )
1886 SetBackgroundColour(mergefrom
->GetBackgroundColour());
1887 if ( !HasFont() && mergefrom
->HasFont() )
1888 SetFont(mergefrom
->GetFont());
1889 if ( !!HasAlignment() && mergefrom
->HasAlignment() ){
1891 mergefrom
->GetAlignment( &hAlign
, &vAlign
);
1892 SetAlignment(hAlign
, vAlign
);
1895 // Directly access member functions as GetRender/Editor don't just return
1896 // m_renderer/m_editor
1898 // Maybe add support for merge of Render and Editor?
1899 if (!HasRenderer() && mergefrom
->HasRenderer() )
1901 m_renderer
= mergefrom
->m_renderer
;
1902 m_renderer
->IncRef();
1904 if ( !HasEditor() && mergefrom
->HasEditor() )
1906 m_editor
= mergefrom
->m_editor
;
1909 if ( !HasReadWriteMode() && mergefrom
->HasReadWriteMode() )
1910 SetReadOnly(mergefrom
->IsReadOnly());
1912 SetDefAttr(mergefrom
->m_defGridAttr
);
1915 const wxColour
& wxGridCellAttr::GetTextColour() const
1917 if (HasTextColour())
1921 else if (m_defGridAttr
&& m_defGridAttr
!= this)
1923 return m_defGridAttr
->GetTextColour();
1927 wxFAIL_MSG(wxT("Missing default cell attribute"));
1928 return wxNullColour
;
1933 const wxColour
& wxGridCellAttr::GetBackgroundColour() const
1935 if (HasBackgroundColour())
1937 else if (m_defGridAttr
&& m_defGridAttr
!= this)
1938 return m_defGridAttr
->GetBackgroundColour();
1941 wxFAIL_MSG(wxT("Missing default cell attribute"));
1942 return wxNullColour
;
1947 const wxFont
& wxGridCellAttr::GetFont() const
1951 else if (m_defGridAttr
&& m_defGridAttr
!= this)
1952 return m_defGridAttr
->GetFont();
1955 wxFAIL_MSG(wxT("Missing default cell attribute"));
1961 void wxGridCellAttr::GetAlignment(int *hAlign
, int *vAlign
) const
1965 if ( hAlign
) *hAlign
= m_hAlign
;
1966 if ( vAlign
) *vAlign
= m_vAlign
;
1968 else if (m_defGridAttr
&& m_defGridAttr
!= this)
1969 m_defGridAttr
->GetAlignment(hAlign
, vAlign
);
1972 wxFAIL_MSG(wxT("Missing default cell attribute"));
1977 // GetRenderer and GetEditor use a slightly different decision path about
1978 // which attribute to use. If a non-default attr object has one then it is
1979 // used, otherwise the default editor or renderer is fetched from the grid and
1980 // used. It should be the default for the data type of the cell. If it is
1981 // NULL (because the table has a type that the grid does not have in its
1982 // registry,) then the grid's default editor or renderer is used.
1984 wxGridCellRenderer
* wxGridCellAttr::GetRenderer(wxGrid
* grid
, int row
, int col
) const
1986 wxGridCellRenderer
*renderer
;
1988 if ( m_renderer
&& this != m_defGridAttr
)
1990 // use the cells renderer if it has one
1991 renderer
= m_renderer
;
1994 else // no non default cell renderer
1996 // get default renderer for the data type
1999 // GetDefaultRendererForCell() will do IncRef() for us
2000 renderer
= grid
->GetDefaultRendererForCell(row
, col
);
2009 if (m_defGridAttr
&& this != m_defGridAttr
)
2011 // if we still don't have one then use the grid default
2012 // (no need for IncRef() here neither)
2013 renderer
= m_defGridAttr
->GetRenderer(NULL
, 0, 0);
2015 else // default grid attr
2017 // use m_renderer which we had decided not to use initially
2018 renderer
= m_renderer
;
2025 // we're supposed to always find something
2026 wxASSERT_MSG(renderer
, wxT("Missing default cell renderer"));
2031 // same as above, except for s/renderer/editor/g
2032 wxGridCellEditor
* wxGridCellAttr::GetEditor(wxGrid
* grid
, int row
, int col
) const
2034 wxGridCellEditor
*editor
;
2036 if ( m_editor
&& this != m_defGridAttr
)
2038 // use the cells editor if it has one
2042 else // no non default cell editor
2044 // get default editor for the data type
2047 // GetDefaultEditorForCell() will do IncRef() for us
2048 editor
= grid
->GetDefaultEditorForCell(row
, col
);
2057 if ( m_defGridAttr
&& this != m_defGridAttr
)
2059 // if we still don't have one then use the grid default
2060 // (no need for IncRef() here neither)
2061 editor
= m_defGridAttr
->GetEditor(NULL
, 0, 0);
2063 else // default grid attr
2065 // use m_editor which we had decided not to use initially
2073 // we're supposed to always find something
2074 wxASSERT_MSG(editor
, wxT("Missing default cell editor"));
2079 // ----------------------------------------------------------------------------
2080 // wxGridCellAttrData
2081 // ----------------------------------------------------------------------------
2083 void wxGridCellAttrData::SetAttr(wxGridCellAttr
*attr
, int row
, int col
)
2085 int n
= FindIndex(row
, col
);
2086 if ( n
== wxNOT_FOUND
)
2088 // add the attribute
2089 m_attrs
.Add(new wxGridCellWithAttr(row
, col
, attr
));
2093 // free the old attribute
2094 m_attrs
[(size_t)n
].attr
->DecRef();
2098 // change the attribute
2099 m_attrs
[(size_t)n
].attr
= attr
;
2103 // remove this attribute
2104 m_attrs
.RemoveAt((size_t)n
);
2109 wxGridCellAttr
*wxGridCellAttrData::GetAttr(int row
, int col
) const
2111 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2113 int n
= FindIndex(row
, col
);
2114 if ( n
!= wxNOT_FOUND
)
2116 attr
= m_attrs
[(size_t)n
].attr
;
2123 void wxGridCellAttrData::UpdateAttrRows( size_t pos
, int numRows
)
2125 size_t count
= m_attrs
.GetCount();
2126 for ( size_t n
= 0; n
< count
; n
++ )
2128 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2129 wxCoord row
= coords
.GetRow();
2130 if ((size_t)row
>= pos
)
2134 // If rows inserted, include row counter where necessary
2135 coords
.SetRow(row
+ numRows
);
2137 else if (numRows
< 0)
2139 // If rows deleted ...
2140 if ((size_t)row
>= pos
- numRows
)
2142 // ...either decrement row counter (if row still exists)...
2143 coords
.SetRow(row
+ numRows
);
2147 // ...or remove the attribute
2148 m_attrs
.RemoveAt((size_t)n
);
2156 void wxGridCellAttrData::UpdateAttrCols( size_t pos
, int numCols
)
2158 size_t count
= m_attrs
.GetCount();
2159 for ( size_t n
= 0; n
< count
; n
++ )
2161 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2162 wxCoord col
= coords
.GetCol();
2163 if ( (size_t)col
>= pos
)
2167 // If rows inserted, include row counter where necessary
2168 coords
.SetCol(col
+ numCols
);
2170 else if (numCols
< 0)
2172 // If rows deleted ...
2173 if ((size_t)col
>= pos
- numCols
)
2175 // ...either decrement row counter (if row still exists)...
2176 coords
.SetCol(col
+ numCols
);
2180 // ...or remove the attribute
2181 m_attrs
.RemoveAt((size_t)n
);
2189 int wxGridCellAttrData::FindIndex(int row
, int col
) const
2191 size_t count
= m_attrs
.GetCount();
2192 for ( size_t n
= 0; n
< count
; n
++ )
2194 const wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2195 if ( (coords
.GetRow() == row
) && (coords
.GetCol() == col
) )
2204 // ----------------------------------------------------------------------------
2205 // wxGridRowOrColAttrData
2206 // ----------------------------------------------------------------------------
2208 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2210 size_t count
= m_attrs
.Count();
2211 for ( size_t n
= 0; n
< count
; n
++ )
2213 m_attrs
[n
]->DecRef();
2217 wxGridCellAttr
*wxGridRowOrColAttrData::GetAttr(int rowOrCol
) const
2219 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2221 int n
= m_rowsOrCols
.Index(rowOrCol
);
2222 if ( n
!= wxNOT_FOUND
)
2224 attr
= m_attrs
[(size_t)n
];
2231 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr
*attr
, int rowOrCol
)
2233 int i
= m_rowsOrCols
.Index(rowOrCol
);
2234 if ( i
== wxNOT_FOUND
)
2236 // add the attribute
2237 m_rowsOrCols
.Add(rowOrCol
);
2242 size_t n
= (size_t)i
;
2245 // change the attribute
2246 m_attrs
[n
]->DecRef();
2251 // remove this attribute
2252 m_attrs
[n
]->DecRef();
2253 m_rowsOrCols
.RemoveAt(n
);
2254 m_attrs
.RemoveAt(n
);
2259 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
)
2261 size_t count
= m_attrs
.GetCount();
2262 for ( size_t n
= 0; n
< count
; n
++ )
2264 int & rowOrCol
= m_rowsOrCols
[n
];
2265 if ( (size_t)rowOrCol
>= pos
)
2267 if ( numRowsOrCols
> 0 )
2269 // If rows inserted, include row counter where necessary
2270 rowOrCol
+= numRowsOrCols
;
2272 else if ( numRowsOrCols
< 0)
2274 // If rows deleted, either decrement row counter (if row still exists)
2275 if ((size_t)rowOrCol
>= pos
- numRowsOrCols
)
2276 rowOrCol
+= numRowsOrCols
;
2279 m_rowsOrCols
.RemoveAt((size_t)n
);
2280 m_attrs
.RemoveAt((size_t)n
);
2288 // ----------------------------------------------------------------------------
2289 // wxGridCellAttrProvider
2290 // ----------------------------------------------------------------------------
2292 wxGridCellAttrProvider::wxGridCellAttrProvider()
2294 m_data
= (wxGridCellAttrProviderData
*)NULL
;
2297 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2302 void wxGridCellAttrProvider::InitData()
2304 m_data
= new wxGridCellAttrProviderData
;
2307 wxGridCellAttr
*wxGridCellAttrProvider::GetAttr(int row
, int col
,
2308 wxGridCellAttr::wxAttrKind kind
) const
2310 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2315 case (wxGridCellAttr::Any
):
2316 //Get cached merge attributes.
2317 // Currenlty not used as no cache implemented as not mutiable
2318 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2321 //Basicaly implement old version.
2322 //Also check merge cache, so we don't have to re-merge every time..
2323 wxGridCellAttr
*attrcell
= (wxGridCellAttr
*)NULL
,
2324 *attrrow
= (wxGridCellAttr
*)NULL
,
2325 *attrcol
= (wxGridCellAttr
*)NULL
;
2327 attrcell
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2328 attrcol
= m_data
->m_colAttrs
.GetAttr(col
);
2329 attrrow
= m_data
->m_rowAttrs
.GetAttr(row
);
2331 if((attrcell
!= attrrow
) && (attrrow
!=attrcol
) && (attrcell
!= attrcol
)){
2332 // Two or move are non NULL
2333 attr
= new wxGridCellAttr
;
2334 attr
->SetKind(wxGridCellAttr::Merged
);
2338 attr
->MergeWith(attrcell
);
2342 attr
->MergeWith(attrcol
);
2346 attr
->MergeWith(attrrow
);
2349 //store merge attr if cache implemented
2351 //m_data->m_mergeAttr.SetAttr(attr, row, col);
2355 // one or none is non null return it or null.
2356 if(attrrow
) attr
= attrrow
;
2357 if(attrcol
) attr
= attrcol
;
2358 if(attrcell
) attr
= attrcell
;
2362 case (wxGridCellAttr::Cell
):
2363 attr
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2365 case (wxGridCellAttr::Col
):
2366 attr
= m_data
->m_colAttrs
.GetAttr(col
);
2368 case (wxGridCellAttr::Row
):
2369 attr
= m_data
->m_rowAttrs
.GetAttr(row
);
2373 // (wxGridCellAttr::Default):
2374 // (wxGridCellAttr::Merged):
2381 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr
*attr
,
2387 m_data
->m_cellAttrs
.SetAttr(attr
, row
, col
);
2390 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2395 m_data
->m_rowAttrs
.SetAttr(attr
, row
);
2398 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr
*attr
, int col
)
2403 m_data
->m_colAttrs
.SetAttr(attr
, col
);
2406 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos
, int numRows
)
2410 m_data
->m_cellAttrs
.UpdateAttrRows( pos
, numRows
);
2412 m_data
->m_rowAttrs
.UpdateAttrRowsOrCols( pos
, numRows
);
2416 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos
, int numCols
)
2420 m_data
->m_cellAttrs
.UpdateAttrCols( pos
, numCols
);
2422 m_data
->m_colAttrs
.UpdateAttrRowsOrCols( pos
, numCols
);
2426 // ----------------------------------------------------------------------------
2427 // wxGridTypeRegistry
2428 // ----------------------------------------------------------------------------
2430 wxGridTypeRegistry::~wxGridTypeRegistry()
2432 size_t count
= m_typeinfo
.Count();
2433 for ( size_t i
= 0; i
< count
; i
++ )
2434 delete m_typeinfo
[i
];
2438 void wxGridTypeRegistry::RegisterDataType(const wxString
& typeName
,
2439 wxGridCellRenderer
* renderer
,
2440 wxGridCellEditor
* editor
)
2442 wxGridDataTypeInfo
* info
= new wxGridDataTypeInfo(typeName
, renderer
, editor
);
2444 // is it already registered?
2445 int loc
= FindRegisteredDataType(typeName
);
2446 if ( loc
!= wxNOT_FOUND
)
2448 delete m_typeinfo
[loc
];
2449 m_typeinfo
[loc
] = info
;
2453 m_typeinfo
.Add(info
);
2457 int wxGridTypeRegistry::FindRegisteredDataType(const wxString
& typeName
)
2459 size_t count
= m_typeinfo
.GetCount();
2460 for ( size_t i
= 0; i
< count
; i
++ )
2462 if ( typeName
== m_typeinfo
[i
]->m_typeName
)
2471 int wxGridTypeRegistry::FindDataType(const wxString
& typeName
)
2473 int index
= FindRegisteredDataType(typeName
);
2474 if ( index
== wxNOT_FOUND
)
2476 // check whether this is one of the standard ones, in which case
2477 // register it "on the fly"
2479 if ( typeName
== wxGRID_VALUE_STRING
)
2481 RegisterDataType(wxGRID_VALUE_STRING
,
2482 new wxGridCellStringRenderer
,
2483 new wxGridCellTextEditor
);
2485 #endif // wxUSE_TEXTCTRL
2487 if ( typeName
== wxGRID_VALUE_BOOL
)
2489 RegisterDataType(wxGRID_VALUE_BOOL
,
2490 new wxGridCellBoolRenderer
,
2491 new wxGridCellBoolEditor
);
2493 #endif // wxUSE_CHECKBOX
2495 if ( typeName
== wxGRID_VALUE_NUMBER
)
2497 RegisterDataType(wxGRID_VALUE_NUMBER
,
2498 new wxGridCellNumberRenderer
,
2499 new wxGridCellNumberEditor
);
2501 else if ( typeName
== wxGRID_VALUE_FLOAT
)
2503 RegisterDataType(wxGRID_VALUE_FLOAT
,
2504 new wxGridCellFloatRenderer
,
2505 new wxGridCellFloatEditor
);
2507 #endif // wxUSE_TEXTCTRL
2509 if ( typeName
== wxGRID_VALUE_CHOICE
)
2511 RegisterDataType(wxGRID_VALUE_CHOICE
,
2512 new wxGridCellStringRenderer
,
2513 new wxGridCellChoiceEditor
);
2515 #endif // wxUSE_COMBOBOX
2520 // we get here only if just added the entry for this type, so return
2522 index
= m_typeinfo
.GetCount() - 1;
2528 int wxGridTypeRegistry::FindOrCloneDataType(const wxString
& typeName
)
2530 int index
= FindDataType(typeName
);
2531 if ( index
== wxNOT_FOUND
)
2533 // the first part of the typename is the "real" type, anything after ':'
2534 // are the parameters for the renderer
2535 index
= FindDataType(typeName
.BeforeFirst(_T(':')));
2536 if ( index
== wxNOT_FOUND
)
2541 wxGridCellRenderer
*renderer
= GetRenderer(index
);
2542 wxGridCellRenderer
*rendererOld
= renderer
;
2543 renderer
= renderer
->Clone();
2544 rendererOld
->DecRef();
2546 wxGridCellEditor
*editor
= GetEditor(index
);
2547 wxGridCellEditor
*editorOld
= editor
;
2548 editor
= editor
->Clone();
2549 editorOld
->DecRef();
2551 // do it even if there are no parameters to reset them to defaults
2552 wxString params
= typeName
.AfterFirst(_T(':'));
2553 renderer
->SetParameters(params
);
2554 editor
->SetParameters(params
);
2556 // register the new typename
2557 RegisterDataType(typeName
, renderer
, editor
);
2559 // we just registered it, it's the last one
2560 index
= m_typeinfo
.GetCount() - 1;
2566 wxGridCellRenderer
* wxGridTypeRegistry::GetRenderer(int index
)
2568 wxGridCellRenderer
* renderer
= m_typeinfo
[index
]->m_renderer
;
2574 wxGridCellEditor
* wxGridTypeRegistry::GetEditor(int index
)
2576 wxGridCellEditor
* editor
= m_typeinfo
[index
]->m_editor
;
2582 // ----------------------------------------------------------------------------
2584 // ----------------------------------------------------------------------------
2586 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase
, wxObject
)
2589 wxGridTableBase::wxGridTableBase()
2591 m_view
= (wxGrid
*) NULL
;
2592 m_attrProvider
= (wxGridCellAttrProvider
*) NULL
;
2595 wxGridTableBase::~wxGridTableBase()
2597 delete m_attrProvider
;
2600 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider
*attrProvider
)
2602 delete m_attrProvider
;
2603 m_attrProvider
= attrProvider
;
2606 bool wxGridTableBase::CanHaveAttributes()
2608 if ( ! GetAttrProvider() )
2610 // use the default attr provider by default
2611 SetAttrProvider(new wxGridCellAttrProvider
);
2616 wxGridCellAttr
*wxGridTableBase::GetAttr(int row
, int col
, wxGridCellAttr::wxAttrKind kind
)
2618 if ( m_attrProvider
)
2619 return m_attrProvider
->GetAttr(row
, col
, kind
);
2621 return (wxGridCellAttr
*)NULL
;
2624 void wxGridTableBase::SetAttr(wxGridCellAttr
* attr
, int row
, int col
)
2626 if ( m_attrProvider
)
2628 attr
->SetKind(wxGridCellAttr::Cell
);
2629 m_attrProvider
->SetAttr(attr
, row
, col
);
2633 // as we take ownership of the pointer and don't store it, we must
2639 void wxGridTableBase::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2641 if ( m_attrProvider
)
2643 attr
->SetKind(wxGridCellAttr::Row
);
2644 m_attrProvider
->SetRowAttr(attr
, row
);
2648 // as we take ownership of the pointer and don't store it, we must
2654 void wxGridTableBase::SetColAttr(wxGridCellAttr
*attr
, int col
)
2656 if ( m_attrProvider
)
2658 attr
->SetKind(wxGridCellAttr::Col
);
2659 m_attrProvider
->SetColAttr(attr
, col
);
2663 // as we take ownership of the pointer and don't store it, we must
2669 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos
),
2670 size_t WXUNUSED(numRows
) )
2672 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
2677 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows
) )
2679 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
2684 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos
),
2685 size_t WXUNUSED(numRows
) )
2687 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
2692 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos
),
2693 size_t WXUNUSED(numCols
) )
2695 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
2700 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols
) )
2702 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
2707 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos
),
2708 size_t WXUNUSED(numCols
) )
2710 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
2716 wxString
wxGridTableBase::GetRowLabelValue( int row
)
2719 s
<< row
+ 1; // RD: Starting the rows at zero confuses users, no matter
2720 // how much it makes sense to us geeks.
2724 wxString
wxGridTableBase::GetColLabelValue( int col
)
2726 // default col labels are:
2727 // cols 0 to 25 : A-Z
2728 // cols 26 to 675 : AA-ZZ
2733 for ( n
= 1; ; n
++ )
2735 s
+= (_T('A') + (wxChar
)( col%26
));
2737 if ( col
< 0 ) break;
2740 // reverse the string...
2742 for ( i
= 0; i
< n
; i
++ )
2751 wxString
wxGridTableBase::GetTypeName( int WXUNUSED(row
), int WXUNUSED(col
) )
2753 return wxGRID_VALUE_STRING
;
2756 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row
), int WXUNUSED(col
),
2757 const wxString
& typeName
)
2759 return typeName
== wxGRID_VALUE_STRING
;
2762 bool wxGridTableBase::CanSetValueAs( int row
, int col
, const wxString
& typeName
)
2764 return CanGetValueAs(row
, col
, typeName
);
2767 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
) )
2772 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
) )
2777 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
) )
2782 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
),
2783 long WXUNUSED(value
) )
2787 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
),
2788 double WXUNUSED(value
) )
2792 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
),
2793 bool WXUNUSED(value
) )
2798 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
2799 const wxString
& WXUNUSED(typeName
) )
2804 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
2805 const wxString
& WXUNUSED(typeName
),
2806 void* WXUNUSED(value
) )
2810 //////////////////////////////////////////////////////////////////////
2812 // Message class for the grid table to send requests and notifications
2816 wxGridTableMessage::wxGridTableMessage()
2818 m_table
= (wxGridTableBase
*) NULL
;
2824 wxGridTableMessage::wxGridTableMessage( wxGridTableBase
*table
, int id
,
2825 int commandInt1
, int commandInt2
)
2829 m_comInt1
= commandInt1
;
2830 m_comInt2
= commandInt2
;
2835 //////////////////////////////////////////////////////////////////////
2837 // A basic grid table for string data. An object of this class will
2838 // created by wxGrid if you don't specify an alternative table class.
2841 WX_DEFINE_OBJARRAY(wxGridStringArray
)
2843 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable
, wxGridTableBase
)
2845 wxGridStringTable::wxGridStringTable()
2850 wxGridStringTable::wxGridStringTable( int numRows
, int numCols
)
2855 m_data
.Alloc( numRows
);
2858 sa
.Alloc( numCols
);
2859 for ( col
= 0; col
< numCols
; col
++ )
2861 sa
.Add( wxEmptyString
);
2864 for ( row
= 0; row
< numRows
; row
++ )
2870 wxGridStringTable::~wxGridStringTable()
2874 int wxGridStringTable::GetNumberRows()
2876 return m_data
.GetCount();
2879 int wxGridStringTable::GetNumberCols()
2881 if ( m_data
.GetCount() > 0 )
2882 return m_data
[0].GetCount();
2887 wxString
wxGridStringTable::GetValue( int row
, int col
)
2889 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
2890 _T("invalid row or column index in wxGridStringTable") );
2892 return m_data
[row
][col
];
2895 void wxGridStringTable::SetValue( int row
, int col
, const wxString
& value
)
2897 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
2898 _T("invalid row or column index in wxGridStringTable") );
2900 m_data
[row
][col
] = value
;
2903 bool wxGridStringTable::IsEmptyCell( int row
, int col
)
2905 wxASSERT_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
2906 _T("invalid row or column index in wxGridStringTable") );
2908 return (m_data
[row
][col
] == wxEmptyString
);
2911 void wxGridStringTable::Clear()
2914 int numRows
, numCols
;
2916 numRows
= m_data
.GetCount();
2919 numCols
= m_data
[0].GetCount();
2921 for ( row
= 0; row
< numRows
; row
++ )
2923 for ( col
= 0; col
< numCols
; col
++ )
2925 m_data
[row
][col
] = wxEmptyString
;
2932 bool wxGridStringTable::InsertRows( size_t pos
, size_t numRows
)
2936 size_t curNumRows
= m_data
.GetCount();
2937 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
2938 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2940 if ( pos
>= curNumRows
)
2942 return AppendRows( numRows
);
2946 sa
.Alloc( curNumCols
);
2947 for ( col
= 0; col
< curNumCols
; col
++ )
2949 sa
.Add( wxEmptyString
);
2952 for ( row
= pos
; row
< pos
+ numRows
; row
++ )
2954 m_data
.Insert( sa
, row
);
2958 wxGridTableMessage
msg( this,
2959 wxGRIDTABLE_NOTIFY_ROWS_INSERTED
,
2963 GetView()->ProcessTableMessage( msg
);
2969 bool wxGridStringTable::AppendRows( size_t numRows
)
2973 size_t curNumRows
= m_data
.GetCount();
2974 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
2975 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
2978 if ( curNumCols
> 0 )
2980 sa
.Alloc( curNumCols
);
2981 for ( col
= 0; col
< curNumCols
; col
++ )
2983 sa
.Add( wxEmptyString
);
2987 for ( row
= 0; row
< numRows
; row
++ )
2994 wxGridTableMessage
msg( this,
2995 wxGRIDTABLE_NOTIFY_ROWS_APPENDED
,
2998 GetView()->ProcessTableMessage( msg
);
3004 bool wxGridStringTable::DeleteRows( size_t pos
, size_t numRows
)
3008 size_t curNumRows
= m_data
.GetCount();
3010 if ( pos
>= curNumRows
)
3013 errmsg
.Printf(wxT("Called wxGridStringTable::DeleteRows(pos=%d, N=%d)\nPos value is invalid for present table with %d rows"),
3014 pos
, numRows
, curNumRows
);
3015 wxFAIL_MSG( errmsg
);
3019 if ( numRows
> curNumRows
- pos
)
3021 numRows
= curNumRows
- pos
;
3024 if ( numRows
>= curNumRows
)
3026 m_data
.Empty(); // don't release memory just yet
3030 for ( n
= 0; n
< numRows
; n
++ )
3032 m_data
.RemoveAt( pos
);
3037 wxGridTableMessage
msg( this,
3038 wxGRIDTABLE_NOTIFY_ROWS_DELETED
,
3042 GetView()->ProcessTableMessage( msg
);
3048 bool wxGridStringTable::InsertCols( size_t pos
, size_t numCols
)
3052 size_t curNumRows
= m_data
.GetCount();
3053 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3054 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3056 if ( pos
>= curNumCols
)
3058 return AppendCols( numCols
);
3061 for ( row
= 0; row
< curNumRows
; row
++ )
3063 for ( col
= pos
; col
< pos
+ numCols
; col
++ )
3065 m_data
[row
].Insert( wxEmptyString
, col
);
3070 wxGridTableMessage
msg( this,
3071 wxGRIDTABLE_NOTIFY_COLS_INSERTED
,
3075 GetView()->ProcessTableMessage( msg
);
3081 bool wxGridStringTable::AppendCols( size_t numCols
)
3085 size_t curNumRows
= m_data
.GetCount();
3089 // TODO: something better than this ?
3091 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3096 for ( row
= 0; row
< curNumRows
; row
++ )
3098 for ( n
= 0; n
< numCols
; n
++ )
3100 m_data
[row
].Add( wxEmptyString
);
3106 wxGridTableMessage
msg( this,
3107 wxGRIDTABLE_NOTIFY_COLS_APPENDED
,
3110 GetView()->ProcessTableMessage( msg
);
3116 bool wxGridStringTable::DeleteCols( size_t pos
, size_t numCols
)
3120 size_t curNumRows
= m_data
.GetCount();
3121 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3122 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3124 if ( pos
>= curNumCols
)
3127 errmsg
.Printf( wxT("Called wxGridStringTable::DeleteCols(pos=%d, N=%d)...\nPos value is invalid for present table with %d cols"),
3128 pos
, numCols
, curNumCols
);
3129 wxFAIL_MSG( errmsg
);
3133 if ( numCols
> curNumCols
- pos
)
3135 numCols
= curNumCols
- pos
;
3138 for ( row
= 0; row
< curNumRows
; row
++ )
3140 if ( numCols
>= curNumCols
)
3142 m_data
[row
].Clear();
3146 for ( n
= 0; n
< numCols
; n
++ )
3148 m_data
[row
].RemoveAt( pos
);
3154 wxGridTableMessage
msg( this,
3155 wxGRIDTABLE_NOTIFY_COLS_DELETED
,
3159 GetView()->ProcessTableMessage( msg
);
3165 wxString
wxGridStringTable::GetRowLabelValue( int row
)
3167 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3169 // using default label
3171 return wxGridTableBase::GetRowLabelValue( row
);
3175 return m_rowLabels
[ row
];
3179 wxString
wxGridStringTable::GetColLabelValue( int col
)
3181 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3183 // using default label
3185 return wxGridTableBase::GetColLabelValue( col
);
3189 return m_colLabels
[ col
];
3193 void wxGridStringTable::SetRowLabelValue( int row
, const wxString
& value
)
3195 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3197 int n
= m_rowLabels
.GetCount();
3199 for ( i
= n
; i
<= row
; i
++ )
3201 m_rowLabels
.Add( wxGridTableBase::GetRowLabelValue(i
) );
3205 m_rowLabels
[row
] = value
;
3208 void wxGridStringTable::SetColLabelValue( int col
, const wxString
& value
)
3210 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3212 int n
= m_colLabels
.GetCount();
3214 for ( i
= n
; i
<= col
; i
++ )
3216 m_colLabels
.Add( wxGridTableBase::GetColLabelValue(i
) );
3220 m_colLabels
[col
] = value
;
3225 //////////////////////////////////////////////////////////////////////
3226 //////////////////////////////////////////////////////////////////////
3228 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow
, wxWindow
)
3230 BEGIN_EVENT_TABLE( wxGridRowLabelWindow
, wxWindow
)
3231 EVT_PAINT( wxGridRowLabelWindow::OnPaint
)
3232 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel
)
3233 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent
)
3234 EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown
)
3235 EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp
)
3238 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid
*parent
,
3240 const wxPoint
&pos
, const wxSize
&size
)
3241 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
)
3246 void wxGridRowLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3250 // NO - don't do this because it will set both the x and y origin
3251 // coords to match the parent scrolled window and we just want to
3252 // set the y coord - MB
3254 // m_owner->PrepareDC( dc );
3257 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3258 dc
.SetDeviceOrigin( 0, -y
);
3260 wxArrayInt rows
= m_owner
->CalcRowLabelsExposed( GetUpdateRegion() );
3261 m_owner
->DrawRowLabels( dc
, rows
);
3265 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3267 m_owner
->ProcessRowLabelMouseEvent( event
);
3271 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3273 m_owner
->GetEventHandler()->ProcessEvent(event
);
3277 // This seems to be required for wxMotif otherwise the mouse
3278 // cursor must be in the cell edit control to get key events
3280 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3282 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3285 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3287 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3292 //////////////////////////////////////////////////////////////////////
3294 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow
, wxWindow
)
3296 BEGIN_EVENT_TABLE( wxGridColLabelWindow
, wxWindow
)
3297 EVT_PAINT( wxGridColLabelWindow::OnPaint
)
3298 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel
)
3299 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent
)
3300 EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown
)
3301 EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp
)
3304 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid
*parent
,
3306 const wxPoint
&pos
, const wxSize
&size
)
3307 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
)
3312 void wxGridColLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3316 // NO - don't do this because it will set both the x and y origin
3317 // coords to match the parent scrolled window and we just want to
3318 // set the x coord - MB
3320 // m_owner->PrepareDC( dc );
3323 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3324 dc
.SetDeviceOrigin( -x
, 0 );
3326 wxArrayInt cols
= m_owner
->CalcColLabelsExposed( GetUpdateRegion() );
3327 m_owner
->DrawColLabels( dc
, cols
);
3331 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3333 m_owner
->ProcessColLabelMouseEvent( event
);
3336 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3338 m_owner
->GetEventHandler()->ProcessEvent(event
);
3342 // This seems to be required for wxMotif otherwise the mouse
3343 // cursor must be in the cell edit control to get key events
3345 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3347 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3350 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3352 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3357 //////////////////////////////////////////////////////////////////////
3359 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow
, wxWindow
)
3361 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow
, wxWindow
)
3362 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel
)
3363 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent
)
3364 EVT_PAINT( wxGridCornerLabelWindow::OnPaint
)
3365 EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown
)
3366 EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp
)
3369 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid
*parent
,
3371 const wxPoint
&pos
, const wxSize
&size
)
3372 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
)
3377 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3381 int client_height
= 0;
3382 int client_width
= 0;
3383 GetClientSize( &client_width
, &client_height
);
3385 dc
.SetPen( *wxBLACK_PEN
);
3386 dc
.DrawLine( client_width
-1, client_height
-1, client_width
-1, 0 );
3387 dc
.DrawLine( client_width
-1, client_height
-1, 0, client_height
-1 );
3389 dc
.SetPen( *wxWHITE_PEN
);
3390 dc
.DrawLine( 0, 0, client_width
, 0 );
3391 dc
.DrawLine( 0, 0, 0, client_height
);
3395 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3397 m_owner
->ProcessCornerLabelMouseEvent( event
);
3401 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3403 m_owner
->GetEventHandler()->ProcessEvent(event
);
3406 // This seems to be required for wxMotif otherwise the mouse
3407 // cursor must be in the cell edit control to get key events
3409 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3411 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3414 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3416 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3421 //////////////////////////////////////////////////////////////////////
3423 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow
, wxWindow
)
3425 BEGIN_EVENT_TABLE( wxGridWindow
, wxWindow
)
3426 EVT_PAINT( wxGridWindow::OnPaint
)
3427 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel
)
3428 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent
)
3429 EVT_KEY_DOWN( wxGridWindow::OnKeyDown
)
3430 EVT_KEY_UP( wxGridWindow::OnKeyUp
)
3431 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground
)
3434 wxGridWindow::wxGridWindow( wxGrid
*parent
,
3435 wxGridRowLabelWindow
*rowLblWin
,
3436 wxGridColLabelWindow
*colLblWin
,
3437 wxWindowID id
, const wxPoint
&pos
, const wxSize
&size
)
3438 : wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
, "grid window" )
3441 m_rowLabelWin
= rowLblWin
;
3442 m_colLabelWin
= colLblWin
;
3443 SetBackgroundColour(_T("WHITE"));
3447 wxGridWindow::~wxGridWindow()
3452 void wxGridWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
3454 wxPaintDC
dc( this );
3455 m_owner
->PrepareDC( dc
);
3456 wxRegion reg
= GetUpdateRegion();
3457 wxGridCellCoordsArray DirtyCells
= m_owner
->CalcCellsExposed( reg
);
3458 m_owner
->DrawGridCellArea( dc
, DirtyCells
);
3459 #if WXGRID_DRAW_LINES
3460 m_owner
->DrawAllGridLines( dc
, reg
);
3462 m_owner
->DrawGridSpace( dc
);
3463 m_owner
->DrawHighlight( dc
, DirtyCells
);
3467 void wxGridWindow::ScrollWindow( int dx
, int dy
, const wxRect
*rect
)
3469 wxWindow::ScrollWindow( dx
, dy
, rect
);
3470 m_rowLabelWin
->ScrollWindow( 0, dy
, rect
);
3471 m_colLabelWin
->ScrollWindow( dx
, 0, rect
);
3475 void wxGridWindow::OnMouseEvent( wxMouseEvent
& event
)
3477 m_owner
->ProcessGridCellMouseEvent( event
);
3480 void wxGridWindow::OnMouseWheel( wxMouseEvent
& event
)
3482 m_owner
->GetEventHandler()->ProcessEvent(event
);
3485 // This seems to be required for wxMotif/wxGTK otherwise the mouse
3486 // cursor must be in the cell edit control to get key events
3488 void wxGridWindow::OnKeyDown( wxKeyEvent
& event
)
3490 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3493 void wxGridWindow::OnKeyUp( wxKeyEvent
& event
)
3495 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) ) event
.Skip();
3498 void wxGridWindow::OnEraseBackground( wxEraseEvent
& WXUNUSED(event
) )
3503 //////////////////////////////////////////////////////////////////////
3505 // Internal Helper function for computing row or column from some
3506 // (unscrolled) coordinate value, using either
3507 // m_defaultRowHeight/m_defaultColWidth or binary search on array
3508 // of m_rowBottoms/m_ColRights to speed up the search!
3510 // Internal helper macros for simpler use of that function
3512 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
3513 const wxArrayInt
& BorderArray
, bool maxOnOverflow
);
3515 #define internalXToCol(x) CoordToRowOrCol(x, m_defaultColWidth, \
3516 WXGRID_MIN_COL_WIDTH, \
3518 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
3519 WXGRID_MIN_ROW_HEIGHT, \
3521 /////////////////////////////////////////////////////////////////////
3523 IMPLEMENT_DYNAMIC_CLASS( wxGrid
, wxScrolledWindow
)
3525 BEGIN_EVENT_TABLE( wxGrid
, wxScrolledWindow
)
3526 EVT_PAINT( wxGrid::OnPaint
)
3527 EVT_SIZE( wxGrid::OnSize
)
3528 EVT_KEY_DOWN( wxGrid::OnKeyDown
)
3529 EVT_KEY_UP( wxGrid::OnKeyUp
)
3530 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground
)
3533 wxGrid::wxGrid( wxWindow
*parent
,
3538 const wxString
& name
)
3539 : wxScrolledWindow( parent
, id
, pos
, size
, (style
| wxWANTS_CHARS
), name
),
3540 m_colMinWidths(GRID_HASH_SIZE
),
3541 m_rowMinHeights(GRID_HASH_SIZE
)
3549 // Must do this or ~wxScrollHelper will pop the wrong event handler
3550 SetTargetWindow(this);
3552 wxSafeDecRef(m_defaultCellAttr
);
3554 #ifdef DEBUG_ATTR_CACHE
3555 size_t total
= gs_nAttrCacheHits
+ gs_nAttrCacheMisses
;
3556 wxPrintf(_T("wxGrid attribute cache statistics: "
3557 "total: %u, hits: %u (%u%%)\n"),
3558 total
, gs_nAttrCacheHits
,
3559 total
? (gs_nAttrCacheHits
*100) / total
: 0);
3565 delete m_typeRegistry
;
3571 // ----- internal init and update functions
3574 void wxGrid::Create()
3576 m_created
= FALSE
; // set to TRUE by CreateGrid
3578 m_table
= (wxGridTableBase
*) NULL
;
3581 m_cellEditCtrlEnabled
= FALSE
;
3583 m_defaultCellAttr
= new wxGridCellAttr();
3585 // Set default cell attributes
3586 m_defaultCellAttr
->SetDefAttr(m_defaultCellAttr
);
3587 m_defaultCellAttr
->SetKind(wxGridCellAttr::Default
);
3588 m_defaultCellAttr
->SetFont(GetFont());
3589 m_defaultCellAttr
->SetAlignment(wxALIGN_LEFT
, wxALIGN_TOP
);
3590 m_defaultCellAttr
->SetTextColour(
3591 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
3592 m_defaultCellAttr
->SetBackgroundColour(
3593 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
3594 m_defaultCellAttr
->SetRenderer(new wxGridCellStringRenderer
);
3595 m_defaultCellAttr
->SetEditor(new wxGridCellTextEditor
);
3600 m_currentCellCoords
= wxGridNoCellCoords
;
3602 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
3603 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
3605 // create the type registry
3606 m_typeRegistry
= new wxGridTypeRegistry
;
3608 // subwindow components that make up the wxGrid
3609 m_cornerLabelWin
= new wxGridCornerLabelWindow( this,
3614 m_rowLabelWin
= new wxGridRowLabelWindow( this,
3619 m_colLabelWin
= new wxGridColLabelWindow( this,
3624 m_gridWin
= new wxGridWindow( this,
3631 SetTargetWindow( m_gridWin
);
3637 bool wxGrid::CreateGrid( int numRows
, int numCols
,
3638 wxGrid::wxGridSelectionModes selmode
)
3640 wxCHECK_MSG( !m_created
,
3642 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3644 m_numRows
= numRows
;
3645 m_numCols
= numCols
;
3647 m_table
= new wxGridStringTable( m_numRows
, m_numCols
);
3648 m_table
->SetView( this );
3650 m_selection
= new wxGridSelection( this, selmode
);
3659 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode
)
3661 wxCHECK_RET( m_created
,
3662 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
3664 m_selection
->SetSelectionMode( selmode
);
3667 bool wxGrid::SetTable( wxGridTableBase
*table
, bool takeOwnership
,
3668 wxGrid::wxGridSelectionModes selmode
)
3672 // RD: Actually, this should probably be allowed. I think it would be
3673 // nice to be able to switch multiple Tables in and out of a single
3674 // View at runtime. Is there anything in the implmentation that would
3677 // At least, you now have to cope with m_selection
3678 wxFAIL_MSG( wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
3683 m_numRows
= table
->GetNumberRows();
3684 m_numCols
= table
->GetNumberCols();
3687 m_table
->SetView( this );
3690 m_selection
= new wxGridSelection( this, selmode
);
3703 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
3704 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
3706 if ( m_rowLabelWin
)
3708 m_labelBackgroundColour
= m_rowLabelWin
->GetBackgroundColour();
3712 m_labelBackgroundColour
= wxColour( _T("WHITE") );
3715 m_labelTextColour
= wxColour( _T("BLACK") );
3718 m_attrCache
.row
= -1;
3720 // TODO: something better than this ?
3722 m_labelFont
= this->GetFont();
3723 m_labelFont
.SetWeight( m_labelFont
.GetWeight() + 2 );
3725 m_rowLabelHorizAlign
= wxALIGN_LEFT
;
3726 m_rowLabelVertAlign
= wxALIGN_CENTRE
;
3728 m_colLabelHorizAlign
= wxALIGN_CENTRE
;
3729 m_colLabelVertAlign
= wxALIGN_TOP
;
3731 m_defaultColWidth
= WXGRID_DEFAULT_COL_WIDTH
;
3732 m_defaultRowHeight
= m_gridWin
->GetCharHeight();
3734 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
3735 m_defaultRowHeight
+= 8;
3737 m_defaultRowHeight
+= 4;
3740 m_gridLineColour
= wxColour( 128, 128, 255 );
3741 m_gridLinesEnabled
= TRUE
;
3742 m_cellHighlightColour
= m_gridLineColour
;
3743 m_cellHighlightPenWidth
= 2;
3744 m_cellHighlightROPenWidth
= 1;
3746 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
3747 m_winCapture
= (wxWindow
*)NULL
;
3748 m_canDragRowSize
= TRUE
;
3749 m_canDragColSize
= TRUE
;
3750 m_canDragGridSize
= TRUE
;
3752 m_dragRowOrCol
= -1;
3753 m_isDragging
= FALSE
;
3754 m_startDragPos
= wxDefaultPosition
;
3756 m_waitForSlowClick
= FALSE
;
3758 m_rowResizeCursor
= wxCursor( wxCURSOR_SIZENS
);
3759 m_colResizeCursor
= wxCursor( wxCURSOR_SIZEWE
);
3761 m_currentCellCoords
= wxGridNoCellCoords
;
3763 m_selectingTopLeft
= wxGridNoCellCoords
;
3764 m_selectingBottomRight
= wxGridNoCellCoords
;
3765 m_selectionBackground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
3766 m_selectionForeground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
3768 m_editable
= TRUE
; // default for whole grid
3770 m_inOnKeyDown
= FALSE
;
3777 // ----------------------------------------------------------------------------
3778 // the idea is to call these functions only when necessary because they create
3779 // quite big arrays which eat memory mostly unnecessary - in particular, if
3780 // default widths/heights are used for all rows/columns, we may not use these
3783 // with some extra code, it should be possible to only store the
3784 // widths/heights different from default ones but this will be done later...
3785 // ----------------------------------------------------------------------------
3787 void wxGrid::InitRowHeights()
3789 m_rowHeights
.Empty();
3790 m_rowBottoms
.Empty();
3792 m_rowHeights
.Alloc( m_numRows
);
3793 m_rowBottoms
.Alloc( m_numRows
);
3796 for ( int i
= 0; i
< m_numRows
; i
++ )
3798 m_rowHeights
.Add( m_defaultRowHeight
);
3799 rowBottom
+= m_defaultRowHeight
;
3800 m_rowBottoms
.Add( rowBottom
);
3804 void wxGrid::InitColWidths()
3806 m_colWidths
.Empty();
3807 m_colRights
.Empty();
3809 m_colWidths
.Alloc( m_numCols
);
3810 m_colRights
.Alloc( m_numCols
);
3812 for ( int i
= 0; i
< m_numCols
; i
++ )
3814 m_colWidths
.Add( m_defaultColWidth
);
3815 colRight
+= m_defaultColWidth
;
3816 m_colRights
.Add( colRight
);
3820 int wxGrid::GetColWidth(int col
) const
3822 return m_colWidths
.IsEmpty() ? m_defaultColWidth
: m_colWidths
[col
];
3825 int wxGrid::GetColLeft(int col
) const
3827 return m_colRights
.IsEmpty() ? col
* m_defaultColWidth
3828 : m_colRights
[col
] - m_colWidths
[col
];
3831 int wxGrid::GetColRight(int col
) const
3833 return m_colRights
.IsEmpty() ? (col
+ 1) * m_defaultColWidth
3837 int wxGrid::GetRowHeight(int row
) const
3839 return m_rowHeights
.IsEmpty() ? m_defaultRowHeight
: m_rowHeights
[row
];
3842 int wxGrid::GetRowTop(int row
) const
3844 return m_rowBottoms
.IsEmpty() ? row
* m_defaultRowHeight
3845 : m_rowBottoms
[row
] - m_rowHeights
[row
];
3848 int wxGrid::GetRowBottom(int row
) const
3850 return m_rowBottoms
.IsEmpty() ? (row
+ 1) * m_defaultRowHeight
3851 : m_rowBottoms
[row
];
3854 void wxGrid::CalcDimensions()
3857 GetClientSize( &cw
, &ch
);
3859 if ( m_rowLabelWin
->IsShown() )
3860 cw
-= m_rowLabelWidth
;
3861 if ( m_colLabelWin
->IsShown() )
3862 ch
-= m_colLabelHeight
;
3865 int w
= m_numCols
> 0 ? GetColRight(m_numCols
- 1) + m_extraWidth
+ 1 : 0;
3866 int h
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) + m_extraHeight
+ 1 : 0;
3868 // preserve (more or less) the previous position
3870 GetViewStart( &x
, &y
);
3872 // maybe we don't need scrollbars at all?
3874 // also adjust the position to be valid for the new scroll rangs
3895 // do set scrollbar parameters
3896 SetScrollbars( GRID_SCROLL_LINE_X
, GRID_SCROLL_LINE_Y
,
3897 GetScrollX(w
), GetScrollY(h
), x
, y
,
3898 GetBatchCount() != 0);
3900 // if our OnSize() hadn't been called (it would if we have scrollbars), we
3901 // still must reposition the children
3906 void wxGrid::CalcWindowSizes()
3909 GetClientSize( &cw
, &ch
);
3911 if ( m_cornerLabelWin
->IsShown() )
3912 m_cornerLabelWin
->SetSize( 0, 0, m_rowLabelWidth
, m_colLabelHeight
);
3914 if ( m_colLabelWin
->IsShown() )
3915 m_colLabelWin
->SetSize( m_rowLabelWidth
, 0, cw
-m_rowLabelWidth
, m_colLabelHeight
);
3917 if ( m_rowLabelWin
->IsShown() )
3918 m_rowLabelWin
->SetSize( 0, m_colLabelHeight
, m_rowLabelWidth
, ch
-m_colLabelHeight
);
3920 if ( m_gridWin
->IsShown() )
3921 m_gridWin
->SetSize( m_rowLabelWidth
, m_colLabelHeight
, cw
-m_rowLabelWidth
, ch
-m_colLabelHeight
);
3925 // this is called when the grid table sends a message to say that it
3926 // has been redimensioned
3928 bool wxGrid::Redimension( wxGridTableMessage
& msg
)
3931 bool result
= FALSE
;
3934 // if we were using the default widths/heights so far, we must change them
3936 if ( m_colWidths
.IsEmpty() )
3941 if ( m_rowHeights
.IsEmpty() )
3947 switch ( msg
.GetId() )
3949 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
3951 size_t pos
= msg
.GetCommandInt();
3952 int numRows
= msg
.GetCommandInt2();
3954 m_numRows
+= numRows
;
3956 if ( !m_rowHeights
.IsEmpty() )
3958 for ( i
= 0; i
< numRows
; i
++ )
3960 m_rowHeights
.Insert( m_defaultRowHeight
, pos
);
3961 m_rowBottoms
.Insert( 0, pos
);
3965 if ( pos
> 0 ) bottom
= m_rowBottoms
[pos
-1];
3967 for ( i
= pos
; i
< m_numRows
; i
++ )
3969 bottom
+= m_rowHeights
[i
];
3970 m_rowBottoms
[i
] = bottom
;
3973 if ( m_currentCellCoords
== wxGridNoCellCoords
)
3975 // if we have just inserted cols into an empty grid the current
3976 // cell will be undefined...
3978 SetCurrentCell( 0, 0 );
3980 m_selection
->UpdateRows( pos
, numRows
);
3981 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
3983 attrProvider
->UpdateAttrRows( pos
, numRows
);
3985 if ( !GetBatchCount() )
3988 m_rowLabelWin
->Refresh();
3994 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
3996 int numRows
= msg
.GetCommandInt();
3997 int oldNumRows
= m_numRows
;
3998 m_numRows
+= numRows
;
4000 if ( !m_rowHeights
.IsEmpty() )
4002 for ( i
= 0; i
< numRows
; i
++ )
4004 m_rowHeights
.Add( m_defaultRowHeight
);
4005 m_rowBottoms
.Add( 0 );
4009 if ( oldNumRows
> 0 ) bottom
= m_rowBottoms
[oldNumRows
-1];
4011 for ( i
= oldNumRows
; i
< m_numRows
; i
++ )
4013 bottom
+= m_rowHeights
[i
];
4014 m_rowBottoms
[i
] = bottom
;
4017 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4019 // if we have just inserted cols into an empty grid the current
4020 // cell will be undefined...
4022 SetCurrentCell( 0, 0 );
4024 if ( !GetBatchCount() )
4027 m_rowLabelWin
->Refresh();
4033 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
4035 size_t pos
= msg
.GetCommandInt();
4036 int numRows
= msg
.GetCommandInt2();
4037 m_numRows
-= numRows
;
4039 if ( !m_rowHeights
.IsEmpty() )
4041 for ( i
= 0; i
< numRows
; i
++ )
4043 m_rowHeights
.RemoveAt( pos
);
4044 m_rowBottoms
.RemoveAt( pos
);
4048 for ( i
= 0; i
< m_numRows
; i
++ )
4050 h
+= m_rowHeights
[i
];
4051 m_rowBottoms
[i
] = h
;
4056 m_currentCellCoords
= wxGridNoCellCoords
;
4060 if ( m_currentCellCoords
.GetRow() >= m_numRows
)
4061 m_currentCellCoords
.Set( 0, 0 );
4063 m_selection
->UpdateRows( pos
, -((int)numRows
) );
4064 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4066 attrProvider
->UpdateAttrRows( pos
, -((int)numRows
) );
4067 // ifdef'd out following patch from Paul Gammans
4069 // No need to touch column attributes, unless we
4070 // removed _all_ rows, in this case, we remove
4071 // all column attributes.
4072 // I hate to do this here, but the
4073 // needed data is not available inside UpdateAttrRows.
4074 if ( !GetNumberRows() )
4075 attrProvider
->UpdateAttrCols( 0, -GetNumberCols() );
4078 if ( !GetBatchCount() )
4081 m_rowLabelWin
->Refresh();
4087 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
4089 size_t pos
= msg
.GetCommandInt();
4090 int numCols
= msg
.GetCommandInt2();
4091 m_numCols
+= numCols
;
4093 if ( !m_colWidths
.IsEmpty() )
4095 for ( i
= 0; i
< numCols
; i
++ )
4097 m_colWidths
.Insert( m_defaultColWidth
, pos
);
4098 m_colRights
.Insert( 0, pos
);
4102 if ( pos
> 0 ) right
= m_colRights
[pos
-1];
4104 for ( i
= pos
; i
< m_numCols
; i
++ )
4106 right
+= m_colWidths
[i
];
4107 m_colRights
[i
] = right
;
4110 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4112 // if we have just inserted cols into an empty grid the current
4113 // cell will be undefined...
4115 SetCurrentCell( 0, 0 );
4117 m_selection
->UpdateCols( pos
, numCols
);
4118 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4120 attrProvider
->UpdateAttrCols( pos
, numCols
);
4121 if ( !GetBatchCount() )
4124 m_colLabelWin
->Refresh();
4131 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
4133 int numCols
= msg
.GetCommandInt();
4134 int oldNumCols
= m_numCols
;
4135 m_numCols
+= numCols
;
4136 if ( !m_colWidths
.IsEmpty() )
4138 for ( i
= 0; i
< numCols
; i
++ )
4140 m_colWidths
.Add( m_defaultColWidth
);
4141 m_colRights
.Add( 0 );
4145 if ( oldNumCols
> 0 ) right
= m_colRights
[oldNumCols
-1];
4147 for ( i
= oldNumCols
; i
< m_numCols
; i
++ )
4149 right
+= m_colWidths
[i
];
4150 m_colRights
[i
] = right
;
4153 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4155 // if we have just inserted cols into an empty grid the current
4156 // cell will be undefined...
4158 SetCurrentCell( 0, 0 );
4160 if ( !GetBatchCount() )
4163 m_colLabelWin
->Refresh();
4169 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
4171 size_t pos
= msg
.GetCommandInt();
4172 int numCols
= msg
.GetCommandInt2();
4173 m_numCols
-= numCols
;
4175 if ( !m_colWidths
.IsEmpty() )
4177 for ( i
= 0; i
< numCols
; i
++ )
4179 m_colWidths
.RemoveAt( pos
);
4180 m_colRights
.RemoveAt( pos
);
4184 for ( i
= 0; i
< m_numCols
; i
++ )
4186 w
+= m_colWidths
[i
];
4192 m_currentCellCoords
= wxGridNoCellCoords
;
4196 if ( m_currentCellCoords
.GetCol() >= m_numCols
)
4197 m_currentCellCoords
.Set( 0, 0 );
4199 m_selection
->UpdateCols( pos
, -((int)numCols
) );
4200 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4202 attrProvider
->UpdateAttrCols( pos
, -((int)numCols
) );
4203 // ifdef'd out following patch from Paul Gammans
4205 // No need to touch row attributes, unless we
4206 // removed _all_ columns, in this case, we remove
4207 // all row attributes.
4208 // I hate to do this here, but the
4209 // needed data is not available inside UpdateAttrCols.
4210 if ( !GetNumberCols() )
4211 attrProvider
->UpdateAttrRows( 0, -GetNumberRows() );
4214 if ( !GetBatchCount() )
4217 m_colLabelWin
->Refresh();
4224 if (result
&& !GetBatchCount() )
4225 m_gridWin
->Refresh();
4230 wxArrayInt
wxGrid::CalcRowLabelsExposed( const wxRegion
& reg
)
4232 wxRegionIterator
iter( reg
);
4235 wxArrayInt rowlabels
;
4242 // TODO: remove this when we can...
4243 // There is a bug in wxMotif that gives garbage update
4244 // rectangles if you jump-scroll a long way by clicking the
4245 // scrollbar with middle button. This is a work-around
4247 #if defined(__WXMOTIF__)
4249 m_gridWin
->GetClientSize( &cw
, &ch
);
4250 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
4251 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
4254 // logical bounds of update region
4257 CalcUnscrolledPosition( 0, r
.GetTop(), &dummy
, &top
);
4258 CalcUnscrolledPosition( 0, r
.GetBottom(), &dummy
, &bottom
);
4260 // find the row labels within these bounds
4263 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
4265 if ( GetRowBottom(row
) < top
)
4268 if ( GetRowTop(row
) > bottom
)
4271 rowlabels
.Add( row
);
4281 wxArrayInt
wxGrid::CalcColLabelsExposed( const wxRegion
& reg
)
4283 wxRegionIterator
iter( reg
);
4286 wxArrayInt colLabels
;
4293 // TODO: remove this when we can...
4294 // There is a bug in wxMotif that gives garbage update
4295 // rectangles if you jump-scroll a long way by clicking the
4296 // scrollbar with middle button. This is a work-around
4298 #if defined(__WXMOTIF__)
4300 m_gridWin
->GetClientSize( &cw
, &ch
);
4301 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
4302 r
.SetRight( wxMin( r
.GetRight(), cw
) );
4305 // logical bounds of update region
4308 CalcUnscrolledPosition( r
.GetLeft(), 0, &left
, &dummy
);
4309 CalcUnscrolledPosition( r
.GetRight(), 0, &right
, &dummy
);
4311 // find the cells within these bounds
4314 for ( col
= internalXToCol(left
); col
< m_numCols
; col
++ )
4316 if ( GetColRight(col
) < left
)
4319 if ( GetColLeft(col
) > right
)
4322 colLabels
.Add( col
);
4331 wxGridCellCoordsArray
wxGrid::CalcCellsExposed( const wxRegion
& reg
)
4333 wxRegionIterator
iter( reg
);
4336 wxGridCellCoordsArray cellsExposed
;
4338 int left
, top
, right
, bottom
;
4343 // TODO: remove this when we can...
4344 // There is a bug in wxMotif that gives garbage update
4345 // rectangles if you jump-scroll a long way by clicking the
4346 // scrollbar with middle button. This is a work-around
4348 #if defined(__WXMOTIF__)
4350 m_gridWin
->GetClientSize( &cw
, &ch
);
4351 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
4352 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
4353 r
.SetRight( wxMin( r
.GetRight(), cw
) );
4354 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
4357 // logical bounds of update region
4359 CalcUnscrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
4360 CalcUnscrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
4362 // find the cells within these bounds
4365 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
4367 if ( GetRowBottom(row
) <= top
)
4370 if ( GetRowTop(row
) > bottom
)
4373 for ( col
= internalXToCol(left
); col
< m_numCols
; col
++ )
4375 if ( GetColRight(col
) <= left
)
4378 if ( GetColLeft(col
) > right
)
4381 cellsExposed
.Add( wxGridCellCoords( row
, col
) );
4388 return cellsExposed
;
4392 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent
& event
)
4395 wxPoint
pos( event
.GetPosition() );
4396 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
4398 if ( event
.Dragging() )
4400 m_isDragging
= TRUE
;
4402 if ( event
.LeftIsDown() )
4404 switch( m_cursorMode
)
4406 case WXGRID_CURSOR_RESIZE_ROW
:
4408 int cw
, ch
, left
, dummy
;
4409 m_gridWin
->GetClientSize( &cw
, &ch
);
4410 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
4412 wxClientDC
dc( m_gridWin
);
4415 GetRowTop(m_dragRowOrCol
) +
4416 GetRowMinimalHeight(m_dragRowOrCol
) );
4417 dc
.SetLogicalFunction(wxINVERT
);
4418 if ( m_dragLastPos
>= 0 )
4420 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
4422 dc
.DrawLine( left
, y
, left
+cw
, y
);
4427 case WXGRID_CURSOR_SELECT_ROW
:
4428 if ( (row
= YToRow( y
)) >= 0 )
4430 m_selection
->SelectRow( row
,
4431 event
.ControlDown(),
4437 // default label to suppress warnings about "enumeration value
4438 // 'xxx' not handled in switch
4446 m_isDragging
= FALSE
;
4449 // ------------ Entering or leaving the window
4451 if ( event
.Entering() || event
.Leaving() )
4453 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
4457 // ------------ Left button pressed
4459 else if ( event
.LeftDown() )
4461 // don't send a label click event for a hit on the
4462 // edge of the row label - this is probably the user
4463 // wanting to resize the row
4465 if ( YToEdgeOfRow(y
) < 0 )
4469 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, row
, -1, event
) )
4471 if ( !event
.ShiftDown() && !event
.ControlDown() )
4473 if ( event
.ShiftDown() )
4474 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
4477 GetNumberCols() - 1,
4478 event
.ControlDown(),
4483 m_selection
->SelectRow( row
,
4484 event
.ControlDown(),
4488 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW
, m_rowLabelWin
);
4493 // starting to drag-resize a row
4495 if ( CanDragRowSize() )
4496 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
);
4501 // ------------ Left double click
4503 else if (event
.LeftDClick() )
4505 if ( YToEdgeOfRow(y
) < 0 )
4508 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, row
, -1, event
);
4513 // ------------ Left button released
4515 else if ( event
.LeftUp() )
4517 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
4519 DoEndDragResizeRow();
4521 // Note: we are ending the event *after* doing
4522 // default processing in this case
4524 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
4527 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
4532 // ------------ Right button down
4534 else if ( event
.RightDown() )
4537 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, row
, -1, event
) )
4539 // no default action at the moment
4544 // ------------ Right double click
4546 else if ( event
.RightDClick() )
4549 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, row
, -1, event
) )
4551 // no default action at the moment
4556 // ------------ No buttons down and mouse moving
4558 else if ( event
.Moving() )
4560 m_dragRowOrCol
= YToEdgeOfRow( y
);
4561 if ( m_dragRowOrCol
>= 0 )
4563 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4565 // don't capture the mouse yet
4566 if ( CanDragRowSize() )
4567 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
, FALSE
);
4570 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
4572 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
, FALSE
);
4578 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent
& event
)
4581 wxPoint
pos( event
.GetPosition() );
4582 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
4584 if ( event
.Dragging() )
4588 m_isDragging
= TRUE
;
4589 m_colLabelWin
->CaptureMouse();
4592 if ( event
.LeftIsDown() )
4594 switch( m_cursorMode
)
4596 case WXGRID_CURSOR_RESIZE_COL
:
4598 int cw
, ch
, dummy
, top
;
4599 m_gridWin
->GetClientSize( &cw
, &ch
);
4600 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
4602 wxClientDC
dc( m_gridWin
);
4605 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
4606 GetColMinimalWidth(m_dragRowOrCol
));
4607 dc
.SetLogicalFunction(wxINVERT
);
4608 if ( m_dragLastPos
>= 0 )
4610 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
4612 dc
.DrawLine( x
, top
, x
, top
+ch
);
4617 case WXGRID_CURSOR_SELECT_COL
:
4618 if ( (col
= XToCol( x
)) >= 0 )
4620 m_selection
->SelectCol( col
,
4621 event
.ControlDown(),
4627 // default label to suppress warnings about "enumeration value
4628 // 'xxx' not handled in switch
4636 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
4641 m_colLabelWin
->ReleaseMouse();
4642 m_isDragging
= FALSE
;
4645 // ------------ Entering or leaving the window
4647 if ( event
.Entering() || event
.Leaving() )
4649 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
4653 // ------------ Left button pressed
4655 else if ( event
.LeftDown() )
4657 // don't send a label click event for a hit on the
4658 // edge of the col label - this is probably the user
4659 // wanting to resize the col
4661 if ( XToEdgeOfCol(x
) < 0 )
4665 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, col
, event
) )
4667 if ( !event
.ShiftDown() && !event
.ControlDown() )
4669 if ( event
.ShiftDown() )
4670 m_selection
->SelectBlock( 0,
4671 m_currentCellCoords
.GetCol(),
4672 GetNumberRows() - 1, col
,
4673 event
.ControlDown(),
4678 m_selection
->SelectCol( col
,
4679 event
.ControlDown(),
4683 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL
, m_colLabelWin
);
4688 // starting to drag-resize a col
4690 if ( CanDragColSize() )
4691 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
);
4696 // ------------ Left double click
4698 if ( event
.LeftDClick() )
4700 if ( XToEdgeOfCol(x
) < 0 )
4703 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, col
, event
);
4708 // ------------ Left button released
4710 else if ( event
.LeftUp() )
4712 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
4714 DoEndDragResizeCol();
4716 // Note: we are ending the event *after* doing
4717 // default processing in this case
4719 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
4722 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
4727 // ------------ Right button down
4729 else if ( event
.RightDown() )
4732 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, col
, event
) )
4734 // no default action at the moment
4739 // ------------ Right double click
4741 else if ( event
.RightDClick() )
4744 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, col
, event
) )
4746 // no default action at the moment
4751 // ------------ No buttons down and mouse moving
4753 else if ( event
.Moving() )
4755 m_dragRowOrCol
= XToEdgeOfCol( x
);
4756 if ( m_dragRowOrCol
>= 0 )
4758 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4760 // don't capture the cursor yet
4761 if ( CanDragColSize() )
4762 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
, FALSE
);
4765 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
4767 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
, FALSE
);
4773 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent
& event
)
4775 if ( event
.LeftDown() )
4777 // indicate corner label by having both row and
4780 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, -1, event
) )
4786 else if ( event
.LeftDClick() )
4788 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, -1, event
);
4791 else if ( event
.RightDown() )
4793 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, -1, event
) )
4795 // no default action at the moment
4799 else if ( event
.RightDClick() )
4801 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, -1, event
) )
4803 // no default action at the moment
4808 void wxGrid::ChangeCursorMode(CursorMode mode
,
4813 static const wxChar
*cursorModes
[] =
4822 wxLogTrace(_T("grid"),
4823 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
4824 win
== m_colLabelWin
? _T("colLabelWin")
4825 : win
? _T("rowLabelWin")
4827 cursorModes
[m_cursorMode
], cursorModes
[mode
]);
4828 #endif // __WXDEBUG__
4830 if ( mode
== m_cursorMode
&&
4831 win
== m_winCapture
&&
4832 captureMouse
== (m_winCapture
!= NULL
))
4837 // by default use the grid itself
4843 m_winCapture
->ReleaseMouse();
4844 m_winCapture
= (wxWindow
*)NULL
;
4847 m_cursorMode
= mode
;
4849 switch ( m_cursorMode
)
4851 case WXGRID_CURSOR_RESIZE_ROW
:
4852 win
->SetCursor( m_rowResizeCursor
);
4855 case WXGRID_CURSOR_RESIZE_COL
:
4856 win
->SetCursor( m_colResizeCursor
);
4860 win
->SetCursor( *wxSTANDARD_CURSOR
);
4863 // we need to capture mouse when resizing
4864 bool resize
= m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
||
4865 m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
;
4867 if ( captureMouse
&& resize
)
4869 win
->CaptureMouse();
4874 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent
& event
)
4877 wxPoint
pos( event
.GetPosition() );
4878 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
4880 wxGridCellCoords coords
;
4881 XYToCell( x
, y
, coords
);
4883 if ( event
.Dragging() )
4885 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
4887 // Don't start doing anything until the mouse has been drug at
4888 // least 3 pixels in any direction...
4891 if (m_startDragPos
== wxDefaultPosition
)
4893 m_startDragPos
= pos
;
4896 if (abs(m_startDragPos
.x
- pos
.x
) < 4 && abs(m_startDragPos
.y
- pos
.y
) < 4)
4900 m_isDragging
= TRUE
;
4901 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4903 // Hide the edit control, so it
4904 // won't interfer with drag-shrinking.
4905 if ( IsCellEditControlShown() )
4907 HideCellEditControl();
4908 SaveEditControlValue();
4911 // Have we captured the mouse yet?
4914 m_winCapture
= m_gridWin
;
4915 m_winCapture
->CaptureMouse();
4918 if ( coords
!= wxGridNoCellCoords
)
4920 if ( event
.ControlDown() )
4922 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
4923 m_selectingKeyboard
= coords
;
4924 HighlightBlock ( m_selectingKeyboard
, coords
);
4928 if ( !IsSelection() )
4930 HighlightBlock( coords
, coords
);
4934 HighlightBlock( m_currentCellCoords
, coords
);
4938 if (! IsVisible(coords
))
4940 MakeCellVisible(coords
);
4941 // TODO: need to introduce a delay or something here. The
4942 // scrolling is way to fast, at least on MSW - also on GTK.
4946 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
4948 int cw
, ch
, left
, dummy
;
4949 m_gridWin
->GetClientSize( &cw
, &ch
);
4950 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
4952 wxClientDC
dc( m_gridWin
);
4954 y
= wxMax( y
, GetRowTop(m_dragRowOrCol
) +
4955 GetRowMinimalHeight(m_dragRowOrCol
) );
4956 dc
.SetLogicalFunction(wxINVERT
);
4957 if ( m_dragLastPos
>= 0 )
4959 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
4961 dc
.DrawLine( left
, y
, left
+cw
, y
);
4964 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
4966 int cw
, ch
, dummy
, top
;
4967 m_gridWin
->GetClientSize( &cw
, &ch
);
4968 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
4970 wxClientDC
dc( m_gridWin
);
4972 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
4973 GetColMinimalWidth(m_dragRowOrCol
) );
4974 dc
.SetLogicalFunction(wxINVERT
);
4975 if ( m_dragLastPos
>= 0 )
4977 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
4979 dc
.DrawLine( x
, top
, x
, top
+ch
);
4986 m_isDragging
= FALSE
;
4987 m_startDragPos
= wxDefaultPosition
;
4989 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
4990 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
4993 if ( event
.Entering() || event
.Leaving() )
4995 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
4996 m_gridWin
->SetCursor( *wxSTANDARD_CURSOR
);
5001 // ------------ Left button pressed
5003 if ( event
.LeftDown() && coords
!= wxGridNoCellCoords
)
5005 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK
,
5010 if ( !event
.ControlDown() )
5012 if ( event
.ShiftDown() )
5014 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
5015 m_currentCellCoords
.GetCol(),
5018 event
.ControlDown(),
5023 else if ( XToEdgeOfCol(x
) < 0 &&
5024 YToEdgeOfRow(y
) < 0 )
5026 DisableCellEditControl();
5027 MakeCellVisible( coords
);
5029 // if this is the second click on this cell then start
5031 if ( m_waitForSlowClick
&&
5032 (coords
== m_currentCellCoords
) &&
5033 CanEnableCellControl())
5035 EnableCellEditControl();
5037 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
5038 wxGridCellEditor
*editor
= attr
->GetEditor(this,
5041 editor
->StartingClick();
5045 m_waitForSlowClick
= FALSE
;
5049 if ( event
.ControlDown() )
5051 m_selection
->ToggleCellSelection( coords
.GetRow(),
5053 event
.ControlDown(),
5057 m_selectingTopLeft
= wxGridNoCellCoords
;
5058 m_selectingBottomRight
= wxGridNoCellCoords
;
5059 m_selectingKeyboard
= coords
;
5063 SetCurrentCell( coords
);
5064 if ( m_selection
->GetSelectionMode()
5065 != wxGrid::wxGridSelectCells
)
5066 HighlightBlock( coords
, coords
);
5068 m_waitForSlowClick
= TRUE
;
5075 // ------------ Left double click
5077 else if ( event
.LeftDClick() && coords
!= wxGridNoCellCoords
)
5079 DisableCellEditControl();
5081 if ( XToEdgeOfCol(x
) < 0 && YToEdgeOfRow(y
) < 0 )
5083 SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK
,
5091 // ------------ Left button released
5093 else if ( event
.LeftUp() )
5095 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5097 if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
5098 m_selectingBottomRight
!= wxGridNoCellCoords
)
5102 m_winCapture
->ReleaseMouse();
5103 m_winCapture
= NULL
;
5105 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
5106 m_selectingTopLeft
.GetCol(),
5107 m_selectingBottomRight
.GetRow(),
5108 m_selectingBottomRight
.GetCol(),
5109 event
.ControlDown(),
5113 m_selectingTopLeft
= wxGridNoCellCoords
;
5114 m_selectingBottomRight
= wxGridNoCellCoords
;
5117 // Show the edit control, if it has been hidden for
5119 ShowCellEditControl();
5121 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
5123 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5124 DoEndDragResizeRow();
5126 // Note: we are ending the event *after* doing
5127 // default processing in this case
5129 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
5131 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
5133 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5134 DoEndDragResizeCol();
5136 // Note: we are ending the event *after* doing
5137 // default processing in this case
5139 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
5146 // ------------ Right button down
5148 else if ( event
.RightDown() && coords
!= wxGridNoCellCoords
)
5150 DisableCellEditControl();
5151 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK
,
5156 // no default action at the moment
5161 // ------------ Right double click
5163 else if ( event
.RightDClick() && coords
!= wxGridNoCellCoords
)
5165 DisableCellEditControl();
5166 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK
,
5171 // no default action at the moment
5175 // ------------ Moving and no button action
5177 else if ( event
.Moving() && !event
.IsButton() )
5179 int dragRow
= YToEdgeOfRow( y
);
5180 int dragCol
= XToEdgeOfCol( x
);
5182 // Dragging on the corner of a cell to resize in both
5183 // directions is not implemented yet...
5185 if ( dragRow
>= 0 && dragCol
>= 0 )
5187 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5193 m_dragRowOrCol
= dragRow
;
5195 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5197 if ( CanDragRowSize() && CanDragGridSize() )
5198 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
);
5203 m_dragRowOrCol
= dragCol
;
5211 m_dragRowOrCol
= dragCol
;
5213 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5215 if ( CanDragColSize() && CanDragGridSize() )
5216 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
);
5222 // Neither on a row or col edge
5224 if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5226 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
5232 void wxGrid::DoEndDragResizeRow()
5234 if ( m_dragLastPos
>= 0 )
5236 // erase the last line and resize the row
5238 int cw
, ch
, left
, dummy
;
5239 m_gridWin
->GetClientSize( &cw
, &ch
);
5240 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
5242 wxClientDC
dc( m_gridWin
);
5244 dc
.SetLogicalFunction( wxINVERT
);
5245 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
5246 HideCellEditControl();
5247 SaveEditControlValue();
5249 int rowTop
= GetRowTop(m_dragRowOrCol
);
5250 SetRowSize( m_dragRowOrCol
,
5251 wxMax( m_dragLastPos
- rowTop
, WXGRID_MIN_ROW_HEIGHT
) );
5253 if ( !GetBatchCount() )
5255 // Only needed to get the correct rect.y:
5256 wxRect
rect ( CellToRect( m_dragRowOrCol
, 0 ) );
5258 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
5259 rect
.width
= m_rowLabelWidth
;
5260 rect
.height
= ch
- rect
.y
;
5261 m_rowLabelWin
->Refresh( TRUE
, &rect
);
5263 m_gridWin
->Refresh( FALSE
, &rect
);
5266 ShowCellEditControl();
5271 void wxGrid::DoEndDragResizeCol()
5273 if ( m_dragLastPos
>= 0 )
5275 // erase the last line and resize the col
5277 int cw
, ch
, dummy
, top
;
5278 m_gridWin
->GetClientSize( &cw
, &ch
);
5279 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
5281 wxClientDC
dc( m_gridWin
);
5283 dc
.SetLogicalFunction( wxINVERT
);
5284 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ch
);
5285 HideCellEditControl();
5286 SaveEditControlValue();
5288 int colLeft
= GetColLeft(m_dragRowOrCol
);
5289 SetColSize( m_dragRowOrCol
,
5290 wxMax( m_dragLastPos
- colLeft
,
5291 GetColMinimalWidth(m_dragRowOrCol
) ) );
5293 if ( !GetBatchCount() )
5295 // Only needed to get the correct rect.x:
5296 wxRect
rect ( CellToRect( 0, m_dragRowOrCol
) );
5298 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
5299 rect
.width
= cw
- rect
.x
;
5300 rect
.height
= m_colLabelHeight
;
5301 m_colLabelWin
->Refresh( TRUE
, &rect
);
5303 m_gridWin
->Refresh( FALSE
, &rect
);
5306 ShowCellEditControl();
5313 // ------ interaction with data model
5315 bool wxGrid::ProcessTableMessage( wxGridTableMessage
& msg
)
5317 switch ( msg
.GetId() )
5319 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES
:
5320 return GetModelValues();
5322 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES
:
5323 return SetModelValues();
5325 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
5326 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
5327 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
5328 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
5329 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
5330 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
5331 return Redimension( msg
);
5340 // The behaviour of this function depends on the grid table class
5341 // Clear() function. For the default wxGridStringTable class the
5342 // behavious is to replace all cell contents with wxEmptyString but
5343 // not to change the number of rows or cols.
5345 void wxGrid::ClearGrid()
5349 if (IsCellEditControlEnabled())
5350 DisableCellEditControl();
5353 if ( !GetBatchCount() ) m_gridWin
->Refresh();
5358 bool wxGrid::InsertRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
5360 // TODO: something with updateLabels flag
5364 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
5370 if (IsCellEditControlEnabled())
5371 DisableCellEditControl();
5373 return m_table
->InsertRows( pos
, numRows
);
5375 // the table will have sent the results of the insert row
5376 // operation to this view object as a grid table message
5382 bool wxGrid::AppendRows( int numRows
, bool WXUNUSED(updateLabels
) )
5384 // TODO: something with updateLabels flag
5388 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
5392 return ( m_table
&& m_table
->AppendRows( numRows
) );
5393 // the table will have sent the results of the append row
5394 // operation to this view object as a grid table message
5398 bool wxGrid::DeleteRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
5400 // TODO: something with updateLabels flag
5404 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
5410 if (IsCellEditControlEnabled())
5411 DisableCellEditControl();
5413 return (m_table
->DeleteRows( pos
, numRows
));
5414 // the table will have sent the results of the delete row
5415 // operation to this view object as a grid table message
5421 bool wxGrid::InsertCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
5423 // TODO: something with updateLabels flag
5427 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
5433 if (IsCellEditControlEnabled())
5434 DisableCellEditControl();
5436 return m_table
->InsertCols( pos
, numCols
);
5437 // the table will have sent the results of the insert col
5438 // operation to this view object as a grid table message
5444 bool wxGrid::AppendCols( int numCols
, bool WXUNUSED(updateLabels
) )
5446 // TODO: something with updateLabels flag
5450 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
5454 return ( m_table
&& m_table
->AppendCols( numCols
) );
5455 // the table will have sent the results of the append col
5456 // operation to this view object as a grid table message
5460 bool wxGrid::DeleteCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
5462 // TODO: something with updateLabels flag
5466 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
5472 if (IsCellEditControlEnabled())
5473 DisableCellEditControl();
5475 return ( m_table
->DeleteCols( pos
, numCols
) );
5476 // the table will have sent the results of the delete col
5477 // operation to this view object as a grid table message
5485 // ----- event handlers
5488 // Generate a grid event based on a mouse event and
5489 // return the result of ProcessEvent()
5491 int wxGrid::SendEvent( const wxEventType type
,
5493 wxMouseEvent
& mouseEv
)
5498 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
5500 int rowOrCol
= (row
== -1 ? col
: row
);
5502 wxGridSizeEvent
gridEvt( GetId(),
5506 mouseEv
.GetX() + GetRowLabelSize(),
5507 mouseEv
.GetY() + GetColLabelSize(),
5508 mouseEv
.ControlDown(),
5509 mouseEv
.ShiftDown(),
5511 mouseEv
.MetaDown() );
5513 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5514 vetoed
= !gridEvt
.IsAllowed();
5516 else if ( type
== wxEVT_GRID_RANGE_SELECT
)
5518 // Right now, it should _never_ end up here!
5519 wxGridRangeSelectEvent
gridEvt( GetId(),
5523 m_selectingBottomRight
,
5525 mouseEv
.ControlDown(),
5526 mouseEv
.ShiftDown(),
5528 mouseEv
.MetaDown() );
5530 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5531 vetoed
= !gridEvt
.IsAllowed();
5535 wxGridEvent
gridEvt( GetId(),
5539 mouseEv
.GetX() + GetRowLabelSize(),
5540 mouseEv
.GetY() + GetColLabelSize(),
5542 mouseEv
.ControlDown(),
5543 mouseEv
.ShiftDown(),
5545 mouseEv
.MetaDown() );
5546 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5547 vetoed
= !gridEvt
.IsAllowed();
5550 // A Veto'd event may not be `claimed' so test this first
5551 if (vetoed
) return -1;
5552 return claimed
? 1 : 0;
5556 // Generate a grid event of specified type and return the result
5557 // of ProcessEvent().
5559 int wxGrid::SendEvent( const wxEventType type
,
5565 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
5567 int rowOrCol
= (row
== -1 ? col
: row
);
5569 wxGridSizeEvent
gridEvt( GetId(),
5574 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5575 vetoed
= !gridEvt
.IsAllowed();
5579 wxGridEvent
gridEvt( GetId(),
5584 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
5585 vetoed
= !gridEvt
.IsAllowed();
5588 // A Veto'd event may not be `claimed' so test this first
5589 if (vetoed
) return -1;
5590 return claimed
? 1 : 0;
5594 void wxGrid::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
5596 wxPaintDC
dc(this); // needed to prevent zillions of paint events on MSW
5600 void wxGrid::OnSize( wxSizeEvent
& event
)
5602 // position the child windows
5605 // don't call CalcDimensions() from here, the base class handles the size
5611 void wxGrid::OnKeyDown( wxKeyEvent
& event
)
5613 if ( m_inOnKeyDown
)
5615 // shouldn't be here - we are going round in circles...
5617 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
5620 m_inOnKeyDown
= TRUE
;
5622 // propagate the event up and see if it gets processed
5624 wxWindow
*parent
= GetParent();
5625 wxKeyEvent
keyEvt( event
);
5626 keyEvt
.SetEventObject( parent
);
5628 if ( !parent
->GetEventHandler()->ProcessEvent( keyEvt
) )
5631 // try local handlers
5633 switch ( event
.KeyCode() )
5636 if ( event
.ControlDown() )
5638 MoveCursorUpBlock( event
.ShiftDown() );
5642 MoveCursorUp( event
.ShiftDown() );
5647 if ( event
.ControlDown() )
5649 MoveCursorDownBlock( event
.ShiftDown() );
5653 MoveCursorDown( event
.ShiftDown() );
5658 if ( event
.ControlDown() )
5660 MoveCursorLeftBlock( event
.ShiftDown() );
5664 MoveCursorLeft( event
.ShiftDown() );
5669 if ( event
.ControlDown() )
5671 MoveCursorRightBlock( event
.ShiftDown() );
5675 MoveCursorRight( event
.ShiftDown() );
5680 case WXK_NUMPAD_ENTER
:
5681 if ( event
.ControlDown() )
5683 event
.Skip(); // to let the edit control have the return
5687 if ( GetGridCursorRow() < GetNumberRows()-1 )
5689 MoveCursorDown( event
.ShiftDown() );
5693 // at the bottom of a column
5694 HideCellEditControl();
5695 SaveEditControlValue();
5705 if (event
.ShiftDown())
5707 if ( GetGridCursorCol() > 0 )
5709 MoveCursorLeft( FALSE
);
5714 HideCellEditControl();
5715 SaveEditControlValue();
5720 if ( GetGridCursorCol() < GetNumberCols()-1 )
5722 MoveCursorRight( FALSE
);
5727 HideCellEditControl();
5728 SaveEditControlValue();
5734 if ( event
.ControlDown() )
5736 MakeCellVisible( 0, 0 );
5737 SetCurrentCell( 0, 0 );
5746 if ( event
.ControlDown() )
5748 MakeCellVisible( m_numRows
-1, m_numCols
-1 );
5749 SetCurrentCell( m_numRows
-1, m_numCols
-1 );
5766 if ( event
.ControlDown() )
5768 m_selection
->ToggleCellSelection( m_currentCellCoords
.GetRow(),
5769 m_currentCellCoords
.GetCol(),
5770 event
.ControlDown(),
5776 if ( !IsEditable() )
5778 MoveCursorRight( FALSE
);
5781 // Otherwise fall through to default
5784 // is it possible to edit the current cell at all?
5785 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
5787 // yes, now check whether the cells editor accepts the key
5788 int row
= m_currentCellCoords
.GetRow();
5789 int col
= m_currentCellCoords
.GetCol();
5790 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
5791 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
5793 // <F2> is special and will always start editing, for
5794 // other keys - ask the editor itself
5795 if ( (event
.KeyCode() == WXK_F2
&& !event
.HasModifiers())
5796 || editor
->IsAcceptedKey(event
) )
5798 EnableCellEditControl();
5800 // the editor could be not shown for a variety of
5801 // reasons (i.e. blocked by the app or whatever), so
5802 // check if it really was created
5803 if ( m_cellEditCtrlEnabled
)
5805 editor
->StartingKey(event
);
5818 // let others process char events with modifiers or all
5819 // char events for readonly cells
5826 m_inOnKeyDown
= FALSE
;
5829 void wxGrid::OnKeyUp( wxKeyEvent
& event
)
5831 // try local handlers
5833 if ( event
.KeyCode() == WXK_SHIFT
)
5835 if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
5836 m_selectingBottomRight
!= wxGridNoCellCoords
)
5837 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
5838 m_selectingTopLeft
.GetCol(),
5839 m_selectingBottomRight
.GetRow(),
5840 m_selectingBottomRight
.GetCol(),
5841 event
.ControlDown(),
5845 m_selectingTopLeft
= wxGridNoCellCoords
;
5846 m_selectingBottomRight
= wxGridNoCellCoords
;
5847 m_selectingKeyboard
= wxGridNoCellCoords
;
5851 void wxGrid::OnEraseBackground(wxEraseEvent
&)
5855 void wxGrid::SetCurrentCell( const wxGridCellCoords
& coords
)
5857 if ( SendEvent( wxEVT_GRID_SELECT_CELL
, coords
.GetRow(), coords
.GetCol() ) )
5859 // the event has been intercepted - do nothing
5863 wxClientDC
dc(m_gridWin
);
5866 if ( m_currentCellCoords
!= wxGridNoCellCoords
)
5868 HideCellEditControl();
5869 DisableCellEditControl();
5871 if ( IsVisible( m_currentCellCoords
, FALSE
) )
5874 r
= BlockToDeviceRect(m_currentCellCoords
, coords
);
5875 if ( !m_gridLinesEnabled
)
5883 wxGridCellCoordsArray cells
= CalcCellsExposed( r
);
5885 // Otherwise refresh redraws the highlight!
5886 m_currentCellCoords
= coords
;
5888 DrawGridCellArea(dc
,cells
);
5889 DrawAllGridLines( dc
, r
);
5893 m_currentCellCoords
= coords
;
5895 wxGridCellAttr
* attr
= GetCellAttr(coords
);
5896 DrawCellHighlight(dc
, attr
);
5901 void wxGrid::HighlightBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
)
5904 wxGridCellCoords updateTopLeft
, updateBottomRight
;
5906 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
5909 rightCol
= GetNumberCols() - 1;
5911 else if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
5914 bottomRow
= GetNumberRows() - 1;
5916 if ( topRow
> bottomRow
)
5923 if ( leftCol
> rightCol
)
5930 updateTopLeft
= wxGridCellCoords( topRow
, leftCol
);
5931 updateBottomRight
= wxGridCellCoords( bottomRow
, rightCol
);
5933 if ( m_selectingTopLeft
!= updateTopLeft
||
5934 m_selectingBottomRight
!= updateBottomRight
)
5936 // Compute two optimal update rectangles:
5937 // Either one rectangle is a real subset of the
5938 // other, or they are (almost) disjoint!
5940 bool need_refresh
[4];
5944 need_refresh
[3] = FALSE
;
5947 // Store intermediate values
5948 wxCoord oldLeft
= m_selectingTopLeft
.GetCol();
5949 wxCoord oldTop
= m_selectingTopLeft
.GetRow();
5950 wxCoord oldRight
= m_selectingBottomRight
.GetCol();
5951 wxCoord oldBottom
= m_selectingBottomRight
.GetRow();
5953 // Determine the outer/inner coordinates.
5954 if (oldLeft
> leftCol
)
5960 if (oldTop
> topRow
)
5966 if (oldRight
< rightCol
)
5969 oldRight
= rightCol
;
5972 if (oldBottom
< bottomRow
)
5975 oldBottom
= bottomRow
;
5979 // Now, either the stuff marked old is the outer
5980 // rectangle or we don't have a situation where one
5981 // is contained in the other.
5983 if ( oldLeft
< leftCol
)
5985 need_refresh
[0] = TRUE
;
5986 rect
[0] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
5988 wxGridCellCoords ( oldBottom
,
5992 if ( oldTop
< topRow
)
5994 need_refresh
[1] = TRUE
;
5995 rect
[1] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
5997 wxGridCellCoords ( topRow
- 1,
6001 if ( oldRight
> rightCol
)
6003 need_refresh
[2] = TRUE
;
6004 rect
[2] = BlockToDeviceRect( wxGridCellCoords ( oldTop
,
6006 wxGridCellCoords ( oldBottom
,
6010 if ( oldBottom
> bottomRow
)
6012 need_refresh
[3] = TRUE
;
6013 rect
[3] = BlockToDeviceRect( wxGridCellCoords ( bottomRow
+ 1,
6015 wxGridCellCoords ( oldBottom
,
6021 m_selectingTopLeft
= updateTopLeft
;
6022 m_selectingBottomRight
= updateBottomRight
;
6024 // various Refresh() calls
6025 for (i
= 0; i
< 4; i
++ )
6026 if ( need_refresh
[i
] && rect
[i
] != wxGridNoCellRect
)
6027 m_gridWin
->Refresh( FALSE
, &(rect
[i
]) );
6030 // never generate an event as it will be generated from
6031 // wxGridSelection::SelectBlock!
6032 // (old comment from when this was the body of SelectBlock)
6036 // ------ functions to get/send data (see also public functions)
6039 bool wxGrid::GetModelValues()
6043 // all we need to do is repaint the grid
6045 m_gridWin
->Refresh();
6053 bool wxGrid::SetModelValues()
6059 for ( row
= 0; row
< m_numRows
; row
++ )
6061 for ( col
= 0; col
< m_numCols
; col
++ )
6063 m_table
->SetValue( row
, col
, GetCellValue(row
, col
) );
6075 // Note - this function only draws cells that are in the list of
6076 // exposed cells (usually set from the update region by
6077 // CalcExposedCells)
6079 void wxGrid::DrawGridCellArea( wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
6081 if ( !m_numRows
|| !m_numCols
) return;
6084 size_t numCells
= cells
.GetCount();
6086 for ( i
= 0; i
< numCells
; i
++ )
6088 DrawCell( dc
, cells
[i
] );
6093 void wxGrid::DrawGridSpace( wxDC
& dc
)
6096 m_gridWin
->GetClientSize( &cw
, &ch
);
6099 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6101 int rightCol
= m_numCols
> 0 ? GetColRight(m_numCols
- 1) : 0;
6102 int bottomRow
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0 ;
6104 if ( right
> rightCol
|| bottom
> bottomRow
)
6107 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6109 dc
.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID
) );
6110 dc
.SetPen( *wxTRANSPARENT_PEN
);
6112 if ( right
> rightCol
)
6114 dc
.DrawRectangle( rightCol
, top
, right
- rightCol
, ch
);
6117 if ( bottom
> bottomRow
)
6119 dc
.DrawRectangle( left
, bottomRow
, cw
, bottom
- bottomRow
);
6125 void wxGrid::DrawCell( wxDC
& dc
, const wxGridCellCoords
& coords
)
6127 int row
= coords
.GetRow();
6128 int col
= coords
.GetCol();
6130 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6133 // we draw the cell border ourselves
6134 #if !WXGRID_DRAW_LINES
6135 if ( m_gridLinesEnabled
)
6136 DrawCellBorder( dc
, coords
);
6139 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6141 bool isCurrent
= coords
== m_currentCellCoords
;
6143 wxRect rect
= CellToRect( row
, col
);
6145 // if the editor is shown, we should use it and not the renderer
6146 // Note: However, only if it is really _shown_, i.e. not hidden!
6147 if ( isCurrent
&& IsCellEditControlShown() )
6149 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
6150 editor
->PaintBackground(rect
, attr
);
6155 // but all the rest is drawn by the cell renderer and hence may be
6157 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
6158 renderer
->Draw(*this, *attr
, dc
, rect
, row
, col
, IsInSelection(coords
));
6165 void wxGrid::DrawCellHighlight( wxDC
& dc
, const wxGridCellAttr
*attr
)
6167 int row
= m_currentCellCoords
.GetRow();
6168 int col
= m_currentCellCoords
.GetCol();
6170 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6173 wxRect rect
= CellToRect(row
, col
);
6175 // hmmm... what could we do here to show that the cell is disabled?
6176 // for now, I just draw a thinner border than for the other ones, but
6177 // it doesn't look really good
6179 int penWidth
= attr
->IsReadOnly() ? m_cellHighlightROPenWidth
: m_cellHighlightPenWidth
;
6183 // The center of th drawn line is where the position/width/height of
6184 // the rectangle is actually at, (on wxMSW atr least,) so we will
6185 // reduce the size of the rectangle to compensate for the thickness of
6186 // the line. If this is too strange on non wxMSW platforms then
6187 // please #ifdef this appropriately.
6188 rect
.x
+= penWidth
/2;
6189 rect
.y
+= penWidth
/2;
6190 rect
.width
-= penWidth
-1;
6191 rect
.height
-= penWidth
-1;
6194 // Now draw the rectangle
6195 dc
.SetPen(wxPen(m_cellHighlightColour
, penWidth
, wxSOLID
));
6196 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
6197 dc
.DrawRectangle(rect
);
6201 // VZ: my experiments with 3d borders...
6203 // how to properly set colours for arbitrary bg?
6204 wxCoord x1
= rect
.x
,
6206 x2
= rect
.x
+ rect
.width
-1,
6207 y2
= rect
.y
+ rect
.height
-1;
6209 dc
.SetPen(*wxWHITE_PEN
);
6210 dc
.DrawLine(x1
, y1
, x2
, y1
);
6211 dc
.DrawLine(x1
, y1
, x1
, y2
);
6213 dc
.DrawLine(x1
+ 1, y2
- 1, x2
- 1, y2
- 1);
6214 dc
.DrawLine(x2
- 1, y1
+ 1, x2
- 1, y2
);
6216 dc
.SetPen(*wxBLACK_PEN
);
6217 dc
.DrawLine(x1
, y2
, x2
, y2
);
6218 dc
.DrawLine(x2
, y1
, x2
, y2
+1);
6223 void wxGrid::DrawCellBorder( wxDC
& dc
, const wxGridCellCoords
& coords
)
6225 int row
= coords
.GetRow();
6226 int col
= coords
.GetCol();
6227 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
6230 dc
.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID
) );
6232 // right hand border
6234 dc
.DrawLine( GetColRight(col
), GetRowTop(row
),
6235 GetColRight(col
), GetRowBottom(row
) );
6239 dc
.DrawLine( GetColLeft(col
), GetRowBottom(row
),
6240 GetColRight(col
), GetRowBottom(row
) );
6243 void wxGrid::DrawHighlight(wxDC
& dc
,const wxGridCellCoordsArray
& cells
)
6245 // This if block was previously in wxGrid::OnPaint but that doesn't
6246 // seem to get called under wxGTK - MB
6248 if ( m_currentCellCoords
== wxGridNoCellCoords
&&
6249 m_numRows
&& m_numCols
)
6251 m_currentCellCoords
.Set(0, 0);
6254 if ( IsCellEditControlShown() )
6256 // don't show highlight when the edit control is shown
6260 // if the active cell was repainted, repaint its highlight too because it
6261 // might have been damaged by the grid lines
6262 size_t count
= cells
.GetCount();
6263 for ( size_t n
= 0; n
< count
; n
++ )
6265 if ( cells
[n
] == m_currentCellCoords
)
6267 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
6268 DrawCellHighlight(dc
, attr
);
6276 // TODO: remove this ???
6277 // This is used to redraw all grid lines e.g. when the grid line colour
6280 void wxGrid::DrawAllGridLines( wxDC
& dc
, const wxRegion
& WXUNUSED(reg
) )
6282 if ( !m_gridLinesEnabled
||
6284 !m_numCols
) return;
6286 int top
, bottom
, left
, right
;
6288 #if 0 //#ifndef __WXGTK__
6292 m_gridWin
->GetClientSize(&cw
, &ch
);
6294 // virtual coords of visible area
6296 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6297 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6302 reg
.GetBox(x
, y
, w
, h
);
6303 CalcUnscrolledPosition( x
, y
, &left
, &top
);
6304 CalcUnscrolledPosition( x
+ w
, y
+ h
, &right
, &bottom
);
6308 m_gridWin
->GetClientSize(&cw
, &ch
);
6309 CalcUnscrolledPosition( 0, 0, &left
, &top
);
6310 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
6313 // avoid drawing grid lines past the last row and col
6315 right
= wxMin( right
, GetColRight(m_numCols
- 1) );
6316 bottom
= wxMin( bottom
, GetRowBottom(m_numRows
- 1) );
6318 dc
.SetPen( wxPen(GetGridLineColour(), 1, wxSOLID
) );
6320 // horizontal grid lines
6323 for ( i
= internalYToRow(top
); i
< m_numRows
; i
++ )
6325 int bot
= GetRowBottom(i
) - 1;
6334 dc
.DrawLine( left
, bot
, right
, bot
);
6339 // vertical grid lines
6341 for ( i
= internalXToCol(left
); i
< m_numCols
; i
++ )
6343 int colRight
= GetColRight(i
) - 1;
6344 if ( colRight
> right
)
6349 if ( colRight
>= left
)
6351 dc
.DrawLine( colRight
, top
, colRight
, bottom
);
6357 void wxGrid::DrawRowLabels( wxDC
& dc
,const wxArrayInt
& rows
)
6359 if ( !m_numRows
) return;
6362 size_t numLabels
= rows
.GetCount();
6364 for ( i
= 0; i
< numLabels
; i
++ )
6366 DrawRowLabel( dc
, rows
[i
] );
6371 void wxGrid::DrawRowLabel( wxDC
& dc
, int row
)
6373 if ( GetRowHeight(row
) <= 0 )
6376 int rowTop
= GetRowTop(row
),
6377 rowBottom
= GetRowBottom(row
) - 1;
6379 dc
.SetPen( *wxBLACK_PEN
);
6380 dc
.DrawLine( m_rowLabelWidth
-1, rowTop
,
6381 m_rowLabelWidth
-1, rowBottom
);
6383 dc
.DrawLine( 0, rowBottom
, m_rowLabelWidth
-1, rowBottom
);
6385 dc
.SetPen( *wxWHITE_PEN
);
6386 dc
.DrawLine( 0, rowTop
, 0, rowBottom
);
6387 dc
.DrawLine( 0, rowTop
, m_rowLabelWidth
-1, rowTop
);
6389 dc
.SetBackgroundMode( wxTRANSPARENT
);
6390 dc
.SetTextForeground( GetLabelTextColour() );
6391 dc
.SetFont( GetLabelFont() );
6394 GetRowLabelAlignment( &hAlign
, &vAlign
);
6398 rect
.SetY( GetRowTop(row
) + 2 );
6399 rect
.SetWidth( m_rowLabelWidth
- 4 );
6400 rect
.SetHeight( GetRowHeight(row
) - 4 );
6401 DrawTextRectangle( dc
, GetRowLabelValue( row
), rect
, hAlign
, vAlign
);
6405 void wxGrid::DrawColLabels( wxDC
& dc
,const wxArrayInt
& cols
)
6407 if ( !m_numCols
) return;
6410 size_t numLabels
= cols
.GetCount();
6412 for ( i
= 0; i
< numLabels
; i
++ )
6414 DrawColLabel( dc
, cols
[i
] );
6419 void wxGrid::DrawColLabel( wxDC
& dc
, int col
)
6421 if ( GetColWidth(col
) <= 0 )
6424 int colLeft
= GetColLeft(col
),
6425 colRight
= GetColRight(col
) - 1;
6427 dc
.SetPen( *wxBLACK_PEN
);
6428 dc
.DrawLine( colRight
, 0,
6429 colRight
, m_colLabelHeight
-1 );
6431 dc
.DrawLine( colLeft
, m_colLabelHeight
-1,
6432 colRight
, m_colLabelHeight
-1 );
6434 dc
.SetPen( *wxWHITE_PEN
);
6435 dc
.DrawLine( colLeft
, 0, colLeft
, m_colLabelHeight
-1 );
6436 dc
.DrawLine( colLeft
, 0, colRight
, 0 );
6438 dc
.SetBackgroundMode( wxTRANSPARENT
);
6439 dc
.SetTextForeground( GetLabelTextColour() );
6440 dc
.SetFont( GetLabelFont() );
6442 dc
.SetBackgroundMode( wxTRANSPARENT
);
6443 dc
.SetTextForeground( GetLabelTextColour() );
6444 dc
.SetFont( GetLabelFont() );
6447 GetColLabelAlignment( &hAlign
, &vAlign
);
6450 rect
.SetX( colLeft
+ 2 );
6452 rect
.SetWidth( GetColWidth(col
) - 4 );
6453 rect
.SetHeight( m_colLabelHeight
- 4 );
6454 DrawTextRectangle( dc
, GetColLabelValue( col
), rect
, hAlign
, vAlign
);
6457 void wxGrid::DrawTextRectangle( wxDC
& dc
,
6458 const wxString
& value
,
6463 wxArrayString lines
;
6465 dc
.SetClippingRegion( rect
);
6466 StringToLines( value
, lines
);
6469 //Forward to new API.
6470 DrawTextRectangle( dc
,
6478 void wxGrid::DrawTextRectangle( wxDC
& dc
,
6479 const wxArrayString
& lines
,
6484 long textWidth
, textHeight
;
6485 long lineWidth
, lineHeight
;
6487 if ( lines
.GetCount() )
6489 GetTextBoxSize( dc
, lines
, &textWidth
, &textHeight
);
6490 dc
.GetTextExtent( lines
[0], &lineWidth
, &lineHeight
);
6493 switch ( horizAlign
)
6496 x
= rect
.x
+ (rect
.width
- textWidth
- 1);
6499 case wxALIGN_CENTRE
:
6500 x
= rect
.x
+ ((rect
.width
- textWidth
)/2);
6509 switch ( vertAlign
)
6511 case wxALIGN_BOTTOM
:
6512 y
= rect
.y
+ (rect
.height
- textHeight
- 1);
6515 case wxALIGN_CENTRE
:
6516 y
= rect
.y
+ ((rect
.height
- textHeight
)/2);
6525 for ( size_t i
= 0; i
< lines
.GetCount(); i
++ )
6527 dc
.DrawText( lines
[i
], (int)x
, (int)y
);
6532 dc
.DestroyClippingRegion();
6536 // Split multi line text up into an array of strings. Any existing
6537 // contents of the string array are preserved.
6539 void wxGrid::StringToLines( const wxString
& value
, wxArrayString
& lines
)
6543 wxString eol
= wxTextFile::GetEOL( wxTextFileType_Unix
);
6544 wxString tVal
= wxTextFile::Translate( value
, wxTextFileType_Unix
);
6546 while ( startPos
< (int)tVal
.Length() )
6548 pos
= tVal
.Mid(startPos
).Find( eol
);
6553 else if ( pos
== 0 )
6555 lines
.Add( wxEmptyString
);
6559 lines
.Add( value
.Mid(startPos
, pos
) );
6563 if ( startPos
< (int)value
.Length() )
6565 lines
.Add( value
.Mid( startPos
) );
6570 void wxGrid::GetTextBoxSize( wxDC
& dc
,
6571 const wxArrayString
& lines
,
6572 long *width
, long *height
)
6579 for ( i
= 0; i
< lines
.GetCount(); i
++ )
6581 dc
.GetTextExtent( lines
[i
], &lineW
, &lineH
);
6582 w
= wxMax( w
, lineW
);
6591 // ------ Batch processing.
6593 void wxGrid::EndBatch()
6595 if ( m_batchCount
> 0 )
6598 if ( !m_batchCount
)
6601 m_rowLabelWin
->Refresh();
6602 m_colLabelWin
->Refresh();
6603 m_cornerLabelWin
->Refresh();
6604 m_gridWin
->Refresh();
6609 // Use this, rather than wxWindow::Refresh(), to force an immediate
6610 // repainting of the grid. Has no effect if you are already inside a
6611 // BeginBatch / EndBatch block.
6613 void wxGrid::ForceRefresh()
6621 // ------ Edit control functions
6625 void wxGrid::EnableEditing( bool edit
)
6627 // TODO: improve this ?
6629 if ( edit
!= m_editable
)
6631 if(!edit
) EnableCellEditControl(edit
);
6637 void wxGrid::EnableCellEditControl( bool enable
)
6642 if ( m_currentCellCoords
== wxGridNoCellCoords
)
6643 SetCurrentCell( 0, 0 );
6645 if ( enable
!= m_cellEditCtrlEnabled
)
6649 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN
) <0)
6652 // this should be checked by the caller!
6653 wxASSERT_MSG( CanEnableCellControl(),
6654 _T("can't enable editing for this cell!") );
6656 // do it before ShowCellEditControl()
6657 m_cellEditCtrlEnabled
= enable
;
6659 ShowCellEditControl();
6663 //FIXME:add veto support
6664 SendEvent( wxEVT_GRID_EDITOR_HIDDEN
);
6666 HideCellEditControl();
6667 SaveEditControlValue();
6669 // do it after HideCellEditControl()
6670 m_cellEditCtrlEnabled
= enable
;
6675 bool wxGrid::IsCurrentCellReadOnly() const
6678 wxGridCellAttr
* attr
= ((wxGrid
*)this)->GetCellAttr(m_currentCellCoords
);
6679 bool readonly
= attr
->IsReadOnly();
6685 bool wxGrid::CanEnableCellControl() const
6687 return m_editable
&& !IsCurrentCellReadOnly();
6690 bool wxGrid::IsCellEditControlEnabled() const
6692 // the cell edit control might be disable for all cells or just for the
6693 // current one if it's read only
6694 return m_cellEditCtrlEnabled
? !IsCurrentCellReadOnly() : FALSE
;
6697 bool wxGrid::IsCellEditControlShown() const
6699 bool isShown
= FALSE
;
6701 if ( m_cellEditCtrlEnabled
)
6703 int row
= m_currentCellCoords
.GetRow();
6704 int col
= m_currentCellCoords
.GetCol();
6705 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6706 wxGridCellEditor
* editor
= attr
->GetEditor((wxGrid
*) this, row
, col
);
6711 if ( editor
->IsCreated() )
6713 isShown
= editor
->GetControl()->IsShown();
6723 void wxGrid::ShowCellEditControl()
6725 if ( IsCellEditControlEnabled() )
6727 if ( !IsVisible( m_currentCellCoords
) )
6729 m_cellEditCtrlEnabled
= FALSE
;
6734 wxRect rect
= CellToRect( m_currentCellCoords
);
6735 int row
= m_currentCellCoords
.GetRow();
6736 int col
= m_currentCellCoords
.GetCol();
6738 // convert to scrolled coords
6740 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
6742 // done in PaintBackground()
6744 // erase the highlight and the cell contents because the editor
6745 // might not cover the entire cell
6746 wxClientDC
dc( m_gridWin
);
6748 dc
.SetBrush(*wxLIGHT_GREY_BRUSH
); //wxBrush(attr->GetBackgroundColour(), wxSOLID));
6749 dc
.SetPen(*wxTRANSPARENT_PEN
);
6750 dc
.DrawRectangle(rect
);
6753 // cell is shifted by one pixel
6754 // However, don't allow x or y to become negative
6755 // since the SetSize() method interprets that as
6762 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6763 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
6764 if ( !editor
->IsCreated() )
6766 editor
->Create(m_gridWin
, -1,
6767 new wxGridCellEditorEvtHandler(this, editor
));
6769 wxGridEditorCreatedEvent
evt(GetId(),
6770 wxEVT_GRID_EDITOR_CREATED
,
6774 editor
->GetControl());
6775 GetEventHandler()->ProcessEvent(evt
);
6778 editor
->Show( TRUE
, attr
);
6780 editor
->SetSize( rect
);
6782 editor
->BeginEdit(row
, col
, this);
6791 void wxGrid::HideCellEditControl()
6793 if ( IsCellEditControlEnabled() )
6795 int row
= m_currentCellCoords
.GetRow();
6796 int col
= m_currentCellCoords
.GetCol();
6798 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6799 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
6800 editor
->Show( FALSE
);
6803 m_gridWin
->SetFocus();
6804 wxRect
rect( CellToRect( row
, col
) );
6805 m_gridWin
->Refresh( FALSE
, &rect
);
6810 void wxGrid::SaveEditControlValue()
6812 if ( IsCellEditControlEnabled() )
6814 int row
= m_currentCellCoords
.GetRow();
6815 int col
= m_currentCellCoords
.GetCol();
6817 wxString oldval
= GetCellValue(row
,col
);
6819 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6820 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
6821 bool changed
= editor
->EndEdit(row
, col
, this);
6828 if ( SendEvent( wxEVT_GRID_CELL_CHANGE
,
6829 m_currentCellCoords
.GetRow(),
6830 m_currentCellCoords
.GetCol() ) < 0 ) {
6832 // Event has been vetoed, set the data back.
6833 SetCellValue(row
,col
,oldval
);
6841 // ------ Grid location functions
6842 // Note that all of these functions work with the logical coordinates of
6843 // grid cells and labels so you will need to convert from device
6844 // coordinates for mouse events etc.
6847 void wxGrid::XYToCell( int x
, int y
, wxGridCellCoords
& coords
)
6849 int row
= YToRow(y
);
6850 int col
= XToCol(x
);
6852 if ( row
== -1 || col
== -1 )
6854 coords
= wxGridNoCellCoords
;
6858 coords
.Set( row
, col
);
6863 // Internal Helper function for computing row or column from some
6864 // (unscrolled) coordinate value, using either
6865 // m_defaultRowHeight/m_defaultColWidth or binary search on array
6866 // of m_rowBottoms/m_ColRights to speed up the search!
6868 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
6869 const wxArrayInt
& BorderArray
, bool maxOnOverflow
)
6873 size_t i_max
= coord
/ defaultDist
,
6875 if (BorderArray
.IsEmpty())
6880 if ( i_max
>= BorderArray
.GetCount())
6881 i_max
= BorderArray
.GetCount() - 1;
6884 if ( coord
>= BorderArray
[i_max
])
6887 i_max
= coord
/ minDist
;
6889 if ( i_max
>= BorderArray
.GetCount())
6890 i_max
= BorderArray
.GetCount() - 1;
6892 if ( coord
>= BorderArray
[i_max
])
6893 return maxOnOverflow
? (int)i_max
: -1;
6894 if ( coord
< BorderArray
[0] )
6897 while ( i_max
- i_min
> 0 )
6899 wxCHECK_MSG(BorderArray
[i_min
] <= coord
&& coord
< BorderArray
[i_max
],
6900 0, _T("wxGrid: internal error in CoordToRowOrCol"));
6901 if (coord
>= BorderArray
[ i_max
- 1])
6905 int median
= i_min
+ (i_max
- i_min
+ 1) / 2;
6906 if (coord
< BorderArray
[median
])
6914 int wxGrid::YToRow( int y
)
6916 return CoordToRowOrCol(y
, m_defaultRowHeight
,
6917 WXGRID_MIN_ROW_HEIGHT
, m_rowBottoms
, FALSE
);
6921 int wxGrid::XToCol( int x
)
6923 return CoordToRowOrCol(x
, m_defaultColWidth
,
6924 WXGRID_MIN_COL_WIDTH
, m_colRights
, FALSE
);
6928 // return the row number that that the y coord is near the edge of, or
6929 // -1 if not near an edge
6931 int wxGrid::YToEdgeOfRow( int y
)
6934 i
= internalYToRow(y
);
6936 if ( GetRowHeight(i
) > WXGRID_LABEL_EDGE_ZONE
)
6938 // We know that we are in row i, test whether we are
6939 // close enough to lower or upper border, respectively.
6940 if ( abs(GetRowBottom(i
) - y
) < WXGRID_LABEL_EDGE_ZONE
)
6942 else if( i
> 0 && y
- GetRowTop(i
) < WXGRID_LABEL_EDGE_ZONE
)
6950 // return the col number that that the x coord is near the edge of, or
6951 // -1 if not near an edge
6953 int wxGrid::XToEdgeOfCol( int x
)
6956 i
= internalXToCol(x
);
6958 if ( GetColWidth(i
) > WXGRID_LABEL_EDGE_ZONE
)
6960 // We know that we are in column i, test whether we are
6961 // close enough to right or left border, respectively.
6962 if ( abs(GetColRight(i
) - x
) < WXGRID_LABEL_EDGE_ZONE
)
6964 else if( i
> 0 && x
- GetColLeft(i
) < WXGRID_LABEL_EDGE_ZONE
)
6972 wxRect
wxGrid::CellToRect( int row
, int col
)
6974 wxRect
rect( -1, -1, -1, -1 );
6976 if ( row
>= 0 && row
< m_numRows
&&
6977 col
>= 0 && col
< m_numCols
)
6979 rect
.x
= GetColLeft(col
);
6980 rect
.y
= GetRowTop(row
);
6981 rect
.width
= GetColWidth(col
);
6982 rect
.height
= GetRowHeight(row
);
6985 // if grid lines are enabled, then the area of the cell is a bit smaller
6986 if (m_gridLinesEnabled
) {
6994 bool wxGrid::IsVisible( int row
, int col
, bool wholeCellVisible
)
6996 // get the cell rectangle in logical coords
6998 wxRect
r( CellToRect( row
, col
) );
7000 // convert to device coords
7002 int left
, top
, right
, bottom
;
7003 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
7004 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
7006 // check against the client area of the grid window
7009 m_gridWin
->GetClientSize( &cw
, &ch
);
7011 if ( wholeCellVisible
)
7013 // is the cell wholly visible ?
7015 return ( left
>= 0 && right
<= cw
&&
7016 top
>= 0 && bottom
<= ch
);
7020 // is the cell partly visible ?
7022 return ( ((left
>=0 && left
< cw
) || (right
> 0 && right
<= cw
)) &&
7023 ((top
>=0 && top
< ch
) || (bottom
> 0 && bottom
<= ch
)) );
7028 // make the specified cell location visible by doing a minimal amount
7031 void wxGrid::MakeCellVisible( int row
, int col
)
7035 int xpos
= -1, ypos
= -1;
7037 if ( row
>= 0 && row
< m_numRows
&&
7038 col
>= 0 && col
< m_numCols
)
7040 // get the cell rectangle in logical coords
7042 wxRect
r( CellToRect( row
, col
) );
7044 // convert to device coords
7046 int left
, top
, right
, bottom
;
7047 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
7048 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
7051 m_gridWin
->GetClientSize( &cw
, &ch
);
7057 else if ( bottom
> ch
)
7059 int h
= r
.GetHeight();
7061 for ( i
= row
-1; i
>= 0; i
-- )
7063 int rowHeight
= GetRowHeight(i
);
7064 if ( h
+ rowHeight
> ch
)
7071 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
7072 // have rounding errors (this is important, because if we do, we
7073 // might not scroll at all and some cells won't be redrawn)
7075 // Sometimes GRID_SCROLL_LINE/2 is not enough, so just add a full
7077 ypos
+= GRID_SCROLL_LINE_Y
;
7084 else if ( right
> cw
)
7086 int w
= r
.GetWidth();
7088 for ( i
= col
-1; i
>= 0; i
-- )
7090 int colWidth
= GetColWidth(i
);
7091 if ( w
+ colWidth
> cw
)
7098 // see comment for ypos above
7099 xpos
+= GRID_SCROLL_LINE_X
;
7102 if ( xpos
!= -1 || ypos
!= -1 )
7105 xpos
/= GRID_SCROLL_LINE_X
;
7107 ypos
/= GRID_SCROLL_LINE_Y
;
7108 Scroll( xpos
, ypos
);
7116 // ------ Grid cursor movement functions
7119 bool wxGrid::MoveCursorUp( bool expandSelection
)
7121 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7122 m_currentCellCoords
.GetRow() >= 0 )
7124 if ( expandSelection
)
7126 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7127 m_selectingKeyboard
= m_currentCellCoords
;
7128 if ( m_selectingKeyboard
.GetRow() > 0 )
7130 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() - 1 );
7131 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7132 m_selectingKeyboard
.GetCol() );
7133 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7136 else if ( m_currentCellCoords
.GetRow() > 0 )
7139 MakeCellVisible( m_currentCellCoords
.GetRow() - 1,
7140 m_currentCellCoords
.GetCol() );
7141 SetCurrentCell( m_currentCellCoords
.GetRow() - 1,
7142 m_currentCellCoords
.GetCol() );
7153 bool wxGrid::MoveCursorDown( bool expandSelection
)
7155 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7156 m_currentCellCoords
.GetRow() < m_numRows
)
7158 if ( expandSelection
)
7160 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7161 m_selectingKeyboard
= m_currentCellCoords
;
7162 if ( m_selectingKeyboard
.GetRow() < m_numRows
-1 )
7164 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() + 1 );
7165 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7166 m_selectingKeyboard
.GetCol() );
7167 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7170 else if ( m_currentCellCoords
.GetRow() < m_numRows
- 1 )
7173 MakeCellVisible( m_currentCellCoords
.GetRow() + 1,
7174 m_currentCellCoords
.GetCol() );
7175 SetCurrentCell( m_currentCellCoords
.GetRow() + 1,
7176 m_currentCellCoords
.GetCol() );
7187 bool wxGrid::MoveCursorLeft( bool expandSelection
)
7189 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7190 m_currentCellCoords
.GetCol() >= 0 )
7192 if ( expandSelection
)
7194 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7195 m_selectingKeyboard
= m_currentCellCoords
;
7196 if ( m_selectingKeyboard
.GetCol() > 0 )
7198 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() - 1 );
7199 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7200 m_selectingKeyboard
.GetCol() );
7201 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7204 else if ( m_currentCellCoords
.GetCol() > 0 )
7207 MakeCellVisible( m_currentCellCoords
.GetRow(),
7208 m_currentCellCoords
.GetCol() - 1 );
7209 SetCurrentCell( m_currentCellCoords
.GetRow(),
7210 m_currentCellCoords
.GetCol() - 1 );
7221 bool wxGrid::MoveCursorRight( bool expandSelection
)
7223 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
7224 m_currentCellCoords
.GetCol() < m_numCols
)
7226 if ( expandSelection
)
7228 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
7229 m_selectingKeyboard
= m_currentCellCoords
;
7230 if ( m_selectingKeyboard
.GetCol() < m_numCols
- 1 )
7232 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() + 1 );
7233 MakeCellVisible( m_selectingKeyboard
.GetRow(),
7234 m_selectingKeyboard
.GetCol() );
7235 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7238 else if ( m_currentCellCoords
.GetCol() < m_numCols
- 1 )
7241 MakeCellVisible( m_currentCellCoords
.GetRow(),
7242 m_currentCellCoords
.GetCol() + 1 );
7243 SetCurrentCell( m_currentCellCoords
.GetRow(),
7244 m_currentCellCoords
.GetCol() + 1 );
7255 bool wxGrid::MovePageUp()
7257 if ( m_currentCellCoords
== wxGridNoCellCoords
) return FALSE
;
7259 int row
= m_currentCellCoords
.GetRow();
7263 m_gridWin
->GetClientSize( &cw
, &ch
);
7265 int y
= GetRowTop(row
);
7266 int newRow
= YToRow( y
- ch
+ 1 );
7271 else if ( newRow
== row
)
7276 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
7277 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
7285 bool wxGrid::MovePageDown()
7287 if ( m_currentCellCoords
== wxGridNoCellCoords
) return FALSE
;
7289 int row
= m_currentCellCoords
.GetRow();
7290 if ( row
< m_numRows
)
7293 m_gridWin
->GetClientSize( &cw
, &ch
);
7295 int y
= GetRowTop(row
);
7296 int newRow
= YToRow( y
+ ch
);
7299 newRow
= m_numRows
- 1;
7301 else if ( newRow
== row
)
7306 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
7307 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
7315 bool wxGrid::MoveCursorUpBlock( bool expandSelection
)
7318 m_currentCellCoords
!= wxGridNoCellCoords
&&
7319 m_currentCellCoords
.GetRow() > 0 )
7321 int row
= m_currentCellCoords
.GetRow();
7322 int col
= m_currentCellCoords
.GetCol();
7324 if ( m_table
->IsEmptyCell(row
, col
) )
7326 // starting in an empty cell: find the next block of
7332 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7335 else if ( m_table
->IsEmptyCell(row
-1, col
) )
7337 // starting at the top of a block: find the next block
7343 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7348 // starting within a block: find the top of the block
7353 if ( m_table
->IsEmptyCell(row
, col
) )
7361 MakeCellVisible( row
, col
);
7362 if ( expandSelection
)
7364 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
7365 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7370 SetCurrentCell( row
, col
);
7378 bool wxGrid::MoveCursorDownBlock( bool expandSelection
)
7381 m_currentCellCoords
!= wxGridNoCellCoords
&&
7382 m_currentCellCoords
.GetRow() < m_numRows
-1 )
7384 int row
= m_currentCellCoords
.GetRow();
7385 int col
= m_currentCellCoords
.GetCol();
7387 if ( m_table
->IsEmptyCell(row
, col
) )
7389 // starting in an empty cell: find the next block of
7392 while ( row
< m_numRows
-1 )
7395 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7398 else if ( m_table
->IsEmptyCell(row
+1, col
) )
7400 // starting at the bottom of a block: find the next block
7403 while ( row
< m_numRows
-1 )
7406 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7411 // starting within a block: find the bottom of the block
7413 while ( row
< m_numRows
-1 )
7416 if ( m_table
->IsEmptyCell(row
, col
) )
7424 MakeCellVisible( row
, col
);
7425 if ( expandSelection
)
7427 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
7428 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7433 SetCurrentCell( row
, col
);
7442 bool wxGrid::MoveCursorLeftBlock( bool expandSelection
)
7445 m_currentCellCoords
!= wxGridNoCellCoords
&&
7446 m_currentCellCoords
.GetCol() > 0 )
7448 int row
= m_currentCellCoords
.GetRow();
7449 int col
= m_currentCellCoords
.GetCol();
7451 if ( m_table
->IsEmptyCell(row
, col
) )
7453 // starting in an empty cell: find the next block of
7459 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7462 else if ( m_table
->IsEmptyCell(row
, col
-1) )
7464 // starting at the left of a block: find the next block
7470 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7475 // starting within a block: find the left of the block
7480 if ( m_table
->IsEmptyCell(row
, col
) )
7488 MakeCellVisible( row
, col
);
7489 if ( expandSelection
)
7491 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
7492 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7497 SetCurrentCell( row
, col
);
7506 bool wxGrid::MoveCursorRightBlock( bool expandSelection
)
7509 m_currentCellCoords
!= wxGridNoCellCoords
&&
7510 m_currentCellCoords
.GetCol() < m_numCols
-1 )
7512 int row
= m_currentCellCoords
.GetRow();
7513 int col
= m_currentCellCoords
.GetCol();
7515 if ( m_table
->IsEmptyCell(row
, col
) )
7517 // starting in an empty cell: find the next block of
7520 while ( col
< m_numCols
-1 )
7523 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7526 else if ( m_table
->IsEmptyCell(row
, col
+1) )
7528 // starting at the right of a block: find the next block
7531 while ( col
< m_numCols
-1 )
7534 if ( !(m_table
->IsEmptyCell(row
, col
)) ) break;
7539 // starting within a block: find the right of the block
7541 while ( col
< m_numCols
-1 )
7544 if ( m_table
->IsEmptyCell(row
, col
) )
7552 MakeCellVisible( row
, col
);
7553 if ( expandSelection
)
7555 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
7556 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
7561 SetCurrentCell( row
, col
);
7573 // ------ Label values and formatting
7576 void wxGrid::GetRowLabelAlignment( int *horiz
, int *vert
)
7578 *horiz
= m_rowLabelHorizAlign
;
7579 *vert
= m_rowLabelVertAlign
;
7582 void wxGrid::GetColLabelAlignment( int *horiz
, int *vert
)
7584 *horiz
= m_colLabelHorizAlign
;
7585 *vert
= m_colLabelVertAlign
;
7588 wxString
wxGrid::GetRowLabelValue( int row
)
7592 return m_table
->GetRowLabelValue( row
);
7602 wxString
wxGrid::GetColLabelValue( int col
)
7606 return m_table
->GetColLabelValue( col
);
7617 void wxGrid::SetRowLabelSize( int width
)
7619 width
= wxMax( width
, 0 );
7620 if ( width
!= m_rowLabelWidth
)
7624 m_rowLabelWin
->Show( FALSE
);
7625 m_cornerLabelWin
->Show( FALSE
);
7627 else if ( m_rowLabelWidth
== 0 )
7629 m_rowLabelWin
->Show( TRUE
);
7630 if ( m_colLabelHeight
> 0 ) m_cornerLabelWin
->Show( TRUE
);
7633 m_rowLabelWidth
= width
;
7640 void wxGrid::SetColLabelSize( int height
)
7642 height
= wxMax( height
, 0 );
7643 if ( height
!= m_colLabelHeight
)
7647 m_colLabelWin
->Show( FALSE
);
7648 m_cornerLabelWin
->Show( FALSE
);
7650 else if ( m_colLabelHeight
== 0 )
7652 m_colLabelWin
->Show( TRUE
);
7653 if ( m_rowLabelWidth
> 0 ) m_cornerLabelWin
->Show( TRUE
);
7656 m_colLabelHeight
= height
;
7663 void wxGrid::SetLabelBackgroundColour( const wxColour
& colour
)
7665 if ( m_labelBackgroundColour
!= colour
)
7667 m_labelBackgroundColour
= colour
;
7668 m_rowLabelWin
->SetBackgroundColour( colour
);
7669 m_colLabelWin
->SetBackgroundColour( colour
);
7670 m_cornerLabelWin
->SetBackgroundColour( colour
);
7672 if ( !GetBatchCount() )
7674 m_rowLabelWin
->Refresh();
7675 m_colLabelWin
->Refresh();
7676 m_cornerLabelWin
->Refresh();
7681 void wxGrid::SetLabelTextColour( const wxColour
& colour
)
7683 if ( m_labelTextColour
!= colour
)
7685 m_labelTextColour
= colour
;
7686 if ( !GetBatchCount() )
7688 m_rowLabelWin
->Refresh();
7689 m_colLabelWin
->Refresh();
7694 void wxGrid::SetLabelFont( const wxFont
& font
)
7697 if ( !GetBatchCount() )
7699 m_rowLabelWin
->Refresh();
7700 m_colLabelWin
->Refresh();
7704 void wxGrid::SetRowLabelAlignment( int horiz
, int vert
)
7706 // allow old (incorrect) defs to be used
7709 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
7710 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
7711 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
7716 case wxTOP
: vert
= wxALIGN_TOP
; break;
7717 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
7718 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
7721 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
7723 m_rowLabelHorizAlign
= horiz
;
7726 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
7728 m_rowLabelVertAlign
= vert
;
7731 if ( !GetBatchCount() )
7733 m_rowLabelWin
->Refresh();
7737 void wxGrid::SetColLabelAlignment( int horiz
, int vert
)
7739 // allow old (incorrect) defs to be used
7742 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
7743 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
7744 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
7749 case wxTOP
: vert
= wxALIGN_TOP
; break;
7750 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
7751 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
7754 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
7756 m_colLabelHorizAlign
= horiz
;
7759 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
7761 m_colLabelVertAlign
= vert
;
7764 if ( !GetBatchCount() )
7766 m_colLabelWin
->Refresh();
7770 void wxGrid::SetRowLabelValue( int row
, const wxString
& s
)
7774 m_table
->SetRowLabelValue( row
, s
);
7775 if ( !GetBatchCount() )
7777 wxRect rect
= CellToRect( row
, 0);
7778 if ( rect
.height
> 0 )
7780 CalcScrolledPosition(0, rect
.y
, &rect
.x
, &rect
.y
);
7782 rect
.width
= m_rowLabelWidth
;
7783 m_rowLabelWin
->Refresh( TRUE
, &rect
);
7789 void wxGrid::SetColLabelValue( int col
, const wxString
& s
)
7793 m_table
->SetColLabelValue( col
, s
);
7794 if ( !GetBatchCount() )
7796 wxRect rect
= CellToRect( 0, col
);
7797 if ( rect
.width
> 0 )
7799 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &rect
.y
);
7801 rect
.height
= m_colLabelHeight
;
7802 m_colLabelWin
->Refresh( TRUE
, &rect
);
7808 void wxGrid::SetGridLineColour( const wxColour
& colour
)
7810 if ( m_gridLineColour
!= colour
)
7812 m_gridLineColour
= colour
;
7814 wxClientDC
dc( m_gridWin
);
7816 DrawAllGridLines( dc
, wxRegion() );
7821 void wxGrid::SetCellHighlightColour( const wxColour
& colour
)
7823 if ( m_cellHighlightColour
!= colour
)
7825 m_cellHighlightColour
= colour
;
7827 wxClientDC
dc( m_gridWin
);
7829 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
7830 DrawCellHighlight(dc
, attr
);
7835 void wxGrid::SetCellHighlightPenWidth(int width
)
7837 if (m_cellHighlightPenWidth
!= width
) {
7838 m_cellHighlightPenWidth
= width
;
7840 // Just redrawing the cell highlight is not enough since that won't
7841 // make any visible change if the the thickness is getting smaller.
7842 int row
= m_currentCellCoords
.GetRow();
7843 int col
= m_currentCellCoords
.GetCol();
7844 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7846 wxRect rect
= CellToRect(row
, col
);
7847 m_gridWin
->Refresh(TRUE
, &rect
);
7851 void wxGrid::SetCellHighlightROPenWidth(int width
)
7853 if (m_cellHighlightROPenWidth
!= width
) {
7854 m_cellHighlightROPenWidth
= width
;
7856 // Just redrawing the cell highlight is not enough since that won't
7857 // make any visible change if the the thickness is getting smaller.
7858 int row
= m_currentCellCoords
.GetRow();
7859 int col
= m_currentCellCoords
.GetCol();
7860 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7862 wxRect rect
= CellToRect(row
, col
);
7863 m_gridWin
->Refresh(TRUE
, &rect
);
7867 void wxGrid::EnableGridLines( bool enable
)
7869 if ( enable
!= m_gridLinesEnabled
)
7871 m_gridLinesEnabled
= enable
;
7873 if ( !GetBatchCount() )
7877 wxClientDC
dc( m_gridWin
);
7879 DrawAllGridLines( dc
, wxRegion() );
7883 m_gridWin
->Refresh();
7890 int wxGrid::GetDefaultRowSize()
7892 return m_defaultRowHeight
;
7895 int wxGrid::GetRowSize( int row
)
7897 wxCHECK_MSG( row
>= 0 && row
< m_numRows
, 0, _T("invalid row index") );
7899 return GetRowHeight(row
);
7902 int wxGrid::GetDefaultColSize()
7904 return m_defaultColWidth
;
7907 int wxGrid::GetColSize( int col
)
7909 wxCHECK_MSG( col
>= 0 && col
< m_numCols
, 0, _T("invalid column index") );
7911 return GetColWidth(col
);
7914 // ============================================================================
7915 // access to the grid attributes: each of them has a default value in the grid
7916 // itself and may be overidden on a per-cell basis
7917 // ============================================================================
7919 // ----------------------------------------------------------------------------
7920 // setting default attributes
7921 // ----------------------------------------------------------------------------
7923 void wxGrid::SetDefaultCellBackgroundColour( const wxColour
& col
)
7925 m_defaultCellAttr
->SetBackgroundColour(col
);
7927 m_gridWin
->SetBackgroundColour(col
);
7931 void wxGrid::SetDefaultCellTextColour( const wxColour
& col
)
7933 m_defaultCellAttr
->SetTextColour(col
);
7936 void wxGrid::SetDefaultCellAlignment( int horiz
, int vert
)
7938 m_defaultCellAttr
->SetAlignment(horiz
, vert
);
7941 void wxGrid::SetDefaultCellFont( const wxFont
& font
)
7943 m_defaultCellAttr
->SetFont(font
);
7946 void wxGrid::SetDefaultRenderer(wxGridCellRenderer
*renderer
)
7948 m_defaultCellAttr
->SetRenderer(renderer
);
7951 void wxGrid::SetDefaultEditor(wxGridCellEditor
*editor
)
7953 m_defaultCellAttr
->SetEditor(editor
);
7956 // ----------------------------------------------------------------------------
7957 // access to the default attrbiutes
7958 // ----------------------------------------------------------------------------
7960 wxColour
wxGrid::GetDefaultCellBackgroundColour()
7962 return m_defaultCellAttr
->GetBackgroundColour();
7965 wxColour
wxGrid::GetDefaultCellTextColour()
7967 return m_defaultCellAttr
->GetTextColour();
7970 wxFont
wxGrid::GetDefaultCellFont()
7972 return m_defaultCellAttr
->GetFont();
7975 void wxGrid::GetDefaultCellAlignment( int *horiz
, int *vert
)
7977 m_defaultCellAttr
->GetAlignment(horiz
, vert
);
7980 wxGridCellRenderer
*wxGrid::GetDefaultRenderer() const
7982 return m_defaultCellAttr
->GetRenderer(NULL
, 0, 0);
7985 wxGridCellEditor
*wxGrid::GetDefaultEditor() const
7987 return m_defaultCellAttr
->GetEditor(NULL
,0,0);
7990 // ----------------------------------------------------------------------------
7991 // access to cell attributes
7992 // ----------------------------------------------------------------------------
7994 wxColour
wxGrid::GetCellBackgroundColour(int row
, int col
)
7996 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7997 wxColour colour
= attr
->GetBackgroundColour();
8002 wxColour
wxGrid::GetCellTextColour( int row
, int col
)
8004 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8005 wxColour colour
= attr
->GetTextColour();
8010 wxFont
wxGrid::GetCellFont( int row
, int col
)
8012 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8013 wxFont font
= attr
->GetFont();
8018 void wxGrid::GetCellAlignment( int row
, int col
, int *horiz
, int *vert
)
8020 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8021 attr
->GetAlignment(horiz
, vert
);
8025 wxGridCellRenderer
* wxGrid::GetCellRenderer(int row
, int col
)
8027 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8028 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
8034 wxGridCellEditor
* wxGrid::GetCellEditor(int row
, int col
)
8036 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8037 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
8043 bool wxGrid::IsReadOnly(int row
, int col
) const
8045 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8046 bool isReadOnly
= attr
->IsReadOnly();
8051 // ----------------------------------------------------------------------------
8052 // attribute support: cache, automatic provider creation, ...
8053 // ----------------------------------------------------------------------------
8055 bool wxGrid::CanHaveAttributes()
8062 return m_table
->CanHaveAttributes();
8065 void wxGrid::ClearAttrCache()
8067 if ( m_attrCache
.row
!= -1 )
8069 wxSafeDecRef(m_attrCache
.attr
);
8070 m_attrCache
.attr
= NULL
;
8071 m_attrCache
.row
= -1;
8075 void wxGrid::CacheAttr(int row
, int col
, wxGridCellAttr
*attr
) const
8077 wxGrid
*self
= (wxGrid
*)this; // const_cast
8079 self
->ClearAttrCache();
8080 self
->m_attrCache
.row
= row
;
8081 self
->m_attrCache
.col
= col
;
8082 self
->m_attrCache
.attr
= attr
;
8086 bool wxGrid::LookupAttr(int row
, int col
, wxGridCellAttr
**attr
) const
8088 if ( row
== m_attrCache
.row
&& col
== m_attrCache
.col
)
8090 *attr
= m_attrCache
.attr
;
8091 wxSafeIncRef(m_attrCache
.attr
);
8093 #ifdef DEBUG_ATTR_CACHE
8094 gs_nAttrCacheHits
++;
8101 #ifdef DEBUG_ATTR_CACHE
8102 gs_nAttrCacheMisses
++;
8108 wxGridCellAttr
*wxGrid::GetCellAttr(int row
, int col
) const
8110 wxGridCellAttr
*attr
;
8111 if ( !LookupAttr(row
, col
, &attr
) )
8113 attr
= m_table
? m_table
->GetAttr(row
, col
, wxGridCellAttr::Any
) : (wxGridCellAttr
*)NULL
;
8114 CacheAttr(row
, col
, attr
);
8118 attr
->SetDefAttr(m_defaultCellAttr
);
8122 attr
= m_defaultCellAttr
;
8129 wxGridCellAttr
*wxGrid::GetOrCreateCellAttr(int row
, int col
) const
8131 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
8133 wxCHECK_MSG( m_table
, attr
,
8134 _T("we may only be called if CanHaveAttributes() returned TRUE and then m_table should be !NULL") );
8136 attr
= m_table
->GetAttr(row
, col
, wxGridCellAttr::Cell
);
8139 attr
= new wxGridCellAttr(m_defaultCellAttr
);
8141 // artificially inc the ref count to match DecRef() in caller
8143 m_table
->SetAttr(attr
, row
, col
);
8149 // ----------------------------------------------------------------------------
8150 // setting column attributes (wrappers around SetColAttr)
8151 // ----------------------------------------------------------------------------
8153 void wxGrid::SetColFormatBool(int col
)
8155 SetColFormatCustom(col
, wxGRID_VALUE_BOOL
);
8158 void wxGrid::SetColFormatNumber(int col
)
8160 SetColFormatCustom(col
, wxGRID_VALUE_NUMBER
);
8163 void wxGrid::SetColFormatFloat(int col
, int width
, int precision
)
8165 wxString typeName
= wxGRID_VALUE_FLOAT
;
8166 if ( (width
!= -1) || (precision
!= -1) )
8168 typeName
<< _T(':') << width
<< _T(',') << precision
;
8171 SetColFormatCustom(col
, typeName
);
8174 void wxGrid::SetColFormatCustom(int col
, const wxString
& typeName
)
8176 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
8178 attr
= m_table
->GetAttr(-1, col
, wxGridCellAttr::Col
);
8180 attr
= new wxGridCellAttr
;
8181 wxGridCellRenderer
*renderer
= GetDefaultRendererForType(typeName
);
8182 attr
->SetRenderer(renderer
);
8184 SetColAttr(col
, attr
);
8188 // ----------------------------------------------------------------------------
8189 // setting cell attributes: this is forwarded to the table
8190 // ----------------------------------------------------------------------------
8192 void wxGrid::SetRowAttr(int row
, wxGridCellAttr
*attr
)
8194 if ( CanHaveAttributes() )
8196 m_table
->SetRowAttr(attr
, row
);
8205 void wxGrid::SetColAttr(int col
, wxGridCellAttr
*attr
)
8207 if ( CanHaveAttributes() )
8209 m_table
->SetColAttr(attr
, col
);
8218 void wxGrid::SetCellBackgroundColour( int row
, int col
, const wxColour
& colour
)
8220 if ( CanHaveAttributes() )
8222 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
8223 attr
->SetBackgroundColour(colour
);
8228 void wxGrid::SetCellTextColour( int row
, int col
, const wxColour
& colour
)
8230 if ( CanHaveAttributes() )
8232 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
8233 attr
->SetTextColour(colour
);
8238 void wxGrid::SetCellFont( int row
, int col
, const wxFont
& font
)
8240 if ( CanHaveAttributes() )
8242 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
8243 attr
->SetFont(font
);
8248 void wxGrid::SetCellAlignment( int row
, int col
, int horiz
, int vert
)
8250 if ( CanHaveAttributes() )
8252 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
8253 attr
->SetAlignment(horiz
, vert
);
8258 void wxGrid::SetCellRenderer(int row
, int col
, wxGridCellRenderer
*renderer
)
8260 if ( CanHaveAttributes() )
8262 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
8263 attr
->SetRenderer(renderer
);
8268 void wxGrid::SetCellEditor(int row
, int col
, wxGridCellEditor
* editor
)
8270 if ( CanHaveAttributes() )
8272 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
8273 attr
->SetEditor(editor
);
8278 void wxGrid::SetReadOnly(int row
, int col
, bool isReadOnly
)
8280 if ( CanHaveAttributes() )
8282 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
8283 attr
->SetReadOnly(isReadOnly
);
8288 // ----------------------------------------------------------------------------
8289 // Data type registration
8290 // ----------------------------------------------------------------------------
8292 void wxGrid::RegisterDataType(const wxString
& typeName
,
8293 wxGridCellRenderer
* renderer
,
8294 wxGridCellEditor
* editor
)
8296 m_typeRegistry
->RegisterDataType(typeName
, renderer
, editor
);
8300 wxGridCellEditor
* wxGrid::GetDefaultEditorForCell(int row
, int col
) const
8302 wxString typeName
= m_table
->GetTypeName(row
, col
);
8303 return GetDefaultEditorForType(typeName
);
8306 wxGridCellRenderer
* wxGrid::GetDefaultRendererForCell(int row
, int col
) const
8308 wxString typeName
= m_table
->GetTypeName(row
, col
);
8309 return GetDefaultRendererForType(typeName
);
8313 wxGrid::GetDefaultEditorForType(const wxString
& typeName
) const
8315 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
8316 if ( index
== wxNOT_FOUND
)
8318 wxFAIL_MSG(wxT("Unknown data type name"));
8323 return m_typeRegistry
->GetEditor(index
);
8327 wxGrid::GetDefaultRendererForType(const wxString
& typeName
) const
8329 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
8330 if ( index
== wxNOT_FOUND
)
8332 wxFAIL_MSG(wxT("Unknown data type name"));
8337 return m_typeRegistry
->GetRenderer(index
);
8341 // ----------------------------------------------------------------------------
8343 // ----------------------------------------------------------------------------
8345 void wxGrid::EnableDragRowSize( bool enable
)
8347 m_canDragRowSize
= enable
;
8351 void wxGrid::EnableDragColSize( bool enable
)
8353 m_canDragColSize
= enable
;
8356 void wxGrid::EnableDragGridSize( bool enable
)
8358 m_canDragGridSize
= enable
;
8362 void wxGrid::SetDefaultRowSize( int height
, bool resizeExistingRows
)
8364 m_defaultRowHeight
= wxMax( height
, WXGRID_MIN_ROW_HEIGHT
);
8366 if ( resizeExistingRows
)
8368 // since we are resizing all rows to the default row size,
8369 // we can simply clear the row heights and row bottoms
8370 // arrays (which also allows us to take advantage of
8371 // some speed optimisations)
8372 m_rowHeights
.Empty();
8373 m_rowBottoms
.Empty();
8374 if ( !GetBatchCount() )
8379 void wxGrid::SetRowSize( int row
, int height
)
8381 wxCHECK_RET( row
>= 0 && row
< m_numRows
, _T("invalid row index") );
8383 if ( m_rowHeights
.IsEmpty() )
8385 // need to really create the array
8389 int h
= wxMax( 0, height
);
8390 int diff
= h
- m_rowHeights
[row
];
8392 m_rowHeights
[row
] = h
;
8394 for ( i
= row
; i
< m_numRows
; i
++ )
8396 m_rowBottoms
[i
] += diff
;
8398 if ( !GetBatchCount() )
8402 void wxGrid::SetDefaultColSize( int width
, bool resizeExistingCols
)
8404 m_defaultColWidth
= wxMax( width
, WXGRID_MIN_COL_WIDTH
);
8406 if ( resizeExistingCols
)
8408 // since we are resizing all columns to the default column size,
8409 // we can simply clear the col widths and col rights
8410 // arrays (which also allows us to take advantage of
8411 // some speed optimisations)
8412 m_colWidths
.Empty();
8413 m_colRights
.Empty();
8414 if ( !GetBatchCount() )
8419 void wxGrid::SetColSize( int col
, int width
)
8421 wxCHECK_RET( col
>= 0 && col
< m_numCols
, _T("invalid column index") );
8423 // should we check that it's bigger than GetColMinimalWidth(col) here?
8425 if ( m_colWidths
.IsEmpty() )
8427 // need to really create the array
8431 int w
= wxMax( 0, width
);
8432 int diff
= w
- m_colWidths
[col
];
8433 m_colWidths
[col
] = w
;
8436 for ( i
= col
; i
< m_numCols
; i
++ )
8438 m_colRights
[i
] += diff
;
8440 if ( !GetBatchCount() )
8445 void wxGrid::SetColMinimalWidth( int col
, int width
)
8447 m_colMinWidths
.Put(col
, width
);
8450 void wxGrid::SetRowMinimalHeight( int row
, int width
)
8452 m_rowMinHeights
.Put(row
, width
);
8455 int wxGrid::GetColMinimalWidth(int col
) const
8457 long value
= m_colMinWidths
.Get(col
);
8458 return value
!= wxNOT_FOUND
? (int)value
: WXGRID_MIN_COL_WIDTH
;
8461 int wxGrid::GetRowMinimalHeight(int row
) const
8463 long value
= m_rowMinHeights
.Get(row
);
8464 return value
!= wxNOT_FOUND
? (int)value
: WXGRID_MIN_ROW_HEIGHT
;
8467 // ----------------------------------------------------------------------------
8469 // ----------------------------------------------------------------------------
8471 void wxGrid::AutoSizeColOrRow( int colOrRow
, bool setAsMin
, bool column
)
8473 wxClientDC
dc(m_gridWin
);
8475 // init both of them to avoid compiler warnings, even if weo nly need one
8483 wxCoord extent
, extentMax
= 0;
8484 int max
= column
? m_numRows
: m_numCols
;
8485 for ( int rowOrCol
= 0; rowOrCol
< max
; rowOrCol
++ )
8492 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8493 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
8496 wxSize size
= renderer
->GetBestSize(*this, *attr
, dc
, row
, col
);
8497 extent
= column
? size
.x
: size
.y
;
8498 if ( extent
> extentMax
)
8509 // now also compare with the column label extent
8511 dc
.SetFont( GetLabelFont() );
8514 dc
.GetTextExtent( GetColLabelValue(col
), &w
, &h
);
8516 dc
.GetTextExtent( GetRowLabelValue(row
), &w
, &h
);
8518 extent
= column
? w
: h
;
8519 if ( extent
> extentMax
)
8526 // empty column - give default extent (notice that if extentMax is less
8527 // than default extent but != 0, it's ok)
8528 extentMax
= column
? m_defaultColWidth
: m_defaultRowHeight
;
8534 // leave some space around text
8545 SetColSize(col
, extentMax
);
8546 if ( !GetBatchCount() )
8549 m_gridWin
->GetClientSize( &cw
, &ch
);
8550 wxRect
rect ( CellToRect( 0, col
) );
8552 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
8553 rect
.width
= cw
- rect
.x
;
8554 rect
.height
= m_colLabelHeight
;
8555 m_colLabelWin
->Refresh( TRUE
, &rect
);
8560 SetRowSize(row
, extentMax
);
8561 if ( !GetBatchCount() )
8564 m_gridWin
->GetClientSize( &cw
, &ch
);
8565 wxRect
rect ( CellToRect( row
, 0 ) );
8567 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
8568 rect
.width
= m_rowLabelWidth
;
8569 rect
.height
= ch
- rect
.y
;
8570 m_rowLabelWin
->Refresh( TRUE
, &rect
);
8576 SetColMinimalWidth(col
, extentMax
);
8578 SetRowMinimalHeight(row
, extentMax
);
8582 int wxGrid::SetOrCalcColumnSizes(bool calcOnly
, bool setAsMin
)
8584 int width
= m_rowLabelWidth
;
8589 for ( int col
= 0; col
< m_numCols
; col
++ )
8593 AutoSizeColumn(col
, setAsMin
);
8596 width
+= GetColWidth(col
);
8605 int wxGrid::SetOrCalcRowSizes(bool calcOnly
, bool setAsMin
)
8607 int height
= m_colLabelHeight
;
8612 for ( int row
= 0; row
< m_numRows
; row
++ )
8616 AutoSizeRow(row
, setAsMin
);
8619 height
+= GetRowHeight(row
);
8628 void wxGrid::AutoSize()
8632 wxSize
size(SetOrCalcColumnSizes(FALSE
), SetOrCalcRowSizes(FALSE
));
8634 // round up the size to a multiple of scroll step - this ensures that we
8635 // won't get the scrollbars if we're sized exactly to this width
8636 wxSize
sizeFit(GetScrollX(size
.x
) * GRID_SCROLL_LINE_X
,
8637 GetScrollY(size
.y
) * GRID_SCROLL_LINE_Y
);
8639 // distribute the extra space between teh columns/rows to avoid having
8640 // extra white space
8641 wxCoord diff
= sizeFit
.x
- size
.x
;
8644 // try to resize the columns uniformly
8645 wxCoord diffPerCol
= diff
/ m_numCols
;
8648 for ( int col
= 0; col
< m_numCols
; col
++ )
8650 SetColSize(col
, GetColWidth(col
) + diffPerCol
);
8654 // add remaining amount to the last columns
8655 diff
-= diffPerCol
* m_numCols
;
8658 for ( int col
= m_numCols
- 1; col
>= m_numCols
- diff
; col
-- )
8660 SetColSize(col
, GetColWidth(col
) + 1);
8666 diff
= sizeFit
.y
- size
.y
;
8669 // try to resize the columns uniformly
8670 wxCoord diffPerRow
= diff
/ m_numRows
;
8673 for ( int row
= 0; row
< m_numRows
; row
++ )
8675 SetRowSize(row
, GetRowHeight(row
) + diffPerRow
);
8679 // add remaining amount to the last rows
8680 diff
-= diffPerRow
* m_numRows
;
8683 for ( int row
= m_numRows
- 1; row
>= m_numRows
- diff
; row
-- )
8685 SetRowSize(row
, GetRowHeight(row
) + 1);
8692 SetClientSize(sizeFit
);
8695 wxSize
wxGrid::DoGetBestSize() const
8697 // don't set sizes, only calculate them
8698 wxGrid
*self
= (wxGrid
*)this; // const_cast
8700 return wxSize(self
->SetOrCalcColumnSizes(TRUE
),
8701 self
->SetOrCalcRowSizes(TRUE
));
8710 wxPen
& wxGrid::GetDividerPen() const
8715 // ----------------------------------------------------------------------------
8716 // cell value accessor functions
8717 // ----------------------------------------------------------------------------
8719 void wxGrid::SetCellValue( int row
, int col
, const wxString
& s
)
8723 m_table
->SetValue( row
, col
, s
);
8724 if ( !GetBatchCount() )
8726 wxClientDC
dc( m_gridWin
);
8728 DrawCell( dc
, wxGridCellCoords(row
, col
) );
8731 if ( m_currentCellCoords
.GetRow() == row
&&
8732 m_currentCellCoords
.GetCol() == col
&&
8733 IsCellEditControlShown())
8734 // Note: If we are using IsCellEditControlEnabled,
8735 // this interacts badly with calling SetCellValue from
8736 // an EVT_GRID_CELL_CHANGE handler.
8738 HideCellEditControl();
8739 ShowCellEditControl(); // will reread data from table
8746 // ------ Block, row and col selection
8749 void wxGrid::SelectRow( int row
, bool addToSelected
)
8751 if ( IsSelection() && !addToSelected
)
8754 m_selection
->SelectRow( row
, FALSE
, addToSelected
);
8758 void wxGrid::SelectCol( int col
, bool addToSelected
)
8760 if ( IsSelection() && !addToSelected
)
8763 m_selection
->SelectCol( col
, FALSE
, addToSelected
);
8767 void wxGrid::SelectBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
,
8768 bool addToSelected
)
8770 if ( IsSelection() && !addToSelected
)
8773 m_selection
->SelectBlock( topRow
, leftCol
, bottomRow
, rightCol
,
8774 FALSE
, addToSelected
);
8778 void wxGrid::SelectAll()
8780 if ( m_numRows
> 0 && m_numCols
> 0 )
8781 m_selection
->SelectBlock( 0, 0, m_numRows
-1, m_numCols
-1 );
8785 // ------ Cell, row and col deselection
8788 void wxGrid::DeselectRow( int row
)
8790 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
8792 if ( m_selection
->IsInSelection(row
, 0 ) )
8793 m_selection
->ToggleCellSelection( row
, 0);
8797 int nCols
= GetNumberCols();
8798 for ( int i
= 0; i
< nCols
; i
++ )
8800 if ( m_selection
->IsInSelection(row
, i
) )
8801 m_selection
->ToggleCellSelection( row
, i
);
8806 void wxGrid::DeselectCol( int col
)
8808 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
8810 if ( m_selection
->IsInSelection(0, col
) )
8811 m_selection
->ToggleCellSelection( 0, col
);
8815 int nRows
= GetNumberRows();
8816 for ( int i
= 0; i
< nRows
; i
++ )
8818 if ( m_selection
->IsInSelection(i
, col
) )
8819 m_selection
->ToggleCellSelection(i
, col
);
8824 void wxGrid::DeselectCell( int row
, int col
)
8826 if ( m_selection
->IsInSelection(row
, col
) )
8827 m_selection
->ToggleCellSelection(row
, col
);
8830 bool wxGrid::IsSelection()
8832 return ( m_selection
->IsSelection() ||
8833 ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
8834 m_selectingBottomRight
!= wxGridNoCellCoords
) );
8837 bool wxGrid::IsInSelection( int row
, int col
)
8839 return ( m_selection
->IsInSelection( row
, col
) ||
8840 ( row
>= m_selectingTopLeft
.GetRow() &&
8841 col
>= m_selectingTopLeft
.GetCol() &&
8842 row
<= m_selectingBottomRight
.GetRow() &&
8843 col
<= m_selectingBottomRight
.GetCol() ) );
8846 void wxGrid::ClearSelection()
8848 m_selectingTopLeft
= wxGridNoCellCoords
;
8849 m_selectingBottomRight
= wxGridNoCellCoords
;
8850 m_selection
->ClearSelection();
8854 // This function returns the rectangle that encloses the given block
8855 // in device coords clipped to the client size of the grid window.
8857 wxRect
wxGrid::BlockToDeviceRect( const wxGridCellCoords
&topLeft
,
8858 const wxGridCellCoords
&bottomRight
)
8860 wxRect
rect( wxGridNoCellRect
);
8863 cellRect
= CellToRect( topLeft
);
8864 if ( cellRect
!= wxGridNoCellRect
)
8870 rect
= wxRect( 0, 0, 0, 0 );
8873 cellRect
= CellToRect( bottomRight
);
8874 if ( cellRect
!= wxGridNoCellRect
)
8880 return wxGridNoCellRect
;
8883 // convert to scrolled coords
8885 int left
, top
, right
, bottom
;
8886 CalcScrolledPosition( rect
.GetLeft(), rect
.GetTop(), &left
, &top
);
8887 CalcScrolledPosition( rect
.GetRight(), rect
.GetBottom(), &right
, &bottom
);
8890 m_gridWin
->GetClientSize( &cw
, &ch
);
8892 if (right
< 0 || bottom
< 0 || left
> cw
|| top
> ch
)
8893 return wxRect( 0, 0, 0, 0);
8895 rect
.SetLeft( wxMax(0, left
) );
8896 rect
.SetTop( wxMax(0, top
) );
8897 rect
.SetRight( wxMin(cw
, right
) );
8898 rect
.SetBottom( wxMin(ch
, bottom
) );
8906 // ------ Grid event classes
8909 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent
, wxNotifyEvent
)
8911 wxGridEvent::wxGridEvent( int id
, wxEventType type
, wxObject
* obj
,
8912 int row
, int col
, int x
, int y
, bool sel
,
8913 bool control
, bool shift
, bool alt
, bool meta
)
8914 : wxNotifyEvent( type
, id
)
8921 m_control
= control
;
8926 SetEventObject(obj
);
8930 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent
, wxNotifyEvent
)
8932 wxGridSizeEvent::wxGridSizeEvent( int id
, wxEventType type
, wxObject
* obj
,
8933 int rowOrCol
, int x
, int y
,
8934 bool control
, bool shift
, bool alt
, bool meta
)
8935 : wxNotifyEvent( type
, id
)
8937 m_rowOrCol
= rowOrCol
;
8940 m_control
= control
;
8945 SetEventObject(obj
);
8949 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent
, wxNotifyEvent
)
8951 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id
, wxEventType type
, wxObject
* obj
,
8952 const wxGridCellCoords
& topLeft
,
8953 const wxGridCellCoords
& bottomRight
,
8954 bool sel
, bool control
,
8955 bool shift
, bool alt
, bool meta
)
8956 : wxNotifyEvent( type
, id
)
8958 m_topLeft
= topLeft
;
8959 m_bottomRight
= bottomRight
;
8961 m_control
= control
;
8966 SetEventObject(obj
);
8970 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent
, wxCommandEvent
)
8972 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id
, wxEventType type
,
8973 wxObject
* obj
, int row
,
8974 int col
, wxControl
* ctrl
)
8975 : wxCommandEvent(type
, id
)
8977 SetEventObject(obj
);
8984 #endif // !wxUSE_NEW_GRID/wxUSE_NEW_GRID
8986 #endif // wxUSE_GRID