1 ///////////////////////////////////////////////////////////////////////////
2 // Name: src/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, Santiago Palacios
8 // Copyright: (c) Michael Bedward (mbedward@ozemail.com.au)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // For compilers that support precompilation, includes "wx/wx.h".
13 #include "wx/wxprec.h"
25 #include "wx/dcclient.h"
26 #include "wx/settings.h"
28 #include "wx/textctrl.h"
29 #include "wx/checkbox.h"
30 #include "wx/combobox.h"
31 #include "wx/valtext.h"
34 #include "wx/listbox.h"
37 #include "wx/textfile.h"
38 #include "wx/spinctrl.h"
39 #include "wx/tokenzr.h"
40 #include "wx/renderer.h"
42 #include "wx/generic/gridsel.h"
44 const wxChar wxGridNameStr
[] = wxT("grid");
46 #if defined(__WXMOTIF__)
47 #define WXUNUSED_MOTIF(identifier) WXUNUSED(identifier)
49 #define WXUNUSED_MOTIF(identifier) identifier
52 #if defined(__WXGTK__)
53 #define WXUNUSED_GTK(identifier) WXUNUSED(identifier)
55 #define WXUNUSED_GTK(identifier) identifier
58 // Required for wxIs... functions
61 // ----------------------------------------------------------------------------
63 // ----------------------------------------------------------------------------
65 WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridCellAttr
*, wxArrayAttrs
,
66 class WXDLLIMPEXP_ADV
);
68 struct wxGridCellWithAttr
70 wxGridCellWithAttr(int row
, int col
, wxGridCellAttr
*attr_
)
71 : coords(row
, col
), attr(attr_
)
80 wxGridCellCoords coords
;
84 // DECLARE_NO_COPY_CLASS(wxGridCellWithAttr)
85 // without rewriting the macros, which require a public copy constructor.
88 WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellWithAttr
, wxGridCellWithAttrArray
,
89 class WXDLLIMPEXP_ADV
);
91 #include "wx/arrimpl.cpp"
93 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray
)
94 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray
)
96 // ----------------------------------------------------------------------------
98 // ----------------------------------------------------------------------------
100 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK
)
101 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK
)
102 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK
)
103 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK
)
104 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_BEGIN_DRAG
)
105 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK
)
106 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK
)
107 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK
)
108 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK
)
109 DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE
)
110 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE
)
111 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_MOVE
)
112 DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT
)
113 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE
)
114 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL
)
115 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN
)
116 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN
)
117 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED
)
119 // ----------------------------------------------------------------------------
121 // ----------------------------------------------------------------------------
123 // common base class for various grid subwindows
124 class WXDLLIMPEXP_ADV wxGridSubwindow
: public wxWindow
127 wxGridSubwindow() { m_owner
= NULL
; }
128 wxGridSubwindow(wxGrid
*owner
,
132 int additionalStyle
= 0,
133 const wxString
& name
= wxPanelNameStr
)
134 : wxWindow(owner
, id
, pos
, size
,
135 wxWANTS_CHARS
| wxBORDER_NONE
| additionalStyle
,
141 wxGrid
*GetOwner() { return m_owner
; }
144 void OnMouseCaptureLost(wxMouseCaptureLostEvent
& event
);
148 DECLARE_EVENT_TABLE()
149 DECLARE_NO_COPY_CLASS(wxGridSubwindow
)
152 class WXDLLIMPEXP_ADV wxGridRowLabelWindow
: public wxGridSubwindow
155 wxGridRowLabelWindow() { }
156 wxGridRowLabelWindow( wxGrid
*parent
, wxWindowID id
,
157 const wxPoint
&pos
, const wxSize
&size
);
160 void OnPaint( wxPaintEvent
& event
);
161 void OnMouseEvent( wxMouseEvent
& event
);
162 void OnMouseWheel( wxMouseEvent
& event
);
163 void OnKeyDown( wxKeyEvent
& event
);
164 void OnKeyUp( wxKeyEvent
& );
165 void OnChar( wxKeyEvent
& );
167 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow
)
168 DECLARE_EVENT_TABLE()
169 DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow
)
173 class WXDLLIMPEXP_ADV wxGridColLabelWindow
: public wxGridSubwindow
176 wxGridColLabelWindow() { }
177 wxGridColLabelWindow( wxGrid
*parent
, wxWindowID id
,
178 const wxPoint
&pos
, const wxSize
&size
);
181 void OnPaint( wxPaintEvent
& event
);
182 void OnMouseEvent( wxMouseEvent
& event
);
183 void OnMouseWheel( wxMouseEvent
& event
);
184 void OnKeyDown( wxKeyEvent
& event
);
185 void OnKeyUp( wxKeyEvent
& );
186 void OnChar( wxKeyEvent
& );
188 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow
)
189 DECLARE_EVENT_TABLE()
190 DECLARE_NO_COPY_CLASS(wxGridColLabelWindow
)
194 class WXDLLIMPEXP_ADV wxGridCornerLabelWindow
: public wxGridSubwindow
197 wxGridCornerLabelWindow() { }
198 wxGridCornerLabelWindow( wxGrid
*parent
, wxWindowID id
,
199 const wxPoint
&pos
, const wxSize
&size
);
202 void OnMouseEvent( wxMouseEvent
& event
);
203 void OnMouseWheel( wxMouseEvent
& event
);
204 void OnKeyDown( wxKeyEvent
& event
);
205 void OnKeyUp( wxKeyEvent
& );
206 void OnChar( wxKeyEvent
& );
207 void OnPaint( wxPaintEvent
& event
);
209 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow
)
210 DECLARE_EVENT_TABLE()
211 DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow
)
214 class WXDLLIMPEXP_ADV wxGridWindow
: public wxGridSubwindow
219 m_rowLabelWin
= NULL
;
220 m_colLabelWin
= NULL
;
223 wxGridWindow( wxGrid
*parent
,
224 wxGridRowLabelWindow
*rowLblWin
,
225 wxGridColLabelWindow
*colLblWin
,
226 wxWindowID id
, const wxPoint
&pos
, const wxSize
&size
);
228 void ScrollWindow( int dx
, int dy
, const wxRect
*rect
);
231 wxGridRowLabelWindow
*m_rowLabelWin
;
232 wxGridColLabelWindow
*m_colLabelWin
;
234 void OnPaint( wxPaintEvent
&event
);
235 void OnMouseWheel( wxMouseEvent
& event
);
236 void OnMouseEvent( wxMouseEvent
& event
);
237 void OnKeyDown( wxKeyEvent
& );
238 void OnKeyUp( wxKeyEvent
& );
239 void OnChar( wxKeyEvent
& );
240 void OnEraseBackground( wxEraseEvent
& );
241 void OnFocus( wxFocusEvent
& );
243 DECLARE_DYNAMIC_CLASS(wxGridWindow
)
244 DECLARE_EVENT_TABLE()
245 DECLARE_NO_COPY_CLASS(wxGridWindow
)
249 class wxGridCellEditorEvtHandler
: public wxEvtHandler
252 wxGridCellEditorEvtHandler(wxGrid
* grid
, wxGridCellEditor
* editor
)
259 void OnKillFocus(wxFocusEvent
& event
);
260 void OnKeyDown(wxKeyEvent
& event
);
261 void OnChar(wxKeyEvent
& event
);
263 void SetInSetFocus(bool inSetFocus
) { m_inSetFocus
= inSetFocus
; }
267 wxGridCellEditor
*m_editor
;
269 // Work around the fact that a focus kill event can be sent to
270 // a combobox within a set focus event.
273 DECLARE_EVENT_TABLE()
274 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler
)
275 DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler
)
279 IMPLEMENT_ABSTRACT_CLASS(wxGridCellEditorEvtHandler
, wxEvtHandler
)
281 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler
, wxEvtHandler
)
282 EVT_KILL_FOCUS( wxGridCellEditorEvtHandler::OnKillFocus
)
283 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown
)
284 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar
)
288 // ----------------------------------------------------------------------------
289 // the internal data representation used by wxGridCellAttrProvider
290 // ----------------------------------------------------------------------------
292 // this class stores attributes set for cells
293 class WXDLLIMPEXP_ADV wxGridCellAttrData
296 void SetAttr(wxGridCellAttr
*attr
, int row
, int col
);
297 wxGridCellAttr
*GetAttr(int row
, int col
) const;
298 void UpdateAttrRows( size_t pos
, int numRows
);
299 void UpdateAttrCols( size_t pos
, int numCols
);
302 // searches for the attr for given cell, returns wxNOT_FOUND if not found
303 int FindIndex(int row
, int col
) const;
305 wxGridCellWithAttrArray m_attrs
;
308 // this class stores attributes set for rows or columns
309 class WXDLLIMPEXP_ADV wxGridRowOrColAttrData
312 // empty ctor to suppress warnings
313 wxGridRowOrColAttrData() {}
314 ~wxGridRowOrColAttrData();
316 void SetAttr(wxGridCellAttr
*attr
, int rowOrCol
);
317 wxGridCellAttr
*GetAttr(int rowOrCol
) const;
318 void UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
);
321 wxArrayInt m_rowsOrCols
;
322 wxArrayAttrs m_attrs
;
325 // NB: this is just a wrapper around 3 objects: one which stores cell
326 // attributes, and 2 others for row/col ones
327 class WXDLLIMPEXP_ADV wxGridCellAttrProviderData
330 wxGridCellAttrData m_cellAttrs
;
331 wxGridRowOrColAttrData m_rowAttrs
,
336 // ----------------------------------------------------------------------------
337 // data structures used for the data type registry
338 // ----------------------------------------------------------------------------
340 struct wxGridDataTypeInfo
342 wxGridDataTypeInfo(const wxString
& typeName
,
343 wxGridCellRenderer
* renderer
,
344 wxGridCellEditor
* editor
)
345 : m_typeName(typeName
), m_renderer(renderer
), m_editor(editor
)
348 ~wxGridDataTypeInfo()
350 wxSafeDecRef(m_renderer
);
351 wxSafeDecRef(m_editor
);
355 wxGridCellRenderer
* m_renderer
;
356 wxGridCellEditor
* m_editor
;
358 DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo
)
362 WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridDataTypeInfo
*, wxGridDataTypeInfoArray
,
363 class WXDLLIMPEXP_ADV
);
366 class WXDLLIMPEXP_ADV wxGridTypeRegistry
369 wxGridTypeRegistry() {}
370 ~wxGridTypeRegistry();
372 void RegisterDataType(const wxString
& typeName
,
373 wxGridCellRenderer
* renderer
,
374 wxGridCellEditor
* editor
);
376 // find one of already registered data types
377 int FindRegisteredDataType(const wxString
& typeName
);
379 // try to FindRegisteredDataType(), if this fails and typeName is one of
380 // standard typenames, register it and return its index
381 int FindDataType(const wxString
& typeName
);
383 // try to FindDataType(), if it fails see if it is not one of already
384 // registered data types with some params in which case clone the
385 // registered data type and set params for it
386 int FindOrCloneDataType(const wxString
& typeName
);
388 wxGridCellRenderer
* GetRenderer(int index
);
389 wxGridCellEditor
* GetEditor(int index
);
392 wxGridDataTypeInfoArray m_typeinfo
;
396 // ----------------------------------------------------------------------------
397 // conditional compilation
398 // ----------------------------------------------------------------------------
400 #ifndef WXGRID_DRAW_LINES
401 #define WXGRID_DRAW_LINES 1
404 // ----------------------------------------------------------------------------
406 // ----------------------------------------------------------------------------
408 //#define DEBUG_ATTR_CACHE
409 #ifdef DEBUG_ATTR_CACHE
410 static size_t gs_nAttrCacheHits
= 0;
411 static size_t gs_nAttrCacheMisses
= 0;
414 // ----------------------------------------------------------------------------
416 // ----------------------------------------------------------------------------
418 wxGridCellCoords
wxGridNoCellCoords( -1, -1 );
419 wxRect
wxGridNoCellRect( -1, -1, -1, -1 );
422 // TODO: this doesn't work at all, grid cells have different sizes and approx
423 // calculations don't work as because of the size mismatch scrollbars
424 // sometimes fail to be shown when they should be or vice versa
426 // The scroll bars may be a little flakey once in a while, but that is
427 // surely much less horrible than having scroll lines of only 1!!!
430 // Well, it's still seriously broken so it might be better but needs
433 static const size_t GRID_SCROLL_LINE_X
= 15; // 1;
434 static const size_t GRID_SCROLL_LINE_Y
= GRID_SCROLL_LINE_X
;
436 // the size of hash tables used a bit everywhere (the max number of elements
437 // in these hash tables is the number of rows/columns)
438 static const int GRID_HASH_SIZE
= 100;
441 // ----------------------------------------------------------------------------
443 // ----------------------------------------------------------------------------
445 static inline int GetScrollX(int x
)
447 return (x
+ GRID_SCROLL_LINE_X
- 1) / GRID_SCROLL_LINE_X
;
450 static inline int GetScrollY(int y
)
452 return (y
+ GRID_SCROLL_LINE_Y
- 1) / GRID_SCROLL_LINE_Y
;
456 // ============================================================================
458 // ============================================================================
460 // ----------------------------------------------------------------------------
462 // ----------------------------------------------------------------------------
464 wxGridCellEditor::wxGridCellEditor()
470 wxGridCellEditor::~wxGridCellEditor()
475 void wxGridCellEditor::Create(wxWindow
* WXUNUSED(parent
),
476 wxWindowID
WXUNUSED(id
),
477 wxEvtHandler
* evtHandler
)
480 m_control
->PushEventHandler(evtHandler
);
483 void wxGridCellEditor::PaintBackground(const wxRect
& rectCell
,
484 wxGridCellAttr
*attr
)
486 // erase the background because we might not fill the cell
487 wxClientDC
dc(m_control
->GetParent());
488 wxGridWindow
* gridWindow
= wxDynamicCast(m_control
->GetParent(), wxGridWindow
);
490 gridWindow
->GetOwner()->PrepareDC(dc
);
492 dc
.SetPen(*wxTRANSPARENT_PEN
);
493 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
494 dc
.DrawRectangle(rectCell
);
496 // redraw the control we just painted over
497 m_control
->Refresh();
500 void wxGridCellEditor::Destroy()
504 m_control
->PopEventHandler( true /* delete it*/ );
506 m_control
->Destroy();
511 void wxGridCellEditor::Show(bool show
, wxGridCellAttr
*attr
)
513 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
515 m_control
->Show(show
);
519 // set the colours/fonts if we have any
522 m_colFgOld
= m_control
->GetForegroundColour();
523 m_control
->SetForegroundColour(attr
->GetTextColour());
525 m_colBgOld
= m_control
->GetBackgroundColour();
526 m_control
->SetBackgroundColour(attr
->GetBackgroundColour());
528 // Workaround for GTK+1 font setting problem on some platforms
529 #if !defined(__WXGTK__) || defined(__WXGTK20__)
530 m_fontOld
= m_control
->GetFont();
531 m_control
->SetFont(attr
->GetFont());
534 // can't do anything more in the base class version, the other
535 // attributes may only be used by the derived classes
540 // restore the standard colours fonts
541 if ( m_colFgOld
.Ok() )
543 m_control
->SetForegroundColour(m_colFgOld
);
544 m_colFgOld
= wxNullColour
;
547 if ( m_colBgOld
.Ok() )
549 m_control
->SetBackgroundColour(m_colBgOld
);
550 m_colBgOld
= wxNullColour
;
553 // Workaround for GTK+1 font setting problem on some platforms
554 #if !defined(__WXGTK__) || defined(__WXGTK20__)
555 if ( m_fontOld
.Ok() )
557 m_control
->SetFont(m_fontOld
);
558 m_fontOld
= wxNullFont
;
564 void wxGridCellEditor::SetSize(const wxRect
& rect
)
566 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
568 m_control
->SetSize(rect
, wxSIZE_ALLOW_MINUS_ONE
);
571 void wxGridCellEditor::HandleReturn(wxKeyEvent
& event
)
576 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent
& event
)
578 bool ctrl
= event
.ControlDown();
579 bool alt
= event
.AltDown();
582 // On the Mac the Alt key is more like shift and is used for entry of
583 // valid characters, so check for Ctrl and Meta instead.
584 alt
= event
.MetaDown();
587 // Assume it's not a valid char if ctrl or alt is down, but if both are
588 // down then it may be because of an AltGr key combination, so let them
589 // through in that case.
590 if ((ctrl
|| alt
) && !(ctrl
&& alt
))
597 // If it's a F-Key or other special key then it shouldn't start the
599 if (event
.GetKeyCode() >= WXK_START
)
603 // if the unicode key code is not really a unicode character (it may
604 // be a function key or etc., the platforms appear to always give us a
605 // small value in this case) then fallback to the ASCII key code but
606 // don't do anything for function keys or etc.
607 key
= event
.GetUnicodeKey();
610 key
= event
.GetKeyCode();
611 keyOk
= (key
<= 127);
614 key
= event
.GetKeyCode();
615 keyOk
= (key
<= 255);
621 void wxGridCellEditor::StartingKey(wxKeyEvent
& event
)
626 void wxGridCellEditor::StartingClick()
632 // ----------------------------------------------------------------------------
633 // wxGridCellTextEditor
634 // ----------------------------------------------------------------------------
636 wxGridCellTextEditor::wxGridCellTextEditor()
641 void wxGridCellTextEditor::Create(wxWindow
* parent
,
643 wxEvtHandler
* evtHandler
)
645 DoCreate(parent
, id
, evtHandler
);
648 void wxGridCellTextEditor::DoCreate(wxWindow
* parent
,
650 wxEvtHandler
* evtHandler
,
653 #if defined(__WXMSW__)
654 style
|= wxTE_PROCESS_ENTER
|
660 m_control
= new wxTextCtrl(parent
, id
, wxEmptyString
,
661 wxDefaultPosition
, wxDefaultSize
,
664 // set max length allowed in the textctrl, if the parameter was set
665 if ( m_maxChars
!= 0 )
667 Text()->SetMaxLength(m_maxChars
);
670 wxGridCellEditor::Create(parent
, id
, evtHandler
);
673 void wxGridCellTextEditor::PaintBackground(const wxRect
& WXUNUSED(rectCell
),
674 wxGridCellAttr
* WXUNUSED(attr
))
676 // as we fill the entire client area,
677 // don't do anything here to minimize flicker
680 void wxGridCellTextEditor::SetSize(const wxRect
& rectOrig
)
682 wxRect
rect(rectOrig
);
684 // Make the edit control large enough to allow for internal margins
686 // TODO: remove this if the text ctrl sizing is improved esp. for unix
688 #if defined(__WXGTK__)
696 #elif defined(__WXMSW__)
710 int extra_x
= ( rect
.x
> 2 ) ? 2 : 1;
711 int extra_y
= ( rect
.y
> 2 ) ? 2 : 1;
713 #if defined(__WXMOTIF__)
718 rect
.SetLeft( wxMax(0, rect
.x
- extra_x
) );
719 rect
.SetTop( wxMax(0, rect
.y
- extra_y
) );
720 rect
.SetRight( rect
.GetRight() + 2 * extra_x
);
721 rect
.SetBottom( rect
.GetBottom() + 2 * extra_y
);
724 wxGridCellEditor::SetSize(rect
);
727 void wxGridCellTextEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
729 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
731 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
733 DoBeginEdit(m_startValue
);
736 void wxGridCellTextEditor::DoBeginEdit(const wxString
& startValue
)
738 Text()->SetValue(startValue
);
739 Text()->SetInsertionPointEnd();
740 Text()->SetSelection(-1, -1);
744 bool wxGridCellTextEditor::EndEdit(int row
, int col
, wxGrid
* grid
)
746 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
748 bool changed
= false;
749 wxString value
= Text()->GetValue();
750 if (value
!= m_startValue
)
754 grid
->GetTable()->SetValue(row
, col
, value
);
756 m_startValue
= wxEmptyString
;
758 // No point in setting the text of the hidden control
759 //Text()->SetValue(m_startValue);
764 void wxGridCellTextEditor::Reset()
766 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
768 DoReset(m_startValue
);
771 void wxGridCellTextEditor::DoReset(const wxString
& startValue
)
773 Text()->SetValue(startValue
);
774 Text()->SetInsertionPointEnd();
777 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent
& event
)
779 return wxGridCellEditor::IsAcceptedKey(event
);
782 void wxGridCellTextEditor::StartingKey(wxKeyEvent
& event
)
784 // Since this is now happening in the EVT_CHAR event EmulateKeyPress is no
785 // longer an appropriate way to get the character into the text control.
786 // Do it ourselves instead. We know that if we get this far that we have
787 // a valid character, so not a whole lot of testing needs to be done.
789 wxTextCtrl
* tc
= Text();
794 ch
= event
.GetUnicodeKey();
796 ch
= (wxChar
)event
.GetKeyCode();
798 ch
= (wxChar
)event
.GetKeyCode();
804 // delete the character at the cursor
805 pos
= tc
->GetInsertionPoint();
806 if (pos
< tc
->GetLastPosition())
807 tc
->Remove(pos
, pos
+ 1);
811 // delete the character before the cursor
812 pos
= tc
->GetInsertionPoint();
814 tc
->Remove(pos
- 1, pos
);
823 void wxGridCellTextEditor::HandleReturn( wxKeyEvent
&
824 WXUNUSED_GTK(WXUNUSED_MOTIF(event
)) )
826 #if defined(__WXMOTIF__) || defined(__WXGTK__)
827 // wxMotif needs a little extra help...
828 size_t pos
= (size_t)( Text()->GetInsertionPoint() );
829 wxString
s( Text()->GetValue() );
830 s
= s
.Left(pos
) + wxT("\n") + s
.Mid(pos
);
832 Text()->SetInsertionPoint( pos
);
834 // the other ports can handle a Return key press
840 void wxGridCellTextEditor::SetParameters(const wxString
& params
)
850 if ( params
.ToLong(&tmp
) )
852 m_maxChars
= (size_t)tmp
;
856 wxLogDebug( _T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params
.c_str() );
861 // return the value in the text control
862 wxString
wxGridCellTextEditor::GetValue() const
864 return Text()->GetValue();
867 // ----------------------------------------------------------------------------
868 // wxGridCellNumberEditor
869 // ----------------------------------------------------------------------------
871 wxGridCellNumberEditor::wxGridCellNumberEditor(int min
, int max
)
877 void wxGridCellNumberEditor::Create(wxWindow
* parent
,
879 wxEvtHandler
* evtHandler
)
884 // create a spin ctrl
885 m_control
= new wxSpinCtrl(parent
, wxID_ANY
, wxEmptyString
,
886 wxDefaultPosition
, wxDefaultSize
,
890 wxGridCellEditor::Create(parent
, id
, evtHandler
);
895 // just a text control
896 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
899 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
904 void wxGridCellNumberEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
906 // first get the value
907 wxGridTableBase
*table
= grid
->GetTable();
908 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
910 m_valueOld
= table
->GetValueAsLong(row
, col
);
915 wxString sValue
= table
->GetValue(row
, col
);
916 if (! sValue
.ToLong(&m_valueOld
) && ! sValue
.empty())
918 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
926 Spin()->SetValue((int)m_valueOld
);
932 DoBeginEdit(GetString());
936 bool wxGridCellNumberEditor::EndEdit(int row
, int col
,
946 value
= Spin()->GetValue();
947 changed
= value
!= m_valueOld
;
949 text
= wxString::Format(wxT("%ld"), value
);
954 text
= Text()->GetValue();
955 changed
= (text
.empty() || text
.ToLong(&value
)) && (value
!= m_valueOld
);
960 if (grid
->GetTable()->CanSetValueAs(row
, col
, wxGRID_VALUE_NUMBER
))
961 grid
->GetTable()->SetValueAsLong(row
, col
, value
);
963 grid
->GetTable()->SetValue(row
, col
, text
);
969 void wxGridCellNumberEditor::Reset()
974 Spin()->SetValue((int)m_valueOld
);
979 DoReset(GetString());
983 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent
& event
)
985 if ( wxGridCellEditor::IsAcceptedKey(event
) )
987 int keycode
= event
.GetKeyCode();
988 if ( (keycode
< 128) &&
989 (wxIsdigit(keycode
) || keycode
== '+' || keycode
== '-'))
998 void wxGridCellNumberEditor::StartingKey(wxKeyEvent
& event
)
1000 int keycode
= event
.GetKeyCode();
1003 if ( wxIsdigit(keycode
) || keycode
== '+' || keycode
== '-')
1005 wxGridCellTextEditor::StartingKey(event
);
1007 // skip Skip() below
1014 if ( wxIsdigit(keycode
) )
1016 wxSpinCtrl
* spin
= (wxSpinCtrl
*)m_control
;
1017 spin
->SetValue(keycode
- '0');
1018 spin
->SetSelection(1,1);
1027 void wxGridCellNumberEditor::SetParameters(const wxString
& params
)
1038 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
1042 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
1046 // skip the error message below
1051 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params
.c_str());
1055 // return the value in the spin control if it is there (the text control otherwise)
1056 wxString
wxGridCellNumberEditor::GetValue() const
1063 long value
= Spin()->GetValue();
1064 s
.Printf(wxT("%ld"), value
);
1069 s
= Text()->GetValue();
1075 // ----------------------------------------------------------------------------
1076 // wxGridCellFloatEditor
1077 // ----------------------------------------------------------------------------
1079 wxGridCellFloatEditor::wxGridCellFloatEditor(int width
, int precision
)
1082 m_precision
= precision
;
1085 void wxGridCellFloatEditor::Create(wxWindow
* parent
,
1087 wxEvtHandler
* evtHandler
)
1089 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
1091 #if wxUSE_VALIDATORS
1092 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
1096 void wxGridCellFloatEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1098 // first get the value
1099 wxGridTableBase
*table
= grid
->GetTable();
1100 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
1102 m_valueOld
= table
->GetValueAsDouble(row
, col
);
1107 wxString sValue
= table
->GetValue(row
, col
);
1108 if (! sValue
.ToDouble(&m_valueOld
) && ! sValue
.empty())
1110 wxFAIL_MSG( _T("this cell doesn't have float value") );
1115 DoBeginEdit(GetString());
1118 bool wxGridCellFloatEditor::EndEdit(int row
, int col
,
1122 wxString
text(Text()->GetValue());
1124 if ( (text
.empty() || text
.ToDouble(&value
)) &&
1125 !wxIsSameDouble(value
, m_valueOld
) )
1127 if (grid
->GetTable()->CanSetValueAs(row
, col
, wxGRID_VALUE_FLOAT
))
1128 grid
->GetTable()->SetValueAsDouble(row
, col
, value
);
1130 grid
->GetTable()->SetValue(row
, col
, text
);
1138 void wxGridCellFloatEditor::Reset()
1140 DoReset(GetString());
1143 void wxGridCellFloatEditor::StartingKey(wxKeyEvent
& event
)
1145 int keycode
= event
.GetKeyCode();
1147 tmpbuf
[0] = (char) keycode
;
1149 wxString
strbuf(tmpbuf
, *wxConvCurrent
);
1152 bool is_decimal_point
= ( strbuf
==
1153 wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT
, wxLOCALE_CAT_NUMBER
) );
1155 bool is_decimal_point
= ( strbuf
== _T(".") );
1158 if ( wxIsdigit(keycode
) || keycode
== '+' || keycode
== '-'
1159 || is_decimal_point
)
1161 wxGridCellTextEditor::StartingKey(event
);
1163 // skip Skip() below
1170 void wxGridCellFloatEditor::SetParameters(const wxString
& params
)
1181 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
1185 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
1187 m_precision
= (int)tmp
;
1189 // skip the error message below
1194 wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params
.c_str());
1198 wxString
wxGridCellFloatEditor::GetString() const
1201 if ( m_precision
== -1 && m_width
!= -1)
1203 // default precision
1204 fmt
.Printf(_T("%%%d.f"), m_width
);
1206 else if ( m_precision
!= -1 && m_width
== -1)
1209 fmt
.Printf(_T("%%.%df"), m_precision
);
1211 else if ( m_precision
!= -1 && m_width
!= -1 )
1213 fmt
.Printf(_T("%%%d.%df"), m_width
, m_precision
);
1217 // default width/precision
1221 return wxString::Format(fmt
, m_valueOld
);
1224 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent
& event
)
1226 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1228 const int keycode
= event
.GetKeyCode();
1229 if ( isascii(keycode
) )
1232 tmpbuf
[0] = (char) keycode
;
1234 wxString
strbuf(tmpbuf
, *wxConvCurrent
);
1237 const wxString decimalPoint
=
1238 wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT
, wxLOCALE_CAT_NUMBER
);
1240 const wxString
decimalPoint(_T('.'));
1243 // accept digits, 'e' as in '1e+6', also '-', '+', and '.'
1244 if ( wxIsdigit(keycode
) ||
1245 tolower(keycode
) == 'e' ||
1246 keycode
== decimalPoint
||
1258 #endif // wxUSE_TEXTCTRL
1262 // ----------------------------------------------------------------------------
1263 // wxGridCellBoolEditor
1264 // ----------------------------------------------------------------------------
1266 // the default values for GetValue()
1267 wxString
wxGridCellBoolEditor::ms_stringValues
[2] = { _T(""), _T("1") };
1269 void wxGridCellBoolEditor::Create(wxWindow
* parent
,
1271 wxEvtHandler
* evtHandler
)
1273 m_control
= new wxCheckBox(parent
, id
, wxEmptyString
,
1274 wxDefaultPosition
, wxDefaultSize
,
1277 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1280 void wxGridCellBoolEditor::SetSize(const wxRect
& r
)
1282 bool resize
= false;
1283 wxSize size
= m_control
->GetSize();
1284 wxCoord minSize
= wxMin(r
.width
, r
.height
);
1286 // check if the checkbox is not too big/small for this cell
1287 wxSize sizeBest
= m_control
->GetBestSize();
1288 if ( !(size
== sizeBest
) )
1290 // reset to default size if it had been made smaller
1296 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
1298 // leave 1 pixel margin
1299 size
.x
= size
.y
= minSize
- 2;
1306 m_control
->SetSize(size
);
1309 // position it in the centre of the rectangle (TODO: support alignment?)
1311 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1312 // the checkbox without label still has some space to the right in wxGTK,
1313 // so shift it to the right
1315 #elif defined(__WXMSW__)
1316 // here too, but in other way
1321 int hAlign
= wxALIGN_CENTRE
;
1322 int vAlign
= wxALIGN_CENTRE
;
1324 GetCellAttr()->GetAlignment(& hAlign
, & vAlign
);
1327 if (hAlign
== wxALIGN_LEFT
)
1335 y
= r
.y
+ r
.height
/ 2 - size
.y
/ 2;
1337 else if (hAlign
== wxALIGN_RIGHT
)
1339 x
= r
.x
+ r
.width
- size
.x
- 2;
1340 y
= r
.y
+ r
.height
/ 2 - size
.y
/ 2;
1342 else if (hAlign
== wxALIGN_CENTRE
)
1344 x
= r
.x
+ r
.width
/ 2 - size
.x
/ 2;
1345 y
= r
.y
+ r
.height
/ 2 - size
.y
/ 2;
1348 m_control
->Move(x
, y
);
1351 void wxGridCellBoolEditor::Show(bool show
, wxGridCellAttr
*attr
)
1353 m_control
->Show(show
);
1357 wxColour colBg
= attr
? attr
->GetBackgroundColour() : *wxLIGHT_GREY
;
1358 CBox()->SetBackgroundColour(colBg
);
1362 void wxGridCellBoolEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1364 wxASSERT_MSG(m_control
,
1365 wxT("The wxGridCellEditor must be created first!"));
1367 if (grid
->GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
))
1369 m_startValue
= grid
->GetTable()->GetValueAsBool(row
, col
);
1373 wxString
cellval( grid
->GetTable()->GetValue(row
, col
) );
1375 if ( cellval
== ms_stringValues
[false] )
1376 m_startValue
= false;
1377 else if ( cellval
== ms_stringValues
[true] )
1378 m_startValue
= true;
1381 // do not try to be smart here and convert it to true or false
1382 // because we'll still overwrite it with something different and
1383 // this risks to be very surprising for the user code, let them
1385 wxFAIL_MSG( _T("invalid value for a cell with bool editor!") );
1389 CBox()->SetValue(m_startValue
);
1393 bool wxGridCellBoolEditor::EndEdit(int row
, int col
,
1396 wxASSERT_MSG(m_control
,
1397 wxT("The wxGridCellEditor must be created first!"));
1399 bool changed
= false;
1400 bool value
= CBox()->GetValue();
1401 if ( value
!= m_startValue
)
1406 wxGridTableBase
* const table
= grid
->GetTable();
1407 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
) )
1408 table
->SetValueAsBool(row
, col
, value
);
1410 table
->SetValue(row
, col
, GetValue());
1416 void wxGridCellBoolEditor::Reset()
1418 wxASSERT_MSG(m_control
,
1419 wxT("The wxGridCellEditor must be created first!"));
1421 CBox()->SetValue(m_startValue
);
1424 void wxGridCellBoolEditor::StartingClick()
1426 CBox()->SetValue(!CBox()->GetValue());
1429 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent
& event
)
1431 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1433 int keycode
= event
.GetKeyCode();
1446 void wxGridCellBoolEditor::StartingKey(wxKeyEvent
& event
)
1448 int keycode
= event
.GetKeyCode();
1452 CBox()->SetValue(!CBox()->GetValue());
1456 CBox()->SetValue(true);
1460 CBox()->SetValue(false);
1465 wxString
wxGridCellBoolEditor::GetValue() const
1467 return ms_stringValues
[CBox()->GetValue()];
1471 wxGridCellBoolEditor::UseStringValues(const wxString
& valueTrue
,
1472 const wxString
& valueFalse
)
1474 ms_stringValues
[false] = valueFalse
;
1475 ms_stringValues
[true] = valueTrue
;
1479 wxGridCellBoolEditor::IsTrueValue(const wxString
& value
)
1481 return value
== ms_stringValues
[true];
1484 #endif // wxUSE_CHECKBOX
1488 // ----------------------------------------------------------------------------
1489 // wxGridCellChoiceEditor
1490 // ----------------------------------------------------------------------------
1492 wxGridCellChoiceEditor::wxGridCellChoiceEditor(const wxArrayString
& choices
,
1494 : m_choices(choices
),
1495 m_allowOthers(allowOthers
) { }
1497 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count
,
1498 const wxString choices
[],
1500 : m_allowOthers(allowOthers
)
1504 m_choices
.Alloc(count
);
1505 for ( size_t n
= 0; n
< count
; n
++ )
1507 m_choices
.Add(choices
[n
]);
1512 wxGridCellEditor
*wxGridCellChoiceEditor::Clone() const
1514 wxGridCellChoiceEditor
*editor
= new wxGridCellChoiceEditor
;
1515 editor
->m_allowOthers
= m_allowOthers
;
1516 editor
->m_choices
= m_choices
;
1521 void wxGridCellChoiceEditor::Create(wxWindow
* parent
,
1523 wxEvtHandler
* evtHandler
)
1525 m_control
= new wxComboBox(parent
, id
, wxEmptyString
,
1526 wxDefaultPosition
, wxDefaultSize
,
1528 m_allowOthers
? 0 : wxCB_READONLY
);
1530 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1533 void wxGridCellChoiceEditor::PaintBackground(const wxRect
& rectCell
,
1534 wxGridCellAttr
* attr
)
1536 // as we fill the entire client area, don't do anything here to minimize
1539 // TODO: It doesn't actually fill the client area since the height of a
1540 // combo always defaults to the standard. Until someone has time to
1541 // figure out the right rectangle to paint, just do it the normal way.
1542 wxGridCellEditor::PaintBackground(rectCell
, attr
);
1545 void wxGridCellChoiceEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1547 wxASSERT_MSG(m_control
,
1548 wxT("The wxGridCellEditor must be created first!"));
1550 wxGridCellEditorEvtHandler
* evtHandler
= NULL
;
1552 evtHandler
= wxDynamicCast(m_control
->GetEventHandler(), wxGridCellEditorEvtHandler
);
1554 // Don't immediately end if we get a kill focus event within BeginEdit
1556 evtHandler
->SetInSetFocus(true);
1558 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
1562 Combo()->SetValue(m_startValue
);
1563 Combo()->SetInsertionPointEnd();
1565 else // the combobox is read-only
1567 // find the right position, or default to the first if not found
1568 int pos
= Combo()->FindString(m_startValue
);
1569 if (pos
== wxNOT_FOUND
)
1571 Combo()->SetSelection(pos
);
1574 Combo()->SetFocus();
1578 // When dropping down the menu, a kill focus event
1579 // happens after this point, so we can't reset the flag yet.
1580 #if !defined(__WXGTK20__)
1581 evtHandler
->SetInSetFocus(false);
1586 bool wxGridCellChoiceEditor::EndEdit(int row
, int col
,
1589 wxString value
= Combo()->GetValue();
1590 if ( value
== m_startValue
)
1593 grid
->GetTable()->SetValue(row
, col
, value
);
1598 void wxGridCellChoiceEditor::Reset()
1600 Combo()->SetValue(m_startValue
);
1601 Combo()->SetInsertionPointEnd();
1604 void wxGridCellChoiceEditor::SetParameters(const wxString
& params
)
1614 wxStringTokenizer
tk(params
, _T(','));
1615 while ( tk
.HasMoreTokens() )
1617 m_choices
.Add(tk
.GetNextToken());
1621 // return the value in the text control
1622 wxString
wxGridCellChoiceEditor::GetValue() const
1624 return Combo()->GetValue();
1627 #endif // wxUSE_COMBOBOX
1629 // ----------------------------------------------------------------------------
1630 // wxGridCellEditorEvtHandler
1631 // ----------------------------------------------------------------------------
1633 void wxGridCellEditorEvtHandler::OnKillFocus(wxFocusEvent
& event
)
1635 // Don't disable the cell if we're just starting to edit it
1640 m_grid
->DisableCellEditControl();
1645 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent
& event
)
1647 switch ( event
.GetKeyCode() )
1651 m_grid
->DisableCellEditControl();
1655 m_grid
->GetEventHandler()->ProcessEvent( event
);
1659 case WXK_NUMPAD_ENTER
:
1660 if (!m_grid
->GetEventHandler()->ProcessEvent(event
))
1661 m_editor
->HandleReturn(event
);
1670 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent
& event
)
1672 int row
= m_grid
->GetGridCursorRow();
1673 int col
= m_grid
->GetGridCursorCol();
1674 wxRect rect
= m_grid
->CellToRect( row
, col
);
1676 m_grid
->GetGridWindow()->GetClientSize( &cw
, &ch
);
1678 // if cell width is smaller than grid client area, cell is wholly visible
1679 bool wholeCellVisible
= (rect
.GetWidth() < cw
);
1681 switch ( event
.GetKeyCode() )
1686 case WXK_NUMPAD_ENTER
:
1691 if ( wholeCellVisible
)
1693 // no special processing needed...
1698 // do special processing for partly visible cell...
1700 // get the widths of all cells previous to this one
1702 for ( int i
= 0; i
< col
; i
++ )
1704 colXPos
+= m_grid
->GetColSize(i
);
1707 int xUnit
= 1, yUnit
= 1;
1708 m_grid
->GetScrollPixelsPerUnit(&xUnit
, &yUnit
);
1711 m_grid
->Scroll(colXPos
/ xUnit
- 1, m_grid
->GetScrollPos(wxVERTICAL
));
1715 m_grid
->Scroll(colXPos
/ xUnit
, m_grid
->GetScrollPos(wxVERTICAL
));
1723 if ( wholeCellVisible
)
1725 // no special processing needed...
1730 // do special processing for partly visible cell...
1733 wxString value
= m_grid
->GetCellValue(row
, col
);
1734 if ( wxEmptyString
!= value
)
1736 // get width of cell CONTENTS (text)
1738 wxFont font
= m_grid
->GetCellFont(row
, col
);
1739 m_grid
->GetTextExtent(value
, &textWidth
, &y
, NULL
, NULL
, &font
);
1741 // try to RIGHT align the text by scrolling
1742 int client_right
= m_grid
->GetGridWindow()->GetClientSize().GetWidth();
1744 // (m_grid->GetScrollLineX()*2) is a factor for not scrolling to far,
1745 // otherwise the last part of the cell content might be hidden below the scroll bar
1746 // FIXME: maybe there is a more suitable correction?
1747 textWidth
-= (client_right
- (m_grid
->GetScrollLineX() * 2));
1748 if ( textWidth
< 0 )
1754 // get the widths of all cells previous to this one
1756 for ( int i
= 0; i
< col
; i
++ )
1758 colXPos
+= m_grid
->GetColSize(i
);
1761 // and add the (modified) text width of the cell contents
1762 // as we'd like to see the last part of the cell contents
1763 colXPos
+= textWidth
;
1765 int xUnit
= 1, yUnit
= 1;
1766 m_grid
->GetScrollPixelsPerUnit(&xUnit
, &yUnit
);
1767 m_grid
->Scroll(colXPos
/ xUnit
- 1, m_grid
->GetScrollPos(wxVERTICAL
));
1778 // ----------------------------------------------------------------------------
1779 // wxGridCellWorker is an (almost) empty common base class for
1780 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1781 // ----------------------------------------------------------------------------
1783 void wxGridCellWorker::SetParameters(const wxString
& WXUNUSED(params
))
1788 wxGridCellWorker::~wxGridCellWorker()
1792 // ============================================================================
1794 // ============================================================================
1796 // ----------------------------------------------------------------------------
1797 // wxGridCellRenderer
1798 // ----------------------------------------------------------------------------
1800 void wxGridCellRenderer::Draw(wxGrid
& grid
,
1801 wxGridCellAttr
& attr
,
1804 int WXUNUSED(row
), int WXUNUSED(col
),
1807 dc
.SetBackgroundMode( wxSOLID
);
1809 // grey out fields if the grid is disabled
1810 if ( grid
.IsEnabled() )
1814 dc
.SetBrush( wxBrush(grid
.GetSelectionBackground(), wxSOLID
) );
1818 dc
.SetBrush( wxBrush(attr
.GetBackgroundColour(), wxSOLID
) );
1823 dc
.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
), wxSOLID
));
1826 dc
.SetPen( *wxTRANSPARENT_PEN
);
1827 dc
.DrawRectangle(rect
);
1830 // ----------------------------------------------------------------------------
1831 // wxGridCellStringRenderer
1832 // ----------------------------------------------------------------------------
1834 void wxGridCellStringRenderer::SetTextColoursAndFont(const wxGrid
& grid
,
1835 const wxGridCellAttr
& attr
,
1839 dc
.SetBackgroundMode( wxTRANSPARENT
);
1841 // TODO some special colours for attr.IsReadOnly() case?
1843 // different coloured text when the grid is disabled
1844 if ( grid
.IsEnabled() )
1848 dc
.SetTextBackground( grid
.GetSelectionBackground() );
1849 dc
.SetTextForeground( grid
.GetSelectionForeground() );
1853 dc
.SetTextBackground( attr
.GetBackgroundColour() );
1854 dc
.SetTextForeground( attr
.GetTextColour() );
1859 dc
.SetTextBackground(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
));
1860 dc
.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT
));
1863 dc
.SetFont( attr
.GetFont() );
1866 wxSize
wxGridCellStringRenderer::DoGetBestSize(const wxGridCellAttr
& attr
,
1868 const wxString
& text
)
1870 wxCoord x
= 0, y
= 0, max_x
= 0;
1871 dc
.SetFont(attr
.GetFont());
1872 wxStringTokenizer
tk(text
, _T('\n'));
1873 while ( tk
.HasMoreTokens() )
1875 dc
.GetTextExtent(tk
.GetNextToken(), &x
, &y
);
1876 max_x
= wxMax(max_x
, x
);
1879 y
*= 1 + text
.Freq(wxT('\n')); // multiply by the number of lines.
1881 return wxSize(max_x
, y
);
1884 wxSize
wxGridCellStringRenderer::GetBestSize(wxGrid
& grid
,
1885 wxGridCellAttr
& attr
,
1889 return DoGetBestSize(attr
, dc
, grid
.GetCellValue(row
, col
));
1892 void wxGridCellStringRenderer::Draw(wxGrid
& grid
,
1893 wxGridCellAttr
& attr
,
1895 const wxRect
& rectCell
,
1899 wxRect rect
= rectCell
;
1902 // erase only this cells background, overflow cells should have been erased
1903 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1906 attr
.GetAlignment(&hAlign
, &vAlign
);
1908 int overflowCols
= 0;
1910 if (attr
.GetOverflow())
1912 int cols
= grid
.GetNumberCols();
1913 int best_width
= GetBestSize(grid
,attr
,dc
,row
,col
).GetWidth();
1914 int cell_rows
, cell_cols
;
1915 attr
.GetSize( &cell_rows
, &cell_cols
); // shouldn't get here if <= 0
1916 if ((best_width
> rectCell
.width
) && (col
< cols
) && grid
.GetTable())
1918 int i
, c_cols
, c_rows
;
1919 for (i
= col
+cell_cols
; i
< cols
; i
++)
1921 bool is_empty
= true;
1922 for (int j
=row
; j
< row
+ cell_rows
; j
++)
1924 // check w/ anchor cell for multicell block
1925 grid
.GetCellSize(j
, i
, &c_rows
, &c_cols
);
1928 if (!grid
.GetTable()->IsEmptyCell(j
+ c_rows
, i
))
1937 rect
.width
+= grid
.GetColSize(i
);
1945 if (rect
.width
>= best_width
)
1949 overflowCols
= i
- col
- cell_cols
+ 1;
1950 if (overflowCols
>= cols
)
1951 overflowCols
= cols
- 1;
1954 if (overflowCols
> 0) // redraw overflow cells w/ proper hilight
1956 hAlign
= wxALIGN_LEFT
; // if oveflowed then it's left aligned
1958 clip
.x
+= rectCell
.width
;
1959 // draw each overflow cell individually
1960 int col_end
= col
+ cell_cols
+ overflowCols
;
1961 if (col_end
>= grid
.GetNumberCols())
1962 col_end
= grid
.GetNumberCols() - 1;
1963 for (int i
= col
+ cell_cols
; i
<= col_end
; i
++)
1965 clip
.width
= grid
.GetColSize(i
) - 1;
1966 dc
.DestroyClippingRegion();
1967 dc
.SetClippingRegion(clip
);
1969 SetTextColoursAndFont(grid
, attr
, dc
,
1970 grid
.IsInSelection(row
,i
));
1972 grid
.DrawTextRectangle(dc
, grid
.GetCellValue(row
, col
),
1973 rect
, hAlign
, vAlign
);
1974 clip
.x
+= grid
.GetColSize(i
) - 1;
1980 dc
.DestroyClippingRegion();
1984 // now we only have to draw the text
1985 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
1987 grid
.DrawTextRectangle(dc
, grid
.GetCellValue(row
, col
),
1988 rect
, hAlign
, vAlign
);
1991 // ----------------------------------------------------------------------------
1992 // wxGridCellNumberRenderer
1993 // ----------------------------------------------------------------------------
1995 wxString
wxGridCellNumberRenderer::GetString(const wxGrid
& grid
, int row
, int col
)
1997 wxGridTableBase
*table
= grid
.GetTable();
1999 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
2001 text
.Printf(_T("%ld"), table
->GetValueAsLong(row
, col
));
2005 text
= table
->GetValue(row
, col
);
2011 void wxGridCellNumberRenderer::Draw(wxGrid
& grid
,
2012 wxGridCellAttr
& attr
,
2014 const wxRect
& rectCell
,
2018 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
2020 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
2022 // draw the text right aligned by default
2024 attr
.GetAlignment(&hAlign
, &vAlign
);
2025 hAlign
= wxALIGN_RIGHT
;
2027 wxRect rect
= rectCell
;
2030 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
2033 wxSize
wxGridCellNumberRenderer::GetBestSize(wxGrid
& grid
,
2034 wxGridCellAttr
& attr
,
2038 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
2041 // ----------------------------------------------------------------------------
2042 // wxGridCellFloatRenderer
2043 // ----------------------------------------------------------------------------
2045 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width
, int precision
)
2048 SetPrecision(precision
);
2051 wxGridCellRenderer
*wxGridCellFloatRenderer::Clone() const
2053 wxGridCellFloatRenderer
*renderer
= new wxGridCellFloatRenderer
;
2054 renderer
->m_width
= m_width
;
2055 renderer
->m_precision
= m_precision
;
2056 renderer
->m_format
= m_format
;
2061 wxString
wxGridCellFloatRenderer::GetString(const wxGrid
& grid
, int row
, int col
)
2063 wxGridTableBase
*table
= grid
.GetTable();
2068 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
2070 val
= table
->GetValueAsDouble(row
, col
);
2075 text
= table
->GetValue(row
, col
);
2076 hasDouble
= text
.ToDouble(&val
);
2083 if ( m_width
== -1 )
2085 if ( m_precision
== -1 )
2087 // default width/precision
2088 m_format
= _T("%f");
2092 m_format
.Printf(_T("%%.%df"), m_precision
);
2095 else if ( m_precision
== -1 )
2097 // default precision
2098 m_format
.Printf(_T("%%%d.f"), m_width
);
2102 m_format
.Printf(_T("%%%d.%df"), m_width
, m_precision
);
2106 text
.Printf(m_format
, val
);
2109 //else: text already contains the string
2114 void wxGridCellFloatRenderer::Draw(wxGrid
& grid
,
2115 wxGridCellAttr
& attr
,
2117 const wxRect
& rectCell
,
2121 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
2123 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
2125 // draw the text right aligned by default
2127 attr
.GetAlignment(&hAlign
, &vAlign
);
2128 hAlign
= wxALIGN_RIGHT
;
2130 wxRect rect
= rectCell
;
2133 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
2136 wxSize
wxGridCellFloatRenderer::GetBestSize(wxGrid
& grid
,
2137 wxGridCellAttr
& attr
,
2141 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
2144 void wxGridCellFloatRenderer::SetParameters(const wxString
& params
)
2148 // reset to defaults
2154 wxString tmp
= params
.BeforeFirst(_T(','));
2158 if ( tmp
.ToLong(&width
) )
2160 SetWidth((int)width
);
2164 wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params
.c_str());
2168 tmp
= params
.AfterFirst(_T(','));
2172 if ( tmp
.ToLong(&precision
) )
2174 SetPrecision((int)precision
);
2178 wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params
.c_str());
2184 // ----------------------------------------------------------------------------
2185 // wxGridCellBoolRenderer
2186 // ----------------------------------------------------------------------------
2188 wxSize
wxGridCellBoolRenderer::ms_sizeCheckMark
;
2190 // FIXME these checkbox size calculations are really ugly...
2192 // between checkmark and box
2193 static const wxCoord wxGRID_CHECKMARK_MARGIN
= 2;
2195 wxSize
wxGridCellBoolRenderer::GetBestSize(wxGrid
& grid
,
2196 wxGridCellAttr
& WXUNUSED(attr
),
2201 // compute it only once (no locks for MT safeness in GUI thread...)
2202 if ( !ms_sizeCheckMark
.x
)
2204 // get checkbox size
2205 wxCheckBox
*checkbox
= new wxCheckBox(&grid
, wxID_ANY
, wxEmptyString
);
2206 wxSize size
= checkbox
->GetBestSize();
2207 wxCoord checkSize
= size
.y
+ 2 * wxGRID_CHECKMARK_MARGIN
;
2209 // FIXME wxGTK::wxCheckBox::GetBestSize() gives "wrong" result
2210 #if defined(__WXGTK__) || defined(__WXMOTIF__)
2211 checkSize
-= size
.y
/ 2;
2216 ms_sizeCheckMark
.x
= ms_sizeCheckMark
.y
= checkSize
;
2219 return ms_sizeCheckMark
;
2222 void wxGridCellBoolRenderer::Draw(wxGrid
& grid
,
2223 wxGridCellAttr
& attr
,
2229 wxGridCellRenderer::Draw(grid
, attr
, dc
, rect
, row
, col
, isSelected
);
2231 // draw a check mark in the centre (ignoring alignment - TODO)
2232 wxSize size
= GetBestSize(grid
, attr
, dc
, row
, col
);
2234 // don't draw outside the cell
2235 wxCoord minSize
= wxMin(rect
.width
, rect
.height
);
2236 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
2238 // and even leave (at least) 1 pixel margin
2239 size
.x
= size
.y
= minSize
- 2;
2242 // draw a border around checkmark
2244 attr
.GetAlignment(&hAlign
, &vAlign
);
2247 if (hAlign
== wxALIGN_CENTRE
)
2249 rectBorder
.x
= rect
.x
+ rect
.width
/ 2 - size
.x
/ 2;
2250 rectBorder
.y
= rect
.y
+ rect
.height
/ 2 - size
.y
/ 2;
2251 rectBorder
.width
= size
.x
;
2252 rectBorder
.height
= size
.y
;
2254 else if (hAlign
== wxALIGN_LEFT
)
2256 rectBorder
.x
= rect
.x
+ 2;
2257 rectBorder
.y
= rect
.y
+ rect
.height
/ 2 - size
.y
/ 2;
2258 rectBorder
.width
= size
.x
;
2259 rectBorder
.height
= size
.y
;
2261 else if (hAlign
== wxALIGN_RIGHT
)
2263 rectBorder
.x
= rect
.x
+ rect
.width
- size
.x
- 2;
2264 rectBorder
.y
= rect
.y
+ rect
.height
/ 2 - size
.y
/ 2;
2265 rectBorder
.width
= size
.x
;
2266 rectBorder
.height
= size
.y
;
2270 if ( grid
.GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
) )
2272 value
= grid
.GetTable()->GetValueAsBool(row
, col
);
2276 wxString
cellval( grid
.GetTable()->GetValue(row
, col
) );
2277 value
= wxGridCellBoolEditor::IsTrueValue(cellval
);
2282 wxRect rectMark
= rectBorder
;
2285 // MSW DrawCheckMark() is weird (and should probably be changed...)
2286 rectMark
.Inflate(-wxGRID_CHECKMARK_MARGIN
/ 2);
2290 rectMark
.Inflate(-wxGRID_CHECKMARK_MARGIN
);
2293 dc
.SetTextForeground(attr
.GetTextColour());
2294 dc
.DrawCheckMark(rectMark
);
2297 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
2298 dc
.SetPen(wxPen(attr
.GetTextColour(), 1, wxSOLID
));
2299 dc
.DrawRectangle(rectBorder
);
2302 // ----------------------------------------------------------------------------
2304 // ----------------------------------------------------------------------------
2306 void wxGridCellAttr::Init(wxGridCellAttr
*attrDefault
)
2310 m_isReadOnly
= Unset
;
2315 m_attrkind
= wxGridCellAttr::Cell
;
2317 m_sizeRows
= m_sizeCols
= 1;
2318 m_overflow
= UnsetOverflow
;
2320 SetDefAttr(attrDefault
);
2323 wxGridCellAttr
*wxGridCellAttr::Clone() const
2325 wxGridCellAttr
*attr
= new wxGridCellAttr(m_defGridAttr
);
2327 if ( HasTextColour() )
2328 attr
->SetTextColour(GetTextColour());
2329 if ( HasBackgroundColour() )
2330 attr
->SetBackgroundColour(GetBackgroundColour());
2332 attr
->SetFont(GetFont());
2333 if ( HasAlignment() )
2334 attr
->SetAlignment(m_hAlign
, m_vAlign
);
2336 attr
->SetSize( m_sizeRows
, m_sizeCols
);
2340 attr
->SetRenderer(m_renderer
);
2341 m_renderer
->IncRef();
2345 attr
->SetEditor(m_editor
);
2350 attr
->SetReadOnly();
2352 attr
->SetOverflow( m_overflow
== Overflow
);
2353 attr
->SetKind( m_attrkind
);
2358 void wxGridCellAttr::MergeWith(wxGridCellAttr
*mergefrom
)
2360 if ( !HasTextColour() && mergefrom
->HasTextColour() )
2361 SetTextColour(mergefrom
->GetTextColour());
2362 if ( !HasBackgroundColour() && mergefrom
->HasBackgroundColour() )
2363 SetBackgroundColour(mergefrom
->GetBackgroundColour());
2364 if ( !HasFont() && mergefrom
->HasFont() )
2365 SetFont(mergefrom
->GetFont());
2366 if ( !HasAlignment() && mergefrom
->HasAlignment() )
2369 mergefrom
->GetAlignment( &hAlign
, &vAlign
);
2370 SetAlignment(hAlign
, vAlign
);
2372 if ( !HasSize() && mergefrom
->HasSize() )
2373 mergefrom
->GetSize( &m_sizeRows
, &m_sizeCols
);
2375 // Directly access member functions as GetRender/Editor don't just return
2376 // m_renderer/m_editor
2378 // Maybe add support for merge of Render and Editor?
2379 if (!HasRenderer() && mergefrom
->HasRenderer() )
2381 m_renderer
= mergefrom
->m_renderer
;
2382 m_renderer
->IncRef();
2384 if ( !HasEditor() && mergefrom
->HasEditor() )
2386 m_editor
= mergefrom
->m_editor
;
2389 if ( !HasReadWriteMode() && mergefrom
->HasReadWriteMode() )
2390 SetReadOnly(mergefrom
->IsReadOnly());
2392 if (!HasOverflowMode() && mergefrom
->HasOverflowMode() )
2393 SetOverflow(mergefrom
->GetOverflow());
2395 SetDefAttr(mergefrom
->m_defGridAttr
);
2398 void wxGridCellAttr::SetSize(int num_rows
, int num_cols
)
2400 // The size of a cell is normally 1,1
2402 // If this cell is larger (2,2) then this is the top left cell
2403 // the other cells that will be covered (lower right cells) must be
2404 // set to negative or zero values such that
2405 // row + num_rows of the covered cell points to the larger cell (this cell)
2406 // same goes for the col + num_cols.
2408 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
2410 wxASSERT_MSG( (!((num_rows
> 0) && (num_cols
<= 0)) ||
2411 !((num_rows
<= 0) && (num_cols
> 0)) ||
2412 !((num_rows
== 0) && (num_cols
== 0))),
2413 wxT("wxGridCellAttr::SetSize only takes two postive values or negative/zero values"));
2415 m_sizeRows
= num_rows
;
2416 m_sizeCols
= num_cols
;
2419 const wxColour
& wxGridCellAttr::GetTextColour() const
2421 if (HasTextColour())
2425 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2427 return m_defGridAttr
->GetTextColour();
2431 wxFAIL_MSG(wxT("Missing default cell attribute"));
2432 return wxNullColour
;
2436 const wxColour
& wxGridCellAttr::GetBackgroundColour() const
2438 if (HasBackgroundColour())
2442 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2444 return m_defGridAttr
->GetBackgroundColour();
2448 wxFAIL_MSG(wxT("Missing default cell attribute"));
2449 return wxNullColour
;
2453 const wxFont
& wxGridCellAttr::GetFont() const
2459 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2461 return m_defGridAttr
->GetFont();
2465 wxFAIL_MSG(wxT("Missing default cell attribute"));
2470 void wxGridCellAttr::GetAlignment(int *hAlign
, int *vAlign
) const
2479 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2481 m_defGridAttr
->GetAlignment(hAlign
, vAlign
);
2485 wxFAIL_MSG(wxT("Missing default cell attribute"));
2489 void wxGridCellAttr::GetSize( int *num_rows
, int *num_cols
) const
2492 *num_rows
= m_sizeRows
;
2494 *num_cols
= m_sizeCols
;
2497 // GetRenderer and GetEditor use a slightly different decision path about
2498 // which attribute to use. If a non-default attr object has one then it is
2499 // used, otherwise the default editor or renderer is fetched from the grid and
2500 // used. It should be the default for the data type of the cell. If it is
2501 // NULL (because the table has a type that the grid does not have in its
2502 // registry), then the grid's default editor or renderer is used.
2504 wxGridCellRenderer
* wxGridCellAttr::GetRenderer(const wxGrid
* grid
, int row
, int col
) const
2506 wxGridCellRenderer
*renderer
= NULL
;
2508 if ( m_renderer
&& this != m_defGridAttr
)
2510 // use the cells renderer if it has one
2511 renderer
= m_renderer
;
2514 else // no non-default cell renderer
2516 // get default renderer for the data type
2519 // GetDefaultRendererForCell() will do IncRef() for us
2520 renderer
= grid
->GetDefaultRendererForCell(row
, col
);
2523 if ( renderer
== NULL
)
2525 if ( (m_defGridAttr
!= NULL
) && (m_defGridAttr
!= this) )
2527 // if we still don't have one then use the grid default
2528 // (no need for IncRef() here neither)
2529 renderer
= m_defGridAttr
->GetRenderer(NULL
, 0, 0);
2531 else // default grid attr
2533 // use m_renderer which we had decided not to use initially
2534 renderer
= m_renderer
;
2541 // we're supposed to always find something
2542 wxASSERT_MSG(renderer
, wxT("Missing default cell renderer"));
2547 // same as above, except for s/renderer/editor/g
2548 wxGridCellEditor
* wxGridCellAttr::GetEditor(const wxGrid
* grid
, int row
, int col
) const
2550 wxGridCellEditor
*editor
= NULL
;
2552 if ( m_editor
&& this != m_defGridAttr
)
2554 // use the cells editor if it has one
2558 else // no non default cell editor
2560 // get default editor for the data type
2563 // GetDefaultEditorForCell() will do IncRef() for us
2564 editor
= grid
->GetDefaultEditorForCell(row
, col
);
2567 if ( editor
== NULL
)
2569 if ( (m_defGridAttr
!= NULL
) && (m_defGridAttr
!= this) )
2571 // if we still don't have one then use the grid default
2572 // (no need for IncRef() here neither)
2573 editor
= m_defGridAttr
->GetEditor(NULL
, 0, 0);
2575 else // default grid attr
2577 // use m_editor which we had decided not to use initially
2585 // we're supposed to always find something
2586 wxASSERT_MSG(editor
, wxT("Missing default cell editor"));
2591 // ----------------------------------------------------------------------------
2592 // wxGridCellAttrData
2593 // ----------------------------------------------------------------------------
2595 void wxGridCellAttrData::SetAttr(wxGridCellAttr
*attr
, int row
, int col
)
2597 int n
= FindIndex(row
, col
);
2598 if ( n
== wxNOT_FOUND
)
2600 // add the attribute
2601 m_attrs
.Add(new wxGridCellWithAttr(row
, col
, attr
));
2605 // free the old attribute
2606 m_attrs
[(size_t)n
].attr
->DecRef();
2610 // change the attribute
2611 m_attrs
[(size_t)n
].attr
= attr
;
2615 // remove this attribute
2616 m_attrs
.RemoveAt((size_t)n
);
2621 wxGridCellAttr
*wxGridCellAttrData::GetAttr(int row
, int col
) const
2623 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2625 int n
= FindIndex(row
, col
);
2626 if ( n
!= wxNOT_FOUND
)
2628 attr
= m_attrs
[(size_t)n
].attr
;
2635 void wxGridCellAttrData::UpdateAttrRows( size_t pos
, int numRows
)
2637 size_t count
= m_attrs
.GetCount();
2638 for ( size_t n
= 0; n
< count
; n
++ )
2640 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2641 wxCoord row
= coords
.GetRow();
2642 if ((size_t)row
>= pos
)
2646 // If rows inserted, include row counter where necessary
2647 coords
.SetRow(row
+ numRows
);
2649 else if (numRows
< 0)
2651 // If rows deleted ...
2652 if ((size_t)row
>= pos
- numRows
)
2654 // ...either decrement row counter (if row still exists)...
2655 coords
.SetRow(row
+ numRows
);
2659 // ...or remove the attribute
2660 // No need to DecRef the attribute itself since this is
2661 // done be wxGridCellWithAttr's destructor!
2662 m_attrs
.RemoveAt(n
);
2671 void wxGridCellAttrData::UpdateAttrCols( size_t pos
, int numCols
)
2673 size_t count
= m_attrs
.GetCount();
2674 for ( size_t n
= 0; n
< count
; n
++ )
2676 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2677 wxCoord col
= coords
.GetCol();
2678 if ( (size_t)col
>= pos
)
2682 // If rows inserted, include row counter where necessary
2683 coords
.SetCol(col
+ numCols
);
2685 else if (numCols
< 0)
2687 // If rows deleted ...
2688 if ((size_t)col
>= pos
- numCols
)
2690 // ...either decrement row counter (if row still exists)...
2691 coords
.SetCol(col
+ numCols
);
2695 // ...or remove the attribute
2696 // No need to DecRef the attribute itself since this is
2697 // done be wxGridCellWithAttr's destructor!
2698 m_attrs
.RemoveAt(n
);
2707 int wxGridCellAttrData::FindIndex(int row
, int col
) const
2709 size_t count
= m_attrs
.GetCount();
2710 for ( size_t n
= 0; n
< count
; n
++ )
2712 const wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2713 if ( (coords
.GetRow() == row
) && (coords
.GetCol() == col
) )
2722 // ----------------------------------------------------------------------------
2723 // wxGridRowOrColAttrData
2724 // ----------------------------------------------------------------------------
2726 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2728 size_t count
= m_attrs
.GetCount();
2729 for ( size_t n
= 0; n
< count
; n
++ )
2731 m_attrs
[n
]->DecRef();
2735 wxGridCellAttr
*wxGridRowOrColAttrData::GetAttr(int rowOrCol
) const
2737 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2739 int n
= m_rowsOrCols
.Index(rowOrCol
);
2740 if ( n
!= wxNOT_FOUND
)
2742 attr
= m_attrs
[(size_t)n
];
2749 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr
*attr
, int rowOrCol
)
2751 int i
= m_rowsOrCols
.Index(rowOrCol
);
2752 if ( i
== wxNOT_FOUND
)
2756 // add the attribute
2757 m_rowsOrCols
.Add(rowOrCol
);
2760 // nothing to remove
2764 size_t n
= (size_t)i
;
2767 // change the attribute
2768 m_attrs
[n
]->DecRef();
2773 // remove this attribute
2774 m_attrs
[n
]->DecRef();
2775 m_rowsOrCols
.RemoveAt(n
);
2776 m_attrs
.RemoveAt(n
);
2781 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
)
2783 size_t count
= m_attrs
.GetCount();
2784 for ( size_t n
= 0; n
< count
; n
++ )
2786 int & rowOrCol
= m_rowsOrCols
[n
];
2787 if ( (size_t)rowOrCol
>= pos
)
2789 if ( numRowsOrCols
> 0 )
2791 // If rows inserted, include row counter where necessary
2792 rowOrCol
+= numRowsOrCols
;
2794 else if ( numRowsOrCols
< 0)
2796 // If rows deleted, either decrement row counter (if row still exists)
2797 if ((size_t)rowOrCol
>= pos
- numRowsOrCols
)
2798 rowOrCol
+= numRowsOrCols
;
2801 m_rowsOrCols
.RemoveAt(n
);
2802 m_attrs
[n
]->DecRef();
2803 m_attrs
.RemoveAt(n
);
2812 // ----------------------------------------------------------------------------
2813 // wxGridCellAttrProvider
2814 // ----------------------------------------------------------------------------
2816 wxGridCellAttrProvider::wxGridCellAttrProvider()
2818 m_data
= (wxGridCellAttrProviderData
*)NULL
;
2821 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2826 void wxGridCellAttrProvider::InitData()
2828 m_data
= new wxGridCellAttrProviderData
;
2831 wxGridCellAttr
*wxGridCellAttrProvider::GetAttr(int row
, int col
,
2832 wxGridCellAttr::wxAttrKind kind
) const
2834 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2839 case (wxGridCellAttr::Any
):
2840 // Get cached merge attributes.
2841 // Currently not used as no cache implemented as not mutable
2842 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2845 // Basically implement old version.
2846 // Also check merge cache, so we don't have to re-merge every time..
2847 wxGridCellAttr
*attrcell
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2848 wxGridCellAttr
*attrrow
= m_data
->m_rowAttrs
.GetAttr(row
);
2849 wxGridCellAttr
*attrcol
= m_data
->m_colAttrs
.GetAttr(col
);
2851 if ((attrcell
!= attrrow
) && (attrrow
!= attrcol
) && (attrcell
!= attrcol
))
2853 // Two or more are non NULL
2854 attr
= new wxGridCellAttr
;
2855 attr
->SetKind(wxGridCellAttr::Merged
);
2857 // Order is important..
2860 attr
->MergeWith(attrcell
);
2865 attr
->MergeWith(attrcol
);
2870 attr
->MergeWith(attrrow
);
2874 // store merge attr if cache implemented
2876 //m_data->m_mergeAttr.SetAttr(attr, row, col);
2880 // one or none is non null return it or null.
2899 case (wxGridCellAttr::Cell
):
2900 attr
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2903 case (wxGridCellAttr::Col
):
2904 attr
= m_data
->m_colAttrs
.GetAttr(col
);
2907 case (wxGridCellAttr::Row
):
2908 attr
= m_data
->m_rowAttrs
.GetAttr(row
);
2913 // (wxGridCellAttr::Default):
2914 // (wxGridCellAttr::Merged):
2922 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr
*attr
,
2928 m_data
->m_cellAttrs
.SetAttr(attr
, row
, col
);
2931 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2936 m_data
->m_rowAttrs
.SetAttr(attr
, row
);
2939 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr
*attr
, int col
)
2944 m_data
->m_colAttrs
.SetAttr(attr
, col
);
2947 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos
, int numRows
)
2951 m_data
->m_cellAttrs
.UpdateAttrRows( pos
, numRows
);
2953 m_data
->m_rowAttrs
.UpdateAttrRowsOrCols( pos
, numRows
);
2957 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos
, int numCols
)
2961 m_data
->m_cellAttrs
.UpdateAttrCols( pos
, numCols
);
2963 m_data
->m_colAttrs
.UpdateAttrRowsOrCols( pos
, numCols
);
2967 // ----------------------------------------------------------------------------
2968 // wxGridTypeRegistry
2969 // ----------------------------------------------------------------------------
2971 wxGridTypeRegistry::~wxGridTypeRegistry()
2973 size_t count
= m_typeinfo
.GetCount();
2974 for ( size_t i
= 0; i
< count
; i
++ )
2975 delete m_typeinfo
[i
];
2978 void wxGridTypeRegistry::RegisterDataType(const wxString
& typeName
,
2979 wxGridCellRenderer
* renderer
,
2980 wxGridCellEditor
* editor
)
2982 wxGridDataTypeInfo
* info
= new wxGridDataTypeInfo(typeName
, renderer
, editor
);
2984 // is it already registered?
2985 int loc
= FindRegisteredDataType(typeName
);
2986 if ( loc
!= wxNOT_FOUND
)
2988 delete m_typeinfo
[loc
];
2989 m_typeinfo
[loc
] = info
;
2993 m_typeinfo
.Add(info
);
2997 int wxGridTypeRegistry::FindRegisteredDataType(const wxString
& typeName
)
2999 size_t count
= m_typeinfo
.GetCount();
3000 for ( size_t i
= 0; i
< count
; i
++ )
3002 if ( typeName
== m_typeinfo
[i
]->m_typeName
)
3011 int wxGridTypeRegistry::FindDataType(const wxString
& typeName
)
3013 int index
= FindRegisteredDataType(typeName
);
3014 if ( index
== wxNOT_FOUND
)
3016 // check whether this is one of the standard ones, in which case
3017 // register it "on the fly"
3019 if ( typeName
== wxGRID_VALUE_STRING
)
3021 RegisterDataType(wxGRID_VALUE_STRING
,
3022 new wxGridCellStringRenderer
,
3023 new wxGridCellTextEditor
);
3026 #endif // wxUSE_TEXTCTRL
3028 if ( typeName
== wxGRID_VALUE_BOOL
)
3030 RegisterDataType(wxGRID_VALUE_BOOL
,
3031 new wxGridCellBoolRenderer
,
3032 new wxGridCellBoolEditor
);
3035 #endif // wxUSE_CHECKBOX
3037 if ( typeName
== wxGRID_VALUE_NUMBER
)
3039 RegisterDataType(wxGRID_VALUE_NUMBER
,
3040 new wxGridCellNumberRenderer
,
3041 new wxGridCellNumberEditor
);
3043 else if ( typeName
== wxGRID_VALUE_FLOAT
)
3045 RegisterDataType(wxGRID_VALUE_FLOAT
,
3046 new wxGridCellFloatRenderer
,
3047 new wxGridCellFloatEditor
);
3050 #endif // wxUSE_TEXTCTRL
3052 if ( typeName
== wxGRID_VALUE_CHOICE
)
3054 RegisterDataType(wxGRID_VALUE_CHOICE
,
3055 new wxGridCellStringRenderer
,
3056 new wxGridCellChoiceEditor
);
3059 #endif // wxUSE_COMBOBOX
3064 // we get here only if just added the entry for this type, so return
3066 index
= m_typeinfo
.GetCount() - 1;
3072 int wxGridTypeRegistry::FindOrCloneDataType(const wxString
& typeName
)
3074 int index
= FindDataType(typeName
);
3075 if ( index
== wxNOT_FOUND
)
3077 // the first part of the typename is the "real" type, anything after ':'
3078 // are the parameters for the renderer
3079 index
= FindDataType(typeName
.BeforeFirst(_T(':')));
3080 if ( index
== wxNOT_FOUND
)
3085 wxGridCellRenderer
*renderer
= GetRenderer(index
);
3086 wxGridCellRenderer
*rendererOld
= renderer
;
3087 renderer
= renderer
->Clone();
3088 rendererOld
->DecRef();
3090 wxGridCellEditor
*editor
= GetEditor(index
);
3091 wxGridCellEditor
*editorOld
= editor
;
3092 editor
= editor
->Clone();
3093 editorOld
->DecRef();
3095 // do it even if there are no parameters to reset them to defaults
3096 wxString params
= typeName
.AfterFirst(_T(':'));
3097 renderer
->SetParameters(params
);
3098 editor
->SetParameters(params
);
3100 // register the new typename
3101 RegisterDataType(typeName
, renderer
, editor
);
3103 // we just registered it, it's the last one
3104 index
= m_typeinfo
.GetCount() - 1;
3110 wxGridCellRenderer
* wxGridTypeRegistry::GetRenderer(int index
)
3112 wxGridCellRenderer
* renderer
= m_typeinfo
[index
]->m_renderer
;
3119 wxGridCellEditor
* wxGridTypeRegistry::GetEditor(int index
)
3121 wxGridCellEditor
* editor
= m_typeinfo
[index
]->m_editor
;
3128 // ----------------------------------------------------------------------------
3130 // ----------------------------------------------------------------------------
3132 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase
, wxObject
)
3134 wxGridTableBase::wxGridTableBase()
3136 m_view
= (wxGrid
*) NULL
;
3137 m_attrProvider
= (wxGridCellAttrProvider
*) NULL
;
3140 wxGridTableBase::~wxGridTableBase()
3142 delete m_attrProvider
;
3145 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider
*attrProvider
)
3147 delete m_attrProvider
;
3148 m_attrProvider
= attrProvider
;
3151 bool wxGridTableBase::CanHaveAttributes()
3153 if ( ! GetAttrProvider() )
3155 // use the default attr provider by default
3156 SetAttrProvider(new wxGridCellAttrProvider
);
3162 wxGridCellAttr
*wxGridTableBase::GetAttr(int row
, int col
, wxGridCellAttr::wxAttrKind kind
)
3164 if ( m_attrProvider
)
3165 return m_attrProvider
->GetAttr(row
, col
, kind
);
3167 return (wxGridCellAttr
*)NULL
;
3170 void wxGridTableBase::SetAttr(wxGridCellAttr
* attr
, int row
, int col
)
3172 if ( m_attrProvider
)
3174 attr
->SetKind(wxGridCellAttr::Cell
);
3175 m_attrProvider
->SetAttr(attr
, row
, col
);
3179 // as we take ownership of the pointer and don't store it, we must
3185 void wxGridTableBase::SetRowAttr(wxGridCellAttr
*attr
, int row
)
3187 if ( m_attrProvider
)
3189 attr
->SetKind(wxGridCellAttr::Row
);
3190 m_attrProvider
->SetRowAttr(attr
, row
);
3194 // as we take ownership of the pointer and don't store it, we must
3200 void wxGridTableBase::SetColAttr(wxGridCellAttr
*attr
, int col
)
3202 if ( m_attrProvider
)
3204 attr
->SetKind(wxGridCellAttr::Col
);
3205 m_attrProvider
->SetColAttr(attr
, col
);
3209 // as we take ownership of the pointer and don't store it, we must
3215 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos
),
3216 size_t WXUNUSED(numRows
) )
3218 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
3223 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows
) )
3225 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
3230 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos
),
3231 size_t WXUNUSED(numRows
) )
3233 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
3238 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos
),
3239 size_t WXUNUSED(numCols
) )
3241 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
3246 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols
) )
3248 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
3253 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos
),
3254 size_t WXUNUSED(numCols
) )
3256 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
3261 wxString
wxGridTableBase::GetRowLabelValue( int row
)
3265 // RD: Starting the rows at zero confuses users,
3266 // no matter how much it makes sense to us geeks.
3272 wxString
wxGridTableBase::GetColLabelValue( int col
)
3274 // default col labels are:
3275 // cols 0 to 25 : A-Z
3276 // cols 26 to 675 : AA-ZZ
3281 for ( n
= 1; ; n
++ )
3283 s
+= (wxChar
) (_T('A') + (wxChar
)(col
% 26));
3289 // reverse the string...
3291 for ( i
= 0; i
< n
; i
++ )
3299 wxString
wxGridTableBase::GetTypeName( int WXUNUSED(row
), int WXUNUSED(col
) )
3301 return wxGRID_VALUE_STRING
;
3304 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row
), int WXUNUSED(col
),
3305 const wxString
& typeName
)
3307 return typeName
== wxGRID_VALUE_STRING
;
3310 bool wxGridTableBase::CanSetValueAs( int row
, int col
, const wxString
& typeName
)
3312 return CanGetValueAs(row
, col
, typeName
);
3315 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
) )
3320 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
) )
3325 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
) )
3330 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
),
3331 long WXUNUSED(value
) )
3335 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
),
3336 double WXUNUSED(value
) )
3340 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
),
3341 bool WXUNUSED(value
) )
3345 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3346 const wxString
& WXUNUSED(typeName
) )
3351 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3352 const wxString
& WXUNUSED(typeName
),
3353 void* WXUNUSED(value
) )
3357 //////////////////////////////////////////////////////////////////////
3359 // Message class for the grid table to send requests and notifications
3363 wxGridTableMessage::wxGridTableMessage()
3365 m_table
= (wxGridTableBase
*) NULL
;
3371 wxGridTableMessage::wxGridTableMessage( wxGridTableBase
*table
, int id
,
3372 int commandInt1
, int commandInt2
)
3376 m_comInt1
= commandInt1
;
3377 m_comInt2
= commandInt2
;
3380 //////////////////////////////////////////////////////////////////////
3382 // A basic grid table for string data. An object of this class will
3383 // created by wxGrid if you don't specify an alternative table class.
3386 WX_DEFINE_OBJARRAY(wxGridStringArray
)
3388 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable
, wxGridTableBase
)
3390 wxGridStringTable::wxGridStringTable()
3395 wxGridStringTable::wxGridStringTable( int numRows
, int numCols
)
3398 m_data
.Alloc( numRows
);
3401 sa
.Alloc( numCols
);
3402 sa
.Add( wxEmptyString
, numCols
);
3404 m_data
.Add( sa
, numRows
);
3407 wxGridStringTable::~wxGridStringTable()
3411 int wxGridStringTable::GetNumberRows()
3413 return m_data
.GetCount();
3416 int wxGridStringTable::GetNumberCols()
3418 if ( m_data
.GetCount() > 0 )
3419 return m_data
[0].GetCount();
3424 wxString
wxGridStringTable::GetValue( int row
, int col
)
3426 wxCHECK_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3428 _T("invalid row or column index in wxGridStringTable") );
3430 return m_data
[row
][col
];
3433 void wxGridStringTable::SetValue( int row
, int col
, const wxString
& value
)
3435 wxCHECK_RET( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3436 _T("invalid row or column index in wxGridStringTable") );
3438 m_data
[row
][col
] = value
;
3441 bool wxGridStringTable::IsEmptyCell( int row
, int col
)
3443 wxCHECK_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3445 _T("invalid row or column index in wxGridStringTable") );
3447 return (m_data
[row
][col
] == wxEmptyString
);
3450 void wxGridStringTable::Clear()
3453 int numRows
, numCols
;
3455 numRows
= m_data
.GetCount();
3458 numCols
= m_data
[0].GetCount();
3460 for ( row
= 0; row
< numRows
; row
++ )
3462 for ( col
= 0; col
< numCols
; col
++ )
3464 m_data
[row
][col
] = wxEmptyString
;
3470 bool wxGridStringTable::InsertRows( size_t pos
, size_t numRows
)
3472 size_t curNumRows
= m_data
.GetCount();
3473 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3474 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3476 if ( pos
>= curNumRows
)
3478 return AppendRows( numRows
);
3482 sa
.Alloc( curNumCols
);
3483 sa
.Add( wxEmptyString
, curNumCols
);
3484 m_data
.Insert( sa
, pos
, numRows
);
3488 wxGridTableMessage
msg( this,
3489 wxGRIDTABLE_NOTIFY_ROWS_INSERTED
,
3493 GetView()->ProcessTableMessage( msg
);
3499 bool wxGridStringTable::AppendRows( size_t numRows
)
3501 size_t curNumRows
= m_data
.GetCount();
3502 size_t curNumCols
= ( curNumRows
> 0
3503 ? m_data
[0].GetCount()
3504 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3507 if ( curNumCols
> 0 )
3509 sa
.Alloc( curNumCols
);
3510 sa
.Add( wxEmptyString
, curNumCols
);
3513 m_data
.Add( sa
, numRows
);
3517 wxGridTableMessage
msg( this,
3518 wxGRIDTABLE_NOTIFY_ROWS_APPENDED
,
3521 GetView()->ProcessTableMessage( msg
);
3527 bool wxGridStringTable::DeleteRows( size_t pos
, size_t numRows
)
3529 size_t curNumRows
= m_data
.GetCount();
3531 if ( pos
>= curNumRows
)
3533 wxFAIL_MSG( wxString::Format
3535 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
3537 (unsigned long)numRows
,
3538 (unsigned long)curNumRows
3544 if ( numRows
> curNumRows
- pos
)
3546 numRows
= curNumRows
- pos
;
3549 if ( numRows
>= curNumRows
)
3555 m_data
.RemoveAt( pos
, numRows
);
3560 wxGridTableMessage
msg( this,
3561 wxGRIDTABLE_NOTIFY_ROWS_DELETED
,
3565 GetView()->ProcessTableMessage( msg
);
3571 bool wxGridStringTable::InsertCols( size_t pos
, size_t numCols
)
3575 size_t curNumRows
= m_data
.GetCount();
3576 size_t curNumCols
= ( curNumRows
> 0
3577 ? m_data
[0].GetCount()
3578 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3580 if ( pos
>= curNumCols
)
3582 return AppendCols( numCols
);
3585 if ( !m_colLabels
.IsEmpty() )
3587 m_colLabels
.Insert( wxEmptyString
, pos
, numCols
);
3590 for ( i
= pos
; i
< pos
+ numCols
; i
++ )
3591 m_colLabels
[i
] = wxGridTableBase::GetColLabelValue( i
);
3594 for ( row
= 0; row
< curNumRows
; row
++ )
3596 for ( col
= pos
; col
< pos
+ numCols
; col
++ )
3598 m_data
[row
].Insert( wxEmptyString
, col
);
3604 wxGridTableMessage
msg( this,
3605 wxGRIDTABLE_NOTIFY_COLS_INSERTED
,
3609 GetView()->ProcessTableMessage( msg
);
3615 bool wxGridStringTable::AppendCols( size_t numCols
)
3619 size_t curNumRows
= m_data
.GetCount();
3624 // TODO: something better than this ?
3626 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3631 for ( row
= 0; row
< curNumRows
; row
++ )
3633 m_data
[row
].Add( wxEmptyString
, numCols
);
3638 wxGridTableMessage
msg( this,
3639 wxGRIDTABLE_NOTIFY_COLS_APPENDED
,
3642 GetView()->ProcessTableMessage( msg
);
3648 bool wxGridStringTable::DeleteCols( size_t pos
, size_t numCols
)
3652 size_t curNumRows
= m_data
.GetCount();
3653 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3654 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3656 if ( pos
>= curNumCols
)
3658 wxFAIL_MSG( wxString::Format
3660 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
3662 (unsigned long)numCols
,
3663 (unsigned long)curNumCols
3670 colID
= GetView()->GetColAt( pos
);
3674 if ( numCols
> curNumCols
- colID
)
3676 numCols
= curNumCols
- colID
;
3679 if ( !m_colLabels
.IsEmpty() )
3681 // m_colLabels stores just as many elements as it needs, e.g. if only
3682 // the label of the first column had been set it would have only one
3683 // element and not numCols, so account for it
3684 int nToRm
= m_colLabels
.size() - colID
;
3686 m_colLabels
.RemoveAt( colID
, nToRm
);
3689 for ( row
= 0; row
< curNumRows
; row
++ )
3691 if ( numCols
>= curNumCols
)
3693 m_data
[row
].Clear();
3697 m_data
[row
].RemoveAt( colID
, numCols
);
3703 wxGridTableMessage
msg( this,
3704 wxGRIDTABLE_NOTIFY_COLS_DELETED
,
3708 GetView()->ProcessTableMessage( msg
);
3714 wxString
wxGridStringTable::GetRowLabelValue( int row
)
3716 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3718 // using default label
3720 return wxGridTableBase::GetRowLabelValue( row
);
3724 return m_rowLabels
[row
];
3728 wxString
wxGridStringTable::GetColLabelValue( int col
)
3730 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3732 // using default label
3734 return wxGridTableBase::GetColLabelValue( col
);
3738 return m_colLabels
[col
];
3742 void wxGridStringTable::SetRowLabelValue( int row
, const wxString
& value
)
3744 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3746 int n
= m_rowLabels
.GetCount();
3749 for ( i
= n
; i
<= row
; i
++ )
3751 m_rowLabels
.Add( wxGridTableBase::GetRowLabelValue(i
) );
3755 m_rowLabels
[row
] = value
;
3758 void wxGridStringTable::SetColLabelValue( int col
, const wxString
& value
)
3760 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3762 int n
= m_colLabels
.GetCount();
3765 for ( i
= n
; i
<= col
; i
++ )
3767 m_colLabels
.Add( wxGridTableBase::GetColLabelValue(i
) );
3771 m_colLabels
[col
] = value
;
3775 //////////////////////////////////////////////////////////////////////
3776 //////////////////////////////////////////////////////////////////////
3778 BEGIN_EVENT_TABLE(wxGridSubwindow
, wxWindow
)
3779 EVT_MOUSE_CAPTURE_LOST(wxGridSubwindow::OnMouseCaptureLost
)
3782 void wxGridSubwindow::OnMouseCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
3784 m_owner
->CancelMouseCapture();
3787 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow
, wxWindow
)
3789 BEGIN_EVENT_TABLE( wxGridRowLabelWindow
, wxGridSubwindow
)
3790 EVT_PAINT( wxGridRowLabelWindow::OnPaint
)
3791 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel
)
3792 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent
)
3793 EVT_KEY_DOWN( wxGridRowLabelWindow::OnKeyDown
)
3794 EVT_KEY_UP( wxGridRowLabelWindow::OnKeyUp
)
3795 EVT_CHAR( wxGridRowLabelWindow::OnChar
)
3798 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid
*parent
,
3800 const wxPoint
&pos
, const wxSize
&size
)
3801 : wxGridSubwindow(parent
, id
, pos
, size
)
3806 void wxGridRowLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3810 // NO - don't do this because it will set both the x and y origin
3811 // coords to match the parent scrolled window and we just want to
3812 // set the y coord - MB
3814 // m_owner->PrepareDC( dc );
3817 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3818 wxPoint pt
= dc
.GetDeviceOrigin();
3819 dc
.SetDeviceOrigin( pt
.x
, pt
.y
-y
);
3821 wxArrayInt rows
= m_owner
->CalcRowLabelsExposed( GetUpdateRegion() );
3822 m_owner
->DrawRowLabels( dc
, rows
);
3825 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3827 m_owner
->ProcessRowLabelMouseEvent( event
);
3830 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3832 m_owner
->GetEventHandler()->ProcessEvent( event
);
3835 // This seems to be required for wxMotif otherwise the mouse
3836 // cursor must be in the cell edit control to get key events
3838 void wxGridRowLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3840 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
3844 void wxGridRowLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3846 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
3850 void wxGridRowLabelWindow::OnChar( wxKeyEvent
& event
)
3852 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
3856 //////////////////////////////////////////////////////////////////////
3858 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow
, wxWindow
)
3860 BEGIN_EVENT_TABLE( wxGridColLabelWindow
, wxGridSubwindow
)
3861 EVT_PAINT( wxGridColLabelWindow::OnPaint
)
3862 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel
)
3863 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent
)
3864 EVT_KEY_DOWN( wxGridColLabelWindow::OnKeyDown
)
3865 EVT_KEY_UP( wxGridColLabelWindow::OnKeyUp
)
3866 EVT_CHAR( wxGridColLabelWindow::OnChar
)
3869 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid
*parent
,
3871 const wxPoint
&pos
, const wxSize
&size
)
3872 : wxGridSubwindow(parent
, id
, pos
, size
)
3877 void wxGridColLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3881 // NO - don't do this because it will set both the x and y origin
3882 // coords to match the parent scrolled window and we just want to
3883 // set the x coord - MB
3885 // m_owner->PrepareDC( dc );
3888 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3889 wxPoint pt
= dc
.GetDeviceOrigin();
3890 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3891 dc
.SetDeviceOrigin( pt
.x
+x
, pt
.y
);
3893 dc
.SetDeviceOrigin( pt
.x
-x
, pt
.y
);
3895 wxArrayInt cols
= m_owner
->CalcColLabelsExposed( GetUpdateRegion() );
3896 m_owner
->DrawColLabels( dc
, cols
);
3899 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3901 m_owner
->ProcessColLabelMouseEvent( event
);
3904 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3906 m_owner
->GetEventHandler()->ProcessEvent( event
);
3909 // This seems to be required for wxMotif otherwise the mouse
3910 // cursor must be in the cell edit control to get key events
3912 void wxGridColLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3914 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
3918 void wxGridColLabelWindow::OnKeyUp( wxKeyEvent
& event
)
3920 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
3924 void wxGridColLabelWindow::OnChar( wxKeyEvent
& event
)
3926 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
3930 //////////////////////////////////////////////////////////////////////
3932 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow
, wxWindow
)
3934 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow
, wxGridSubwindow
)
3935 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel
)
3936 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent
)
3937 EVT_PAINT( wxGridCornerLabelWindow::OnPaint
)
3938 EVT_KEY_DOWN( wxGridCornerLabelWindow::OnKeyDown
)
3939 EVT_KEY_UP( wxGridCornerLabelWindow::OnKeyUp
)
3940 EVT_CHAR( wxGridCornerLabelWindow::OnChar
)
3943 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid
*parent
,
3945 const wxPoint
&pos
, const wxSize
&size
)
3946 : wxGridSubwindow(parent
, id
, pos
, size
)
3951 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3955 int client_height
= 0;
3956 int client_width
= 0;
3957 GetClientSize( &client_width
, &client_height
);
3959 // VZ: any reason for this ifdef? (FIXME)
3965 rect
.SetWidth( client_width
- 2 );
3966 rect
.SetHeight( client_height
- 2 );
3968 wxRendererNative::Get().DrawHeaderButton( this, dc
, rect
, 0 );
3970 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
), 1, wxSOLID
) );
3971 dc
.DrawLine( client_width
- 1, client_height
- 1, client_width
- 1, 0 );
3972 dc
.DrawLine( client_width
- 1, client_height
- 1, 0, client_height
- 1 );
3973 dc
.DrawLine( 0, 0, client_width
, 0 );
3974 dc
.DrawLine( 0, 0, 0, client_height
);
3976 dc
.SetPen( *wxWHITE_PEN
);
3977 dc
.DrawLine( 1, 1, client_width
- 1, 1 );
3978 dc
.DrawLine( 1, 1, 1, client_height
- 1 );
3982 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3984 m_owner
->ProcessCornerLabelMouseEvent( event
);
3987 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3989 m_owner
->GetEventHandler()->ProcessEvent(event
);
3992 // This seems to be required for wxMotif otherwise the mouse
3993 // cursor must be in the cell edit control to get key events
3995 void wxGridCornerLabelWindow::OnKeyDown( wxKeyEvent
& event
)
3997 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4001 void wxGridCornerLabelWindow::OnKeyUp( wxKeyEvent
& event
)
4003 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4007 void wxGridCornerLabelWindow::OnChar( wxKeyEvent
& event
)
4009 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4013 //////////////////////////////////////////////////////////////////////
4015 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow
, wxWindow
)
4017 BEGIN_EVENT_TABLE( wxGridWindow
, wxGridSubwindow
)
4018 EVT_PAINT( wxGridWindow::OnPaint
)
4019 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel
)
4020 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent
)
4021 EVT_KEY_DOWN( wxGridWindow::OnKeyDown
)
4022 EVT_KEY_UP( wxGridWindow::OnKeyUp
)
4023 EVT_CHAR( wxGridWindow::OnChar
)
4024 EVT_SET_FOCUS( wxGridWindow::OnFocus
)
4025 EVT_KILL_FOCUS( wxGridWindow::OnFocus
)
4026 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground
)
4029 wxGridWindow::wxGridWindow( wxGrid
*parent
,
4030 wxGridRowLabelWindow
*rowLblWin
,
4031 wxGridColLabelWindow
*colLblWin
,
4034 const wxSize
&size
)
4035 : wxGridSubwindow(parent
, id
, pos
, size
,
4036 wxCLIP_CHILDREN
, wxT("grid window") )
4039 m_rowLabelWin
= rowLblWin
;
4040 m_colLabelWin
= colLblWin
;
4043 void wxGridWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
4045 wxPaintDC
dc( this );
4046 m_owner
->PrepareDC( dc
);
4047 wxRegion reg
= GetUpdateRegion();
4048 wxGridCellCoordsArray dirtyCells
= m_owner
->CalcCellsExposed( reg
);
4049 m_owner
->DrawGridCellArea( dc
, dirtyCells
);
4051 #if WXGRID_DRAW_LINES
4052 m_owner
->DrawAllGridLines( dc
, reg
);
4055 m_owner
->DrawGridSpace( dc
);
4056 m_owner
->DrawHighlight( dc
, dirtyCells
);
4059 void wxGridWindow::ScrollWindow( int dx
, int dy
, const wxRect
*rect
)
4061 wxWindow::ScrollWindow( dx
, dy
, rect
);
4062 m_rowLabelWin
->ScrollWindow( 0, dy
, rect
);
4063 m_colLabelWin
->ScrollWindow( dx
, 0, rect
);
4066 void wxGridWindow::OnMouseEvent( wxMouseEvent
& event
)
4068 if (event
.ButtonDown(wxMOUSE_BTN_LEFT
) && FindFocus() != this)
4071 m_owner
->ProcessGridCellMouseEvent( event
);
4074 void wxGridWindow::OnMouseWheel( wxMouseEvent
& event
)
4076 m_owner
->GetEventHandler()->ProcessEvent( event
);
4079 // This seems to be required for wxMotif/wxGTK otherwise the mouse
4080 // cursor must be in the cell edit control to get key events
4082 void wxGridWindow::OnKeyDown( wxKeyEvent
& event
)
4084 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4088 void wxGridWindow::OnKeyUp( wxKeyEvent
& event
)
4090 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4094 void wxGridWindow::OnChar( wxKeyEvent
& event
)
4096 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4100 void wxGridWindow::OnEraseBackground( wxEraseEvent
& WXUNUSED(event
) )
4104 void wxGridWindow::OnFocus(wxFocusEvent
& event
)
4106 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4110 //////////////////////////////////////////////////////////////////////
4112 // Internal Helper function for computing row or column from some
4113 // (unscrolled) coordinate value, using either
4114 // m_defaultRowHeight/m_defaultColWidth or binary search on array
4115 // of m_rowBottoms/m_ColRights to speed up the search!
4117 // Internal helper macros for simpler use of that function
4119 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
4120 const wxArrayInt
& BorderArray
, int nMax
,
4123 #define internalXToCol(x) XToCol(x, true)
4124 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
4125 m_minAcceptableRowHeight, \
4126 m_rowBottoms, m_numRows, true)
4128 /////////////////////////////////////////////////////////////////////
4130 #if wxUSE_EXTENDED_RTTI
4131 WX_DEFINE_FLAGS( wxGridStyle
)
4133 wxBEGIN_FLAGS( wxGridStyle
)
4134 // new style border flags, we put them first to
4135 // use them for streaming out
4136 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
4137 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
4138 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
4139 wxFLAGS_MEMBER(wxBORDER_RAISED
)
4140 wxFLAGS_MEMBER(wxBORDER_STATIC
)
4141 wxFLAGS_MEMBER(wxBORDER_NONE
)
4143 // old style border flags
4144 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
4145 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
4146 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
4147 wxFLAGS_MEMBER(wxRAISED_BORDER
)
4148 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
4149 wxFLAGS_MEMBER(wxBORDER
)
4151 // standard window styles
4152 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
4153 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
4154 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
4155 wxFLAGS_MEMBER(wxWANTS_CHARS
)
4156 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
4157 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
4158 wxFLAGS_MEMBER(wxVSCROLL
)
4159 wxFLAGS_MEMBER(wxHSCROLL
)
4161 wxEND_FLAGS( wxGridStyle
)
4163 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid
, wxScrolledWindow
,"wx/grid.h")
4165 wxBEGIN_PROPERTIES_TABLE(wxGrid
)
4166 wxHIDE_PROPERTY( Children
)
4167 wxPROPERTY_FLAGS( WindowStyle
, wxGridStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
4168 wxEND_PROPERTIES_TABLE()
4170 wxBEGIN_HANDLERS_TABLE(wxGrid
)
4171 wxEND_HANDLERS_TABLE()
4173 wxCONSTRUCTOR_5( wxGrid
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
4176 TODO : Expose more information of a list's layout, etc. via appropriate objects (e.g., NotebookPageInfo)
4179 IMPLEMENT_DYNAMIC_CLASS( wxGrid
, wxScrolledWindow
)
4182 BEGIN_EVENT_TABLE( wxGrid
, wxScrolledWindow
)
4183 EVT_PAINT( wxGrid::OnPaint
)
4184 EVT_SIZE( wxGrid::OnSize
)
4185 EVT_KEY_DOWN( wxGrid::OnKeyDown
)
4186 EVT_KEY_UP( wxGrid::OnKeyUp
)
4187 EVT_CHAR ( wxGrid::OnChar
)
4188 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground
)
4193 // in order to make sure that a size event is not
4194 // trigerred in a unfinished state
4195 m_cornerLabelWin
= NULL
;
4196 m_rowLabelWin
= NULL
;
4197 m_colLabelWin
= NULL
;
4201 wxGrid::wxGrid( wxWindow
*parent
,
4206 const wxString
& name
)
4207 : wxScrolledWindow( parent
, id
, pos
, size
, (style
| wxWANTS_CHARS
), name
),
4208 m_colMinWidths(GRID_HASH_SIZE
),
4209 m_rowMinHeights(GRID_HASH_SIZE
)
4212 SetInitialSize(size
);
4215 bool wxGrid::Create(wxWindow
*parent
, wxWindowID id
,
4216 const wxPoint
& pos
, const wxSize
& size
,
4217 long style
, const wxString
& name
)
4219 if (!wxScrolledWindow::Create(parent
, id
, pos
, size
,
4220 style
| wxWANTS_CHARS
, name
))
4223 m_colMinWidths
= wxLongToLongHashMap(GRID_HASH_SIZE
);
4224 m_rowMinHeights
= wxLongToLongHashMap(GRID_HASH_SIZE
);
4227 SetInitialSize(size
);
4235 // Must do this or ~wxScrollHelper will pop the wrong event handler
4236 SetTargetWindow(this);
4238 wxSafeDecRef(m_defaultCellAttr
);
4240 #ifdef DEBUG_ATTR_CACHE
4241 size_t total
= gs_nAttrCacheHits
+ gs_nAttrCacheMisses
;
4242 wxPrintf(_T("wxGrid attribute cache statistics: "
4243 "total: %u, hits: %u (%u%%)\n"),
4244 total
, gs_nAttrCacheHits
,
4245 total
? (gs_nAttrCacheHits
*100) / total
: 0);
4248 // if we own the table, just delete it, otherwise at least don't leave it
4249 // with dangling view pointer
4252 else if ( m_table
&& m_table
->GetView() == this )
4253 m_table
->SetView(NULL
);
4255 delete m_typeRegistry
;
4260 // ----- internal init and update functions
4263 // NOTE: If using the default visual attributes works everywhere then this can
4264 // be removed as well as the #else cases below.
4265 #define _USE_VISATTR 0
4267 void wxGrid::Create()
4269 // set to true by CreateGrid
4272 // create the type registry
4273 m_typeRegistry
= new wxGridTypeRegistry
;
4276 m_table
= (wxGridTableBase
*) NULL
;
4279 m_cellEditCtrlEnabled
= false;
4281 m_defaultCellAttr
= new wxGridCellAttr();
4283 // Set default cell attributes
4284 m_defaultCellAttr
->SetDefAttr(m_defaultCellAttr
);
4285 m_defaultCellAttr
->SetKind(wxGridCellAttr::Default
);
4286 m_defaultCellAttr
->SetFont(GetFont());
4287 m_defaultCellAttr
->SetAlignment(wxALIGN_LEFT
, wxALIGN_TOP
);
4288 m_defaultCellAttr
->SetRenderer(new wxGridCellStringRenderer
);
4289 m_defaultCellAttr
->SetEditor(new wxGridCellTextEditor
);
4292 wxVisualAttributes gva
= wxListBox::GetClassDefaultAttributes();
4293 wxVisualAttributes lva
= wxPanel::GetClassDefaultAttributes();
4295 m_defaultCellAttr
->SetTextColour(gva
.colFg
);
4296 m_defaultCellAttr
->SetBackgroundColour(gva
.colBg
);
4299 m_defaultCellAttr
->SetTextColour(
4300 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
4301 m_defaultCellAttr
->SetBackgroundColour(
4302 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
4307 m_currentCellCoords
= wxGridNoCellCoords
;
4309 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
4310 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
4312 // subwindow components that make up the wxGrid
4313 m_rowLabelWin
= new wxGridRowLabelWindow( this,
4318 m_colLabelWin
= new wxGridColLabelWindow( this,
4323 m_cornerLabelWin
= new wxGridCornerLabelWindow( this,
4328 m_gridWin
= new wxGridWindow( this,
4335 SetTargetWindow( m_gridWin
);
4338 wxColour gfg
= gva
.colFg
;
4339 wxColour gbg
= gva
.colBg
;
4340 wxColour lfg
= lva
.colFg
;
4341 wxColour lbg
= lva
.colBg
;
4343 wxColour gfg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT
);
4344 wxColour gbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW
);
4345 wxColour lfg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT
);
4346 wxColour lbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE
);
4349 m_cornerLabelWin
->SetOwnForegroundColour(lfg
);
4350 m_cornerLabelWin
->SetOwnBackgroundColour(lbg
);
4351 m_rowLabelWin
->SetOwnForegroundColour(lfg
);
4352 m_rowLabelWin
->SetOwnBackgroundColour(lbg
);
4353 m_colLabelWin
->SetOwnForegroundColour(lfg
);
4354 m_colLabelWin
->SetOwnBackgroundColour(lbg
);
4356 m_gridWin
->SetOwnForegroundColour(gfg
);
4357 m_gridWin
->SetOwnBackgroundColour(gbg
);
4362 bool wxGrid::CreateGrid( int numRows
, int numCols
,
4363 wxGrid::wxGridSelectionModes selmode
)
4365 wxCHECK_MSG( !m_created
,
4367 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
4369 m_numRows
= numRows
;
4370 m_numCols
= numCols
;
4372 m_table
= new wxGridStringTable( m_numRows
, m_numCols
);
4373 m_table
->SetView( this );
4375 m_selection
= new wxGridSelection( this, selmode
);
4384 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode
)
4386 wxCHECK_RET( m_created
,
4387 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
4389 m_selection
->SetSelectionMode( selmode
);
4392 wxGrid::wxGridSelectionModes
wxGrid::GetSelectionMode() const
4394 wxCHECK_MSG( m_created
, wxGrid::wxGridSelectCells
,
4395 wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
4397 return m_selection
->GetSelectionMode();
4400 bool wxGrid::SetTable( wxGridTableBase
*table
, bool takeOwnership
,
4401 wxGrid::wxGridSelectionModes selmode
)
4403 bool checkSelection
= false;
4406 // stop all processing
4411 m_table
->SetView(0);
4423 checkSelection
= true;
4425 // kill row and column size arrays
4426 m_colWidths
.Empty();
4427 m_colRights
.Empty();
4428 m_rowHeights
.Empty();
4429 m_rowBottoms
.Empty();
4434 m_numRows
= table
->GetNumberRows();
4435 m_numCols
= table
->GetNumberCols();
4438 m_table
->SetView( this );
4439 m_ownTable
= takeOwnership
;
4440 m_selection
= new wxGridSelection( this, selmode
);
4443 // If the newly set table is smaller than the
4444 // original one current cell and selection regions
4445 // might be invalid,
4446 m_selectingKeyboard
= wxGridNoCellCoords
;
4447 m_currentCellCoords
=
4448 wxGridCellCoords(wxMin(m_numRows
, m_currentCellCoords
.GetRow()),
4449 wxMin(m_numCols
, m_currentCellCoords
.GetCol()));
4450 if (m_selectingTopLeft
.GetRow() >= m_numRows
||
4451 m_selectingTopLeft
.GetCol() >= m_numCols
)
4453 m_selectingTopLeft
= wxGridNoCellCoords
;
4454 m_selectingBottomRight
= wxGridNoCellCoords
;
4457 m_selectingBottomRight
=
4458 wxGridCellCoords(wxMin(m_numRows
,
4459 m_selectingBottomRight
.GetRow()),
4461 m_selectingBottomRight
.GetCol()));
4473 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
4474 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
4476 if ( m_rowLabelWin
)
4478 m_labelBackgroundColour
= m_rowLabelWin
->GetBackgroundColour();
4482 m_labelBackgroundColour
= *wxWHITE
;
4485 m_labelTextColour
= *wxBLACK
;
4488 m_attrCache
.row
= -1;
4489 m_attrCache
.col
= -1;
4490 m_attrCache
.attr
= NULL
;
4492 // TODO: something better than this ?
4494 m_labelFont
= this->GetFont();
4495 m_labelFont
.SetWeight( wxBOLD
);
4497 m_rowLabelHorizAlign
= wxALIGN_CENTRE
;
4498 m_rowLabelVertAlign
= wxALIGN_CENTRE
;
4500 m_colLabelHorizAlign
= wxALIGN_CENTRE
;
4501 m_colLabelVertAlign
= wxALIGN_CENTRE
;
4502 m_colLabelTextOrientation
= wxHORIZONTAL
;
4504 m_defaultColWidth
= WXGRID_DEFAULT_COL_WIDTH
;
4505 m_defaultRowHeight
= m_gridWin
->GetCharHeight();
4507 m_minAcceptableColWidth
= WXGRID_MIN_COL_WIDTH
;
4508 m_minAcceptableRowHeight
= WXGRID_MIN_ROW_HEIGHT
;
4510 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
4511 m_defaultRowHeight
+= 8;
4513 m_defaultRowHeight
+= 4;
4516 m_gridLineColour
= wxColour( 192,192,192 );
4517 m_gridLinesEnabled
= true;
4518 m_cellHighlightColour
= *wxBLACK
;
4519 m_cellHighlightPenWidth
= 2;
4520 m_cellHighlightROPenWidth
= 1;
4522 m_canDragColMove
= false;
4524 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
4525 m_winCapture
= (wxWindow
*)NULL
;
4526 m_canDragRowSize
= true;
4527 m_canDragColSize
= true;
4528 m_canDragGridSize
= true;
4529 m_canDragCell
= false;
4531 m_dragRowOrCol
= -1;
4532 m_isDragging
= false;
4533 m_startDragPos
= wxDefaultPosition
;
4535 m_waitForSlowClick
= false;
4537 m_rowResizeCursor
= wxCursor( wxCURSOR_SIZENS
);
4538 m_colResizeCursor
= wxCursor( wxCURSOR_SIZEWE
);
4540 m_currentCellCoords
= wxGridNoCellCoords
;
4544 m_selectionBackground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
4545 m_selectionForeground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
4547 m_editable
= true; // default for whole grid
4549 m_inOnKeyDown
= false;
4555 m_scrollLineX
= GRID_SCROLL_LINE_X
;
4556 m_scrollLineY
= GRID_SCROLL_LINE_Y
;
4559 // ----------------------------------------------------------------------------
4560 // the idea is to call these functions only when necessary because they create
4561 // quite big arrays which eat memory mostly unnecessary - in particular, if
4562 // default widths/heights are used for all rows/columns, we may not use these
4565 // with some extra code, it should be possible to only store the widths/heights
4566 // different from default ones (resulting in space savings for huge grids) but
4567 // this is not done currently
4568 // ----------------------------------------------------------------------------
4570 void wxGrid::InitRowHeights()
4572 m_rowHeights
.Empty();
4573 m_rowBottoms
.Empty();
4575 m_rowHeights
.Alloc( m_numRows
);
4576 m_rowBottoms
.Alloc( m_numRows
);
4578 m_rowHeights
.Add( m_defaultRowHeight
, m_numRows
);
4581 for ( int i
= 0; i
< m_numRows
; i
++ )
4583 rowBottom
+= m_defaultRowHeight
;
4584 m_rowBottoms
.Add( rowBottom
);
4588 void wxGrid::InitColWidths()
4590 m_colWidths
.Empty();
4591 m_colRights
.Empty();
4593 m_colWidths
.Alloc( m_numCols
);
4594 m_colRights
.Alloc( m_numCols
);
4596 m_colWidths
.Add( m_defaultColWidth
, m_numCols
);
4599 for ( int i
= 0; i
< m_numCols
; i
++ )
4601 colRight
= ( GetColPos( i
) + 1 ) * m_defaultColWidth
;
4602 m_colRights
.Add( colRight
);
4606 int wxGrid::GetColWidth(int col
) const
4608 return m_colWidths
.IsEmpty() ? m_defaultColWidth
: m_colWidths
[col
];
4611 int wxGrid::GetColLeft(int col
) const
4613 return m_colRights
.IsEmpty() ? GetColPos( col
) * m_defaultColWidth
4614 : m_colRights
[col
] - m_colWidths
[col
];
4617 int wxGrid::GetColRight(int col
) const
4619 return m_colRights
.IsEmpty() ? (GetColPos( col
) + 1) * m_defaultColWidth
4623 int wxGrid::GetRowHeight(int row
) const
4625 return m_rowHeights
.IsEmpty() ? m_defaultRowHeight
: m_rowHeights
[row
];
4628 int wxGrid::GetRowTop(int row
) const
4630 return m_rowBottoms
.IsEmpty() ? row
* m_defaultRowHeight
4631 : m_rowBottoms
[row
] - m_rowHeights
[row
];
4634 int wxGrid::GetRowBottom(int row
) const
4636 return m_rowBottoms
.IsEmpty() ? (row
+ 1) * m_defaultRowHeight
4637 : m_rowBottoms
[row
];
4640 void wxGrid::CalcDimensions()
4642 // compute the size of the scrollable area
4643 int w
= m_numCols
> 0 ? GetColRight(GetColAt(m_numCols
- 1)) : 0;
4644 int h
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0;
4649 // take into account editor if shown
4650 if ( IsCellEditControlShown() )
4653 int r
= m_currentCellCoords
.GetRow();
4654 int c
= m_currentCellCoords
.GetCol();
4655 int x
= GetColLeft(c
);
4656 int y
= GetRowTop(r
);
4658 // how big is the editor
4659 wxGridCellAttr
* attr
= GetCellAttr(r
, c
);
4660 wxGridCellEditor
* editor
= attr
->GetEditor(this, r
, c
);
4661 editor
->GetControl()->GetSize(&w2
, &h2
);
4672 // preserve (more or less) the previous position
4674 GetViewStart( &x
, &y
);
4676 // ensure the position is valid for the new scroll ranges
4678 x
= wxMax( w
- 1, 0 );
4680 y
= wxMax( h
- 1, 0 );
4682 // do set scrollbar parameters
4683 SetScrollbars( m_scrollLineX
, m_scrollLineY
,
4684 GetScrollX(w
), GetScrollY(h
),
4686 GetBatchCount() != 0);
4688 // if our OnSize() hadn't been called (it would if we have scrollbars), we
4689 // still must reposition the children
4693 void wxGrid::CalcWindowSizes()
4695 // escape if the window is has not been fully created yet
4697 if ( m_cornerLabelWin
== NULL
)
4701 GetClientSize( &cw
, &ch
);
4703 // this block of code tries to work around the following problem: the grid
4704 // could have been just resized to have enough space to show the full grid
4705 // window contents without the scrollbars, but its client size could be
4706 // not big enough because the grid has the scrollbars right now and so the
4707 // scrollbars would remain even though we don't need them any more
4709 // to prevent this from happening, check if we have enough space for
4710 // everything without the scrollbars and explicitly disable them then
4711 wxSize size
= GetSize() - GetWindowBorderSize();
4712 if ( size
!= wxSize(cw
, ch
) )
4714 // check if we have enough space for grid window after accounting for
4715 // the fixed size elements
4716 size
.x
-= m_rowLabelWidth
;
4717 size
.y
-= m_colLabelHeight
;
4719 const wxSize vsize
= m_gridWin
->GetVirtualSize();
4721 if ( size
.x
>= vsize
.x
&& size
.y
>= vsize
.y
)
4723 // yes, we do, so remove the scrollbars and use the new client size
4724 // (which should be the same as full window size - borders now)
4725 SetScrollbars(0, 0, 0, 0);
4726 GetClientSize(&cw
, &ch
);
4730 if ( m_cornerLabelWin
&& m_cornerLabelWin
->IsShown() )
4731 m_cornerLabelWin
->SetSize( 0, 0, m_rowLabelWidth
, m_colLabelHeight
);
4733 if ( m_colLabelWin
&& m_colLabelWin
->IsShown() )
4734 m_colLabelWin
->SetSize( m_rowLabelWidth
, 0, cw
- m_rowLabelWidth
, m_colLabelHeight
);
4736 if ( m_rowLabelWin
&& m_rowLabelWin
->IsShown() )
4737 m_rowLabelWin
->SetSize( 0, m_colLabelHeight
, m_rowLabelWidth
, ch
- m_colLabelHeight
);
4739 if ( m_gridWin
&& m_gridWin
->IsShown() )
4740 m_gridWin
->SetSize( m_rowLabelWidth
, m_colLabelHeight
, cw
- m_rowLabelWidth
, ch
- m_colLabelHeight
);
4743 // this is called when the grid table sends a message
4744 // to indicate that it has been redimensioned
4746 bool wxGrid::Redimension( wxGridTableMessage
& msg
)
4749 bool result
= false;
4751 // Clear the attribute cache as the attribute might refer to a different
4752 // cell than stored in the cache after adding/removing rows/columns.
4755 // By the same reasoning, the editor should be dismissed if columns are
4756 // added or removed. And for consistency, it should IMHO always be
4757 // removed, not only if the cell "underneath" it actually changes.
4758 // For now, I intentionally do not save the editor's content as the
4759 // cell it might want to save that stuff to might no longer exist.
4760 HideCellEditControl();
4763 // if we were using the default widths/heights so far, we must change them
4765 if ( m_colWidths
.IsEmpty() )
4770 if ( m_rowHeights
.IsEmpty() )
4776 switch ( msg
.GetId() )
4778 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
4780 size_t pos
= msg
.GetCommandInt();
4781 int numRows
= msg
.GetCommandInt2();
4783 m_numRows
+= numRows
;
4785 if ( !m_rowHeights
.IsEmpty() )
4787 m_rowHeights
.Insert( m_defaultRowHeight
, pos
, numRows
);
4788 m_rowBottoms
.Insert( 0, pos
, numRows
);
4792 bottom
= m_rowBottoms
[pos
- 1];
4794 for ( i
= pos
; i
< m_numRows
; i
++ )
4796 bottom
+= m_rowHeights
[i
];
4797 m_rowBottoms
[i
] = bottom
;
4801 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4803 // if we have just inserted cols into an empty grid the current
4804 // cell will be undefined...
4806 SetCurrentCell( 0, 0 );
4810 m_selection
->UpdateRows( pos
, numRows
);
4811 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4813 attrProvider
->UpdateAttrRows( pos
, numRows
);
4815 if ( !GetBatchCount() )
4818 m_rowLabelWin
->Refresh();
4824 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
4826 int numRows
= msg
.GetCommandInt();
4827 int oldNumRows
= m_numRows
;
4828 m_numRows
+= numRows
;
4830 if ( !m_rowHeights
.IsEmpty() )
4832 m_rowHeights
.Add( m_defaultRowHeight
, numRows
);
4833 m_rowBottoms
.Add( 0, numRows
);
4836 if ( oldNumRows
> 0 )
4837 bottom
= m_rowBottoms
[oldNumRows
- 1];
4839 for ( i
= oldNumRows
; i
< m_numRows
; i
++ )
4841 bottom
+= m_rowHeights
[i
];
4842 m_rowBottoms
[i
] = bottom
;
4846 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4848 // if we have just inserted cols into an empty grid the current
4849 // cell will be undefined...
4851 SetCurrentCell( 0, 0 );
4854 if ( !GetBatchCount() )
4857 m_rowLabelWin
->Refresh();
4863 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
4865 size_t pos
= msg
.GetCommandInt();
4866 int numRows
= msg
.GetCommandInt2();
4867 m_numRows
-= numRows
;
4869 if ( !m_rowHeights
.IsEmpty() )
4871 m_rowHeights
.RemoveAt( pos
, numRows
);
4872 m_rowBottoms
.RemoveAt( pos
, numRows
);
4875 for ( i
= 0; i
< m_numRows
; i
++ )
4877 h
+= m_rowHeights
[i
];
4878 m_rowBottoms
[i
] = h
;
4884 m_currentCellCoords
= wxGridNoCellCoords
;
4888 if ( m_currentCellCoords
.GetRow() >= m_numRows
)
4889 m_currentCellCoords
.Set( 0, 0 );
4893 m_selection
->UpdateRows( pos
, -((int)numRows
) );
4894 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4897 attrProvider
->UpdateAttrRows( pos
, -((int)numRows
) );
4899 // ifdef'd out following patch from Paul Gammans
4901 // No need to touch column attributes, unless we
4902 // removed _all_ rows, in this case, we remove
4903 // all column attributes.
4904 // I hate to do this here, but the
4905 // needed data is not available inside UpdateAttrRows.
4906 if ( !GetNumberRows() )
4907 attrProvider
->UpdateAttrCols( 0, -GetNumberCols() );
4911 if ( !GetBatchCount() )
4914 m_rowLabelWin
->Refresh();
4920 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
4922 size_t pos
= msg
.GetCommandInt();
4923 int numCols
= msg
.GetCommandInt2();
4924 m_numCols
+= numCols
;
4926 if ( !m_colAt
.IsEmpty() )
4928 //Shift the column IDs
4930 for ( i
= 0; i
< m_numCols
- numCols
; i
++ )
4932 if ( m_colAt
[i
] >= (int)pos
)
4933 m_colAt
[i
] += numCols
;
4936 m_colAt
.Insert( pos
, pos
, numCols
);
4938 //Set the new columns' positions
4939 for ( i
= pos
+ 1; i
< (int)pos
+ numCols
; i
++ )
4945 if ( !m_colWidths
.IsEmpty() )
4947 m_colWidths
.Insert( m_defaultColWidth
, pos
, numCols
);
4948 m_colRights
.Insert( 0, pos
, numCols
);
4952 right
= m_colRights
[GetColAt( pos
- 1 )];
4955 for ( colPos
= pos
; colPos
< m_numCols
; colPos
++ )
4957 i
= GetColAt( colPos
);
4959 right
+= m_colWidths
[i
];
4960 m_colRights
[i
] = right
;
4964 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4966 // if we have just inserted cols into an empty grid the current
4967 // cell will be undefined...
4969 SetCurrentCell( 0, 0 );
4973 m_selection
->UpdateCols( pos
, numCols
);
4974 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4976 attrProvider
->UpdateAttrCols( pos
, numCols
);
4977 if ( !GetBatchCount() )
4980 m_colLabelWin
->Refresh();
4986 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
4988 int numCols
= msg
.GetCommandInt();
4989 int oldNumCols
= m_numCols
;
4990 m_numCols
+= numCols
;
4992 if ( !m_colAt
.IsEmpty() )
4994 m_colAt
.Add( 0, numCols
);
4996 //Set the new columns' positions
4998 for ( i
= oldNumCols
; i
< m_numCols
; i
++ )
5004 if ( !m_colWidths
.IsEmpty() )
5006 m_colWidths
.Add( m_defaultColWidth
, numCols
);
5007 m_colRights
.Add( 0, numCols
);
5010 if ( oldNumCols
> 0 )
5011 right
= m_colRights
[GetColAt( oldNumCols
- 1 )];
5014 for ( colPos
= oldNumCols
; colPos
< m_numCols
; colPos
++ )
5016 i
= GetColAt( colPos
);
5018 right
+= m_colWidths
[i
];
5019 m_colRights
[i
] = right
;
5023 if ( m_currentCellCoords
== wxGridNoCellCoords
)
5025 // if we have just inserted cols into an empty grid the current
5026 // cell will be undefined...
5028 SetCurrentCell( 0, 0 );
5030 if ( !GetBatchCount() )
5033 m_colLabelWin
->Refresh();
5039 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
5041 size_t pos
= msg
.GetCommandInt();
5042 int numCols
= msg
.GetCommandInt2();
5043 m_numCols
-= numCols
;
5045 if ( !m_colAt
.IsEmpty() )
5047 int colID
= GetColAt( pos
);
5049 m_colAt
.RemoveAt( pos
, numCols
);
5051 //Shift the column IDs
5053 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
5055 if ( m_colAt
[colPos
] > colID
)
5056 m_colAt
[colPos
] -= numCols
;
5060 if ( !m_colWidths
.IsEmpty() )
5062 m_colWidths
.RemoveAt( pos
, numCols
);
5063 m_colRights
.RemoveAt( pos
, numCols
);
5067 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
5069 i
= GetColAt( colPos
);
5071 w
+= m_colWidths
[i
];
5078 m_currentCellCoords
= wxGridNoCellCoords
;
5082 if ( m_currentCellCoords
.GetCol() >= m_numCols
)
5083 m_currentCellCoords
.Set( 0, 0 );
5087 m_selection
->UpdateCols( pos
, -((int)numCols
) );
5088 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
5091 attrProvider
->UpdateAttrCols( pos
, -((int)numCols
) );
5093 // ifdef'd out following patch from Paul Gammans
5095 // No need to touch row attributes, unless we
5096 // removed _all_ columns, in this case, we remove
5097 // all row attributes.
5098 // I hate to do this here, but the
5099 // needed data is not available inside UpdateAttrCols.
5100 if ( !GetNumberCols() )
5101 attrProvider
->UpdateAttrRows( 0, -GetNumberRows() );
5105 if ( !GetBatchCount() )
5108 m_colLabelWin
->Refresh();
5115 if (result
&& !GetBatchCount() )
5116 m_gridWin
->Refresh();
5121 wxArrayInt
wxGrid::CalcRowLabelsExposed( const wxRegion
& reg
) const
5123 wxRegionIterator
iter( reg
);
5126 wxArrayInt rowlabels
;
5133 // TODO: remove this when we can...
5134 // There is a bug in wxMotif that gives garbage update
5135 // rectangles if you jump-scroll a long way by clicking the
5136 // scrollbar with middle button. This is a work-around
5138 #if defined(__WXMOTIF__)
5140 m_gridWin
->GetClientSize( &cw
, &ch
);
5141 if ( r
.GetTop() > ch
)
5143 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
5146 // logical bounds of update region
5149 CalcUnscrolledPosition( 0, r
.GetTop(), &dummy
, &top
);
5150 CalcUnscrolledPosition( 0, r
.GetBottom(), &dummy
, &bottom
);
5152 // find the row labels within these bounds
5155 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
5157 if ( GetRowBottom(row
) < top
)
5160 if ( GetRowTop(row
) > bottom
)
5163 rowlabels
.Add( row
);
5172 wxArrayInt
wxGrid::CalcColLabelsExposed( const wxRegion
& reg
) const
5174 wxRegionIterator
iter( reg
);
5177 wxArrayInt colLabels
;
5184 // TODO: remove this when we can...
5185 // There is a bug in wxMotif that gives garbage update
5186 // rectangles if you jump-scroll a long way by clicking the
5187 // scrollbar with middle button. This is a work-around
5189 #if defined(__WXMOTIF__)
5191 m_gridWin
->GetClientSize( &cw
, &ch
);
5192 if ( r
.GetLeft() > cw
)
5194 r
.SetRight( wxMin( r
.GetRight(), cw
) );
5197 // logical bounds of update region
5200 CalcUnscrolledPosition( r
.GetLeft(), 0, &left
, &dummy
);
5201 CalcUnscrolledPosition( r
.GetRight(), 0, &right
, &dummy
);
5203 // find the cells within these bounds
5207 for ( colPos
= GetColPos( internalXToCol(left
) ); colPos
< m_numCols
; colPos
++ )
5209 col
= GetColAt( colPos
);
5211 if ( GetColRight(col
) < left
)
5214 if ( GetColLeft(col
) > right
)
5217 colLabels
.Add( col
);
5226 wxGridCellCoordsArray
wxGrid::CalcCellsExposed( const wxRegion
& reg
) const
5228 wxRegionIterator
iter( reg
);
5231 wxGridCellCoordsArray cellsExposed
;
5233 int left
, top
, right
, bottom
;
5238 // TODO: remove this when we can...
5239 // There is a bug in wxMotif that gives garbage update
5240 // rectangles if you jump-scroll a long way by clicking the
5241 // scrollbar with middle button. This is a work-around
5243 #if defined(__WXMOTIF__)
5245 m_gridWin
->GetClientSize( &cw
, &ch
);
5246 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
5247 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
5248 r
.SetRight( wxMin( r
.GetRight(), cw
) );
5249 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
5252 // logical bounds of update region
5254 CalcUnscrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
5255 CalcUnscrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
5257 // find the cells within these bounds
5260 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
5262 if ( GetRowBottom(row
) <= top
)
5265 if ( GetRowTop(row
) > bottom
)
5269 for ( colPos
= GetColPos( internalXToCol(left
) ); colPos
< m_numCols
; colPos
++ )
5271 col
= GetColAt( colPos
);
5273 if ( GetColRight(col
) <= left
)
5276 if ( GetColLeft(col
) > right
)
5279 cellsExposed
.Add( wxGridCellCoords( row
, col
) );
5286 return cellsExposed
;
5290 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent
& event
)
5293 wxPoint
pos( event
.GetPosition() );
5294 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5296 if ( event
.Dragging() )
5300 m_isDragging
= true;
5301 m_rowLabelWin
->CaptureMouse();
5304 if ( event
.LeftIsDown() )
5306 switch ( m_cursorMode
)
5308 case WXGRID_CURSOR_RESIZE_ROW
:
5310 int cw
, ch
, left
, dummy
;
5311 m_gridWin
->GetClientSize( &cw
, &ch
);
5312 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
5314 wxClientDC
dc( m_gridWin
);
5317 GetRowTop(m_dragRowOrCol
) +
5318 GetRowMinimalHeight(m_dragRowOrCol
) );
5319 dc
.SetLogicalFunction(wxINVERT
);
5320 if ( m_dragLastPos
>= 0 )
5322 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
5324 dc
.DrawLine( left
, y
, left
+cw
, y
);
5329 case WXGRID_CURSOR_SELECT_ROW
:
5331 if ( (row
= YToRow( y
)) >= 0 )
5335 m_selection
->SelectRow( row
,
5336 event
.ControlDown(),
5345 // default label to suppress warnings about "enumeration value
5346 // 'xxx' not handled in switch
5354 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
5359 if (m_rowLabelWin
->HasCapture())
5360 m_rowLabelWin
->ReleaseMouse();
5361 m_isDragging
= false;
5364 // ------------ Entering or leaving the window
5366 if ( event
.Entering() || event
.Leaving() )
5368 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
5371 // ------------ Left button pressed
5373 else if ( event
.LeftDown() )
5375 // don't send a label click event for a hit on the
5376 // edge of the row label - this is probably the user
5377 // wanting to resize the row
5379 if ( YToEdgeOfRow(y
) < 0 )
5383 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, row
, -1, event
) )
5385 if ( !event
.ShiftDown() && !event
.CmdDown() )
5389 if ( event
.ShiftDown() )
5391 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
5394 GetNumberCols() - 1,
5395 event
.ControlDown(),
5402 m_selection
->SelectRow( row
,
5403 event
.ControlDown(),
5410 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW
, m_rowLabelWin
);
5415 // starting to drag-resize a row
5416 if ( CanDragRowSize() )
5417 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
);
5421 // ------------ Left double click
5423 else if (event
.LeftDClick() )
5425 row
= YToEdgeOfRow(y
);
5430 !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, row
, -1, event
) )
5432 // no default action at the moment
5437 // adjust row height depending on label text
5438 AutoSizeRowLabelSize( row
);
5440 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5445 // ------------ Left button released
5447 else if ( event
.LeftUp() )
5449 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
5451 DoEndDragResizeRow();
5453 // Note: we are ending the event *after* doing
5454 // default processing in this case
5456 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
5459 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
5463 // ------------ Right button down
5465 else if ( event
.RightDown() )
5469 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, row
, -1, event
) )
5471 // no default action at the moment
5475 // ------------ Right double click
5477 else if ( event
.RightDClick() )
5481 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, row
, -1, event
) )
5483 // no default action at the moment
5487 // ------------ No buttons down and mouse moving
5489 else if ( event
.Moving() )
5491 m_dragRowOrCol
= YToEdgeOfRow( y
);
5492 if ( m_dragRowOrCol
>= 0 )
5494 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5496 // don't capture the mouse yet
5497 if ( CanDragRowSize() )
5498 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
, false);
5501 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5503 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
, false);
5508 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent
& event
)
5511 wxPoint
pos( event
.GetPosition() );
5512 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5514 if ( event
.Dragging() )
5518 m_isDragging
= true;
5519 m_colLabelWin
->CaptureMouse();
5521 if ( m_cursorMode
== WXGRID_CURSOR_MOVE_COL
)
5522 m_dragRowOrCol
= XToCol( x
);
5525 if ( event
.LeftIsDown() )
5527 switch ( m_cursorMode
)
5529 case WXGRID_CURSOR_RESIZE_COL
:
5531 int cw
, ch
, dummy
, top
;
5532 m_gridWin
->GetClientSize( &cw
, &ch
);
5533 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
5535 wxClientDC
dc( m_gridWin
);
5538 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
5539 GetColMinimalWidth(m_dragRowOrCol
));
5540 dc
.SetLogicalFunction(wxINVERT
);
5541 if ( m_dragLastPos
>= 0 )
5543 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ ch
);
5545 dc
.DrawLine( x
, top
, x
, top
+ ch
);
5550 case WXGRID_CURSOR_SELECT_COL
:
5552 if ( (col
= XToCol( x
)) >= 0 )
5556 m_selection
->SelectCol( col
,
5557 event
.ControlDown(),
5566 case WXGRID_CURSOR_MOVE_COL
:
5569 m_moveToCol
= GetColAt( 0 );
5571 m_moveToCol
= XToCol( x
);
5575 if ( m_moveToCol
< 0 )
5576 markerX
= GetColRight( GetColAt( m_numCols
- 1 ) );
5578 markerX
= GetColLeft( m_moveToCol
);
5580 if ( markerX
!= m_dragLastPos
)
5582 wxClientDC
dc( m_colLabelWin
);
5585 m_colLabelWin
->GetClientSize( &cw
, &ch
);
5589 //Clean up the last indicator
5590 if ( m_dragLastPos
>= 0 )
5592 wxPen
pen( m_colLabelWin
->GetBackgroundColour(), 2 );
5594 dc
.DrawLine( m_dragLastPos
+ 1, 0, m_dragLastPos
+ 1, ch
);
5595 dc
.SetPen(wxNullPen
);
5597 if ( XToCol( m_dragLastPos
) != -1 )
5598 DrawColLabel( dc
, XToCol( m_dragLastPos
) );
5601 //Moving to the same place? Don't draw a marker
5602 if ( (m_moveToCol
== m_dragRowOrCol
)
5603 || (GetColPos( m_moveToCol
) == GetColPos( m_dragRowOrCol
) + 1)
5604 || (m_moveToCol
< 0 && m_dragRowOrCol
== GetColAt( m_numCols
- 1 )))
5611 wxPen
pen( *wxBLUE
, 2 );
5614 dc
.DrawLine( markerX
, 0, markerX
, ch
);
5616 dc
.SetPen(wxNullPen
);
5618 m_dragLastPos
= markerX
- 1;
5623 // default label to suppress warnings about "enumeration value
5624 // 'xxx' not handled in switch
5632 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
5637 if (m_colLabelWin
->HasCapture())
5638 m_colLabelWin
->ReleaseMouse();
5639 m_isDragging
= false;
5642 // ------------ Entering or leaving the window
5644 if ( event
.Entering() || event
.Leaving() )
5646 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5649 // ------------ Left button pressed
5651 else if ( event
.LeftDown() )
5653 // don't send a label click event for a hit on the
5654 // edge of the col label - this is probably the user
5655 // wanting to resize the col
5657 if ( XToEdgeOfCol(x
) < 0 )
5661 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, col
, event
) )
5663 if ( m_canDragColMove
)
5665 //Show button as pressed
5666 wxClientDC
dc( m_colLabelWin
);
5667 int colLeft
= GetColLeft( col
);
5668 int colRight
= GetColRight( col
) - 1;
5669 dc
.SetPen( wxPen( m_colLabelWin
->GetBackgroundColour(), 1 ) );
5670 dc
.DrawLine( colLeft
, 1, colLeft
, m_colLabelHeight
-1 );
5671 dc
.DrawLine( colLeft
, 1, colRight
, 1 );
5673 ChangeCursorMode(WXGRID_CURSOR_MOVE_COL
, m_colLabelWin
);
5677 if ( !event
.ShiftDown() && !event
.CmdDown() )
5681 if ( event
.ShiftDown() )
5683 m_selection
->SelectBlock( 0,
5684 m_currentCellCoords
.GetCol(),
5685 GetNumberRows() - 1, col
,
5686 event
.ControlDown(),
5693 m_selection
->SelectCol( col
,
5694 event
.ControlDown(),
5701 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL
, m_colLabelWin
);
5707 // starting to drag-resize a col
5709 if ( CanDragColSize() )
5710 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
);
5714 // ------------ Left double click
5716 if ( event
.LeftDClick() )
5718 col
= XToEdgeOfCol(x
);
5723 ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, col
, event
) )
5725 // no default action at the moment
5730 // adjust column width depending on label text
5731 AutoSizeColLabelSize( col
);
5733 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5738 // ------------ Left button released
5740 else if ( event
.LeftUp() )
5742 switch ( m_cursorMode
)
5744 case WXGRID_CURSOR_RESIZE_COL
:
5745 DoEndDragResizeCol();
5747 // Note: we are ending the event *after* doing
5748 // default processing in this case
5750 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
5753 case WXGRID_CURSOR_MOVE_COL
:
5756 SendEvent( wxEVT_GRID_COL_MOVE
, -1, m_dragRowOrCol
, event
);
5759 case WXGRID_CURSOR_SELECT_COL
:
5760 case WXGRID_CURSOR_SELECT_CELL
:
5761 case WXGRID_CURSOR_RESIZE_ROW
:
5762 case WXGRID_CURSOR_SELECT_ROW
:
5763 // nothing to do (?)
5767 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5771 // ------------ Right button down
5773 else if ( event
.RightDown() )
5777 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, col
, event
) )
5779 // no default action at the moment
5783 // ------------ Right double click
5785 else if ( event
.RightDClick() )
5789 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, col
, event
) )
5791 // no default action at the moment
5795 // ------------ No buttons down and mouse moving
5797 else if ( event
.Moving() )
5799 m_dragRowOrCol
= XToEdgeOfCol( x
);
5800 if ( m_dragRowOrCol
>= 0 )
5802 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5804 // don't capture the cursor yet
5805 if ( CanDragColSize() )
5806 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
, false);
5809 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5811 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
, false);
5816 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent
& event
)
5818 if ( event
.LeftDown() )
5820 // indicate corner label by having both row and
5823 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, -1, event
) )
5828 else if ( event
.LeftDClick() )
5830 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, -1, event
);
5832 else if ( event
.RightDown() )
5834 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, -1, event
) )
5836 // no default action at the moment
5839 else if ( event
.RightDClick() )
5841 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, -1, event
) )
5843 // no default action at the moment
5848 void wxGrid::CancelMouseCapture()
5850 // cancel operation currently in progress, whatever it is
5853 m_isDragging
= false;
5854 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
5855 m_winCapture
->SetCursor( *wxSTANDARD_CURSOR
);
5856 m_winCapture
= NULL
;
5858 // remove traces of whatever we drew on screen
5863 void wxGrid::ChangeCursorMode(CursorMode mode
,
5868 static const wxChar
*cursorModes
[] =
5878 wxLogTrace(_T("grid"),
5879 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
5880 win
== m_colLabelWin
? _T("colLabelWin")
5881 : win
? _T("rowLabelWin")
5883 cursorModes
[m_cursorMode
], cursorModes
[mode
]);
5886 if ( mode
== m_cursorMode
&&
5887 win
== m_winCapture
&&
5888 captureMouse
== (m_winCapture
!= NULL
))
5893 // by default use the grid itself
5899 if (m_winCapture
->HasCapture())
5900 m_winCapture
->ReleaseMouse();
5901 m_winCapture
= (wxWindow
*)NULL
;
5904 m_cursorMode
= mode
;
5906 switch ( m_cursorMode
)
5908 case WXGRID_CURSOR_RESIZE_ROW
:
5909 win
->SetCursor( m_rowResizeCursor
);
5912 case WXGRID_CURSOR_RESIZE_COL
:
5913 win
->SetCursor( m_colResizeCursor
);
5916 case WXGRID_CURSOR_MOVE_COL
:
5917 win
->SetCursor( wxCursor(wxCURSOR_HAND
) );
5921 win
->SetCursor( *wxSTANDARD_CURSOR
);
5925 // we need to capture mouse when resizing
5926 bool resize
= m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
||
5927 m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
;
5929 if ( captureMouse
&& resize
)
5931 win
->CaptureMouse();
5936 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent
& event
)
5939 wxPoint
pos( event
.GetPosition() );
5940 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5942 wxGridCellCoords coords
;
5943 XYToCell( x
, y
, coords
);
5945 int cell_rows
, cell_cols
;
5946 bool isFirstDrag
= !m_isDragging
;
5947 GetCellSize( coords
.GetRow(), coords
.GetCol(), &cell_rows
, &cell_cols
);
5948 if ((cell_rows
< 0) || (cell_cols
< 0))
5950 coords
.SetRow(coords
.GetRow() + cell_rows
);
5951 coords
.SetCol(coords
.GetCol() + cell_cols
);
5954 if ( event
.Dragging() )
5956 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
5958 // Don't start doing anything until the mouse has been dragged at
5959 // least 3 pixels in any direction...
5962 if (m_startDragPos
== wxDefaultPosition
)
5964 m_startDragPos
= pos
;
5967 if (abs(m_startDragPos
.x
- pos
.x
) < 4 && abs(m_startDragPos
.y
- pos
.y
) < 4)
5971 m_isDragging
= true;
5972 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5974 // Hide the edit control, so it
5975 // won't interfere with drag-shrinking.
5976 if ( IsCellEditControlShown() )
5978 HideCellEditControl();
5979 SaveEditControlValue();
5982 if ( coords
!= wxGridNoCellCoords
)
5984 if ( event
.CmdDown() )
5986 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
5987 m_selectingKeyboard
= coords
;
5988 HighlightBlock( m_selectingKeyboard
, coords
);
5990 else if ( CanDragCell() )
5994 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
5995 m_selectingKeyboard
= coords
;
5997 SendEvent( wxEVT_GRID_CELL_BEGIN_DRAG
,
6006 if ( !IsSelection() )
6008 HighlightBlock( coords
, coords
);
6012 HighlightBlock( m_currentCellCoords
, coords
);
6016 if (! IsVisible(coords
))
6018 MakeCellVisible(coords
);
6019 // TODO: need to introduce a delay or something here. The
6020 // scrolling is way to fast, at least on MSW - also on GTK.
6023 // Have we captured the mouse yet?
6026 m_winCapture
= m_gridWin
;
6027 m_winCapture
->CaptureMouse();
6032 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
6034 int cw
, ch
, left
, dummy
;
6035 m_gridWin
->GetClientSize( &cw
, &ch
);
6036 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
6038 wxClientDC
dc( m_gridWin
);
6040 y
= wxMax( y
, GetRowTop(m_dragRowOrCol
) +
6041 GetRowMinimalHeight(m_dragRowOrCol
) );
6042 dc
.SetLogicalFunction(wxINVERT
);
6043 if ( m_dragLastPos
>= 0 )
6045 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
6047 dc
.DrawLine( left
, y
, left
+cw
, y
);
6050 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
6052 int cw
, ch
, dummy
, top
;
6053 m_gridWin
->GetClientSize( &cw
, &ch
);
6054 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
6056 wxClientDC
dc( m_gridWin
);
6058 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
6059 GetColMinimalWidth(m_dragRowOrCol
) );
6060 dc
.SetLogicalFunction(wxINVERT
);
6061 if ( m_dragLastPos
>= 0 )
6063 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ ch
);
6065 dc
.DrawLine( x
, top
, x
, top
+ ch
);
6072 m_isDragging
= false;
6073 m_startDragPos
= wxDefaultPosition
;
6075 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
6076 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
6079 if ( event
.Entering() || event
.Leaving() )
6081 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6082 m_gridWin
->SetCursor( *wxSTANDARD_CURSOR
);
6087 // ------------ Left button pressed
6089 if ( event
.LeftDown() && coords
!= wxGridNoCellCoords
)
6091 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK
,
6096 if ( !event
.CmdDown() )
6098 if ( event
.ShiftDown() )
6102 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
6103 m_currentCellCoords
.GetCol(),
6106 event
.ControlDown(),
6112 else if ( XToEdgeOfCol(x
) < 0 &&
6113 YToEdgeOfRow(y
) < 0 )
6115 DisableCellEditControl();
6116 MakeCellVisible( coords
);
6118 if ( event
.CmdDown() )
6122 m_selection
->ToggleCellSelection( coords
.GetRow(),
6124 event
.ControlDown(),
6129 m_selectingTopLeft
= wxGridNoCellCoords
;
6130 m_selectingBottomRight
= wxGridNoCellCoords
;
6131 m_selectingKeyboard
= coords
;
6135 m_waitForSlowClick
= m_currentCellCoords
== coords
&& coords
!= wxGridNoCellCoords
;
6136 SetCurrentCell( coords
);
6139 if ( m_selection
->GetSelectionMode() !=
6140 wxGrid::wxGridSelectCells
)
6142 HighlightBlock( coords
, coords
);
6150 // ------------ Left double click
6152 else if ( event
.LeftDClick() && coords
!= wxGridNoCellCoords
)
6154 DisableCellEditControl();
6156 if ( XToEdgeOfCol(x
) < 0 && YToEdgeOfRow(y
) < 0 )
6158 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK
,
6163 // we want double click to select a cell and start editing
6164 // (i.e. to behave in same way as sequence of two slow clicks):
6165 m_waitForSlowClick
= true;
6170 // ------------ Left button released
6172 else if ( event
.LeftUp() )
6174 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
6178 if (m_winCapture
->HasCapture())
6179 m_winCapture
->ReleaseMouse();
6180 m_winCapture
= NULL
;
6183 if ( coords
== m_currentCellCoords
&& m_waitForSlowClick
&& CanEnableCellControl() )
6186 EnableCellEditControl();
6188 wxGridCellAttr
*attr
= GetCellAttr(coords
);
6189 wxGridCellEditor
*editor
= attr
->GetEditor(this, coords
.GetRow(), coords
.GetCol());
6190 editor
->StartingClick();
6194 m_waitForSlowClick
= false;
6196 else if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
6197 m_selectingBottomRight
!= wxGridNoCellCoords
)
6201 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
6202 m_selectingTopLeft
.GetCol(),
6203 m_selectingBottomRight
.GetRow(),
6204 m_selectingBottomRight
.GetCol(),
6205 event
.ControlDown(),
6211 m_selectingTopLeft
= wxGridNoCellCoords
;
6212 m_selectingBottomRight
= wxGridNoCellCoords
;
6214 // Show the edit control, if it has been hidden for
6216 ShowCellEditControl();
6219 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
6221 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6222 DoEndDragResizeRow();
6224 // Note: we are ending the event *after* doing
6225 // default processing in this case
6227 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
6229 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
6231 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6232 DoEndDragResizeCol();
6234 // Note: we are ending the event *after* doing
6235 // default processing in this case
6237 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
6243 // ------------ Right button down
6245 else if ( event
.RightDown() && coords
!= wxGridNoCellCoords
)
6247 DisableCellEditControl();
6248 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK
,
6253 // no default action at the moment
6257 // ------------ Right double click
6259 else if ( event
.RightDClick() && coords
!= wxGridNoCellCoords
)
6261 DisableCellEditControl();
6262 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK
,
6267 // no default action at the moment
6271 // ------------ Moving and no button action
6273 else if ( event
.Moving() && !event
.IsButton() )
6275 if ( coords
.GetRow() < 0 || coords
.GetCol() < 0 )
6277 // out of grid cell area
6278 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6282 int dragRow
= YToEdgeOfRow( y
);
6283 int dragCol
= XToEdgeOfCol( x
);
6285 // Dragging on the corner of a cell to resize in both
6286 // directions is not implemented yet...
6288 if ( dragRow
>= 0 && dragCol
>= 0 )
6290 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6296 m_dragRowOrCol
= dragRow
;
6298 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
6300 if ( CanDragRowSize() && CanDragGridSize() )
6301 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, NULL
, false);
6304 else if ( dragCol
>= 0 )
6306 m_dragRowOrCol
= dragCol
;
6308 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
6310 if ( CanDragColSize() && CanDragGridSize() )
6311 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, NULL
, false);
6314 else // Neither on a row or col edge
6316 if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
6318 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6324 void wxGrid::DoEndDragResizeRow()
6326 if ( m_dragLastPos
>= 0 )
6328 // erase the last line and resize the row
6330 int cw
, ch
, left
, dummy
;
6331 m_gridWin
->GetClientSize( &cw
, &ch
);
6332 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
6334 wxClientDC
dc( m_gridWin
);
6336 dc
.SetLogicalFunction( wxINVERT
);
6337 dc
.DrawLine( left
, m_dragLastPos
, left
+ cw
, m_dragLastPos
);
6338 HideCellEditControl();
6339 SaveEditControlValue();
6341 int rowTop
= GetRowTop(m_dragRowOrCol
);
6342 SetRowSize( m_dragRowOrCol
,
6343 wxMax( m_dragLastPos
- rowTop
, m_minAcceptableRowHeight
) );
6345 if ( !GetBatchCount() )
6347 // Only needed to get the correct rect.y:
6348 wxRect
rect ( CellToRect( m_dragRowOrCol
, 0 ) );
6350 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
6351 rect
.width
= m_rowLabelWidth
;
6352 rect
.height
= ch
- rect
.y
;
6353 m_rowLabelWin
->Refresh( true, &rect
);
6356 // if there is a multicell block, paint all of it
6359 int i
, cell_rows
, cell_cols
, subtract_rows
= 0;
6360 int leftCol
= XToCol(left
);
6361 int rightCol
= internalXToCol(left
+ cw
);
6364 for (i
=leftCol
; i
<rightCol
; i
++)
6366 GetCellSize(m_dragRowOrCol
, i
, &cell_rows
, &cell_cols
);
6367 if (cell_rows
< subtract_rows
)
6368 subtract_rows
= cell_rows
;
6370 rect
.y
= GetRowTop(m_dragRowOrCol
+ subtract_rows
);
6371 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
6372 rect
.height
= ch
- rect
.y
;
6375 m_gridWin
->Refresh( false, &rect
);
6378 ShowCellEditControl();
6383 void wxGrid::DoEndDragResizeCol()
6385 if ( m_dragLastPos
>= 0 )
6387 // erase the last line and resize the col
6389 int cw
, ch
, dummy
, top
;
6390 m_gridWin
->GetClientSize( &cw
, &ch
);
6391 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
6393 wxClientDC
dc( m_gridWin
);
6395 dc
.SetLogicalFunction( wxINVERT
);
6396 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ ch
);
6397 HideCellEditControl();
6398 SaveEditControlValue();
6400 int colLeft
= GetColLeft(m_dragRowOrCol
);
6401 SetColSize( m_dragRowOrCol
,
6402 wxMax( m_dragLastPos
- colLeft
,
6403 GetColMinimalWidth(m_dragRowOrCol
) ) );
6405 if ( !GetBatchCount() )
6407 // Only needed to get the correct rect.x:
6408 wxRect
rect ( CellToRect( 0, m_dragRowOrCol
) );
6410 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
6411 rect
.width
= cw
- rect
.x
;
6412 rect
.height
= m_colLabelHeight
;
6413 m_colLabelWin
->Refresh( true, &rect
);
6416 // if there is a multicell block, paint all of it
6419 int i
, cell_rows
, cell_cols
, subtract_cols
= 0;
6420 int topRow
= YToRow(top
);
6421 int bottomRow
= internalYToRow(top
+ cw
);
6424 for (i
=topRow
; i
<bottomRow
; i
++)
6426 GetCellSize(i
, m_dragRowOrCol
, &cell_rows
, &cell_cols
);
6427 if (cell_cols
< subtract_cols
)
6428 subtract_cols
= cell_cols
;
6431 rect
.x
= GetColLeft(m_dragRowOrCol
+ subtract_cols
);
6432 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
6433 rect
.width
= cw
- rect
.x
;
6437 m_gridWin
->Refresh( false, &rect
);
6440 ShowCellEditControl();
6444 void wxGrid::DoEndDragMoveCol()
6446 //The user clicked on the column but didn't actually drag
6447 if ( m_dragLastPos
< 0 )
6449 m_colLabelWin
->Refresh(); //Do this to "unpress" the column
6454 if ( m_moveToCol
== -1 )
6455 newPos
= m_numCols
- 1;
6458 newPos
= GetColPos( m_moveToCol
);
6459 if ( newPos
> GetColPos( m_dragRowOrCol
) )
6463 SetColPos( m_dragRowOrCol
, newPos
);
6466 void wxGrid::SetColPos( int colID
, int newPos
)
6468 if ( m_colAt
.IsEmpty() )
6470 m_colAt
.Alloc( m_numCols
);
6473 for ( i
= 0; i
< m_numCols
; i
++ )
6479 int oldPos
= GetColPos( colID
);
6481 //Reshuffle the m_colAt array
6482 if ( newPos
> oldPos
)
6485 for ( i
= oldPos
; i
< newPos
; i
++ )
6487 m_colAt
[i
] = m_colAt
[i
+1];
6493 for ( i
= oldPos
; i
> newPos
; i
-- )
6495 m_colAt
[i
] = m_colAt
[i
-1];
6499 m_colAt
[newPos
] = colID
;
6501 //Recalculate the column rights
6502 if ( !m_colWidths
.IsEmpty() )
6506 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
6508 int colID
= GetColAt( colPos
);
6510 colRight
+= m_colWidths
[colID
];
6511 m_colRights
[colID
] = colRight
;
6515 m_colLabelWin
->Refresh();
6516 m_gridWin
->Refresh();
6521 void wxGrid::EnableDragColMove( bool enable
)
6523 if ( m_canDragColMove
== enable
)
6526 m_canDragColMove
= enable
;
6528 if ( !m_canDragColMove
)
6532 //Recalculate the column rights
6533 if ( !m_colWidths
.IsEmpty() )
6537 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
6539 colRight
+= m_colWidths
[colPos
];
6540 m_colRights
[colPos
] = colRight
;
6544 m_colLabelWin
->Refresh();
6545 m_gridWin
->Refresh();
6551 // ------ interaction with data model
6553 bool wxGrid::ProcessTableMessage( wxGridTableMessage
& msg
)
6555 switch ( msg
.GetId() )
6557 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES
:
6558 return GetModelValues();
6560 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES
:
6561 return SetModelValues();
6563 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
6564 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
6565 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
6566 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
6567 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
6568 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
6569 return Redimension( msg
);
6576 // The behaviour of this function depends on the grid table class
6577 // Clear() function. For the default wxGridStringTable class the
6578 // behavious is to replace all cell contents with wxEmptyString but
6579 // not to change the number of rows or cols.
6581 void wxGrid::ClearGrid()
6585 if (IsCellEditControlEnabled())
6586 DisableCellEditControl();
6589 if (!GetBatchCount())
6590 m_gridWin
->Refresh();
6594 bool wxGrid::InsertRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
6596 // TODO: something with updateLabels flag
6600 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
6606 if (IsCellEditControlEnabled())
6607 DisableCellEditControl();
6609 bool done
= m_table
->InsertRows( pos
, numRows
);
6612 // the table will have sent the results of the insert row
6613 // operation to this view object as a grid table message
6619 bool wxGrid::AppendRows( int numRows
, bool WXUNUSED(updateLabels
) )
6621 // TODO: something with updateLabels flag
6625 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
6631 bool done
= m_table
&& m_table
->AppendRows( numRows
);
6634 // the table will have sent the results of the append row
6635 // operation to this view object as a grid table message
6641 bool wxGrid::DeleteRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
6643 // TODO: something with updateLabels flag
6647 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
6653 if (IsCellEditControlEnabled())
6654 DisableCellEditControl();
6656 bool done
= m_table
->DeleteRows( pos
, numRows
);
6658 // the table will have sent the results of the delete row
6659 // operation to this view object as a grid table message
6665 bool wxGrid::InsertCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
6667 // TODO: something with updateLabels flag
6671 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
6677 if (IsCellEditControlEnabled())
6678 DisableCellEditControl();
6680 bool done
= m_table
->InsertCols( pos
, numCols
);
6682 // the table will have sent the results of the insert col
6683 // operation to this view object as a grid table message
6689 bool wxGrid::AppendCols( int numCols
, bool WXUNUSED(updateLabels
) )
6691 // TODO: something with updateLabels flag
6695 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
6701 bool done
= m_table
->AppendCols( numCols
);
6703 // the table will have sent the results of the append col
6704 // operation to this view object as a grid table message
6710 bool wxGrid::DeleteCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
6712 // TODO: something with updateLabels flag
6716 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
6722 if (IsCellEditControlEnabled())
6723 DisableCellEditControl();
6725 bool done
= m_table
->DeleteCols( pos
, numCols
);
6727 // the table will have sent the results of the delete col
6728 // operation to this view object as a grid table message
6735 // ----- event handlers
6738 // Generate a grid event based on a mouse event and
6739 // return the result of ProcessEvent()
6741 int wxGrid::SendEvent( const wxEventType type
,
6743 wxMouseEvent
& mouseEv
)
6745 bool claimed
, vetoed
;
6747 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
6749 int rowOrCol
= (row
== -1 ? col
: row
);
6751 wxGridSizeEvent
gridEvt( GetId(),
6755 mouseEv
.GetX() + GetRowLabelSize(),
6756 mouseEv
.GetY() + GetColLabelSize(),
6757 mouseEv
.ControlDown(),
6758 mouseEv
.ShiftDown(),
6760 mouseEv
.MetaDown() );
6762 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6763 vetoed
= !gridEvt
.IsAllowed();
6765 else if ( type
== wxEVT_GRID_RANGE_SELECT
)
6767 // Right now, it should _never_ end up here!
6768 wxGridRangeSelectEvent
gridEvt( GetId(),
6772 m_selectingBottomRight
,
6774 mouseEv
.ControlDown(),
6775 mouseEv
.ShiftDown(),
6777 mouseEv
.MetaDown() );
6779 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6780 vetoed
= !gridEvt
.IsAllowed();
6782 else if ( type
== wxEVT_GRID_LABEL_LEFT_CLICK
||
6783 type
== wxEVT_GRID_LABEL_LEFT_DCLICK
||
6784 type
== wxEVT_GRID_LABEL_RIGHT_CLICK
||
6785 type
== wxEVT_GRID_LABEL_RIGHT_DCLICK
)
6787 wxPoint pos
= mouseEv
.GetPosition();
6789 if ( mouseEv
.GetEventObject() == GetGridRowLabelWindow() )
6790 pos
.y
+= GetColLabelSize();
6791 if ( mouseEv
.GetEventObject() == GetGridColLabelWindow() )
6792 pos
.x
+= GetRowLabelSize();
6794 wxGridEvent
gridEvt( GetId(),
6801 mouseEv
.ControlDown(),
6802 mouseEv
.ShiftDown(),
6804 mouseEv
.MetaDown() );
6805 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6806 vetoed
= !gridEvt
.IsAllowed();
6810 wxGridEvent
gridEvt( GetId(),
6814 mouseEv
.GetX() + GetRowLabelSize(),
6815 mouseEv
.GetY() + GetColLabelSize(),
6817 mouseEv
.ControlDown(),
6818 mouseEv
.ShiftDown(),
6820 mouseEv
.MetaDown() );
6821 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6822 vetoed
= !gridEvt
.IsAllowed();
6825 // A Veto'd event may not be `claimed' so test this first
6829 return claimed
? 1 : 0;
6832 // Generate a grid event of specified type and return the result
6833 // of ProcessEvent().
6835 int wxGrid::SendEvent( const wxEventType type
,
6838 bool claimed
, vetoed
;
6840 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
6842 int rowOrCol
= (row
== -1 ? col
: row
);
6844 wxGridSizeEvent
gridEvt( GetId(), type
, this, rowOrCol
);
6846 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6847 vetoed
= !gridEvt
.IsAllowed();
6851 wxGridEvent
gridEvt( GetId(), type
, this, row
, col
);
6853 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6854 vetoed
= !gridEvt
.IsAllowed();
6857 // A Veto'd event may not be `claimed' so test this first
6861 return claimed
? 1 : 0;
6864 void wxGrid::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
6866 // needed to prevent zillions of paint events on MSW
6870 void wxGrid::Refresh(bool eraseb
, const wxRect
* rect
)
6872 // Don't do anything if between Begin/EndBatch...
6873 // EndBatch() will do all this on the last nested one anyway.
6874 if (! GetBatchCount())
6876 // Refresh to get correct scrolled position:
6877 wxScrolledWindow::Refresh(eraseb
, rect
);
6881 int rect_x
, rect_y
, rectWidth
, rectHeight
;
6882 int width_label
, width_cell
, height_label
, height_cell
;
6885 // Copy rectangle can get scroll offsets..
6886 rect_x
= rect
->GetX();
6887 rect_y
= rect
->GetY();
6888 rectWidth
= rect
->GetWidth();
6889 rectHeight
= rect
->GetHeight();
6891 width_label
= m_rowLabelWidth
- rect_x
;
6892 if (width_label
> rectWidth
)
6893 width_label
= rectWidth
;
6895 height_label
= m_colLabelHeight
- rect_y
;
6896 if (height_label
> rectHeight
)
6897 height_label
= rectHeight
;
6899 if (rect_x
> m_rowLabelWidth
)
6901 x
= rect_x
- m_rowLabelWidth
;
6902 width_cell
= rectWidth
;
6907 width_cell
= rectWidth
- (m_rowLabelWidth
- rect_x
);
6910 if (rect_y
> m_colLabelHeight
)
6912 y
= rect_y
- m_colLabelHeight
;
6913 height_cell
= rectHeight
;
6918 height_cell
= rectHeight
- (m_colLabelHeight
- rect_y
);
6921 // Paint corner label part intersecting rect.
6922 if ( width_label
> 0 && height_label
> 0 )
6924 wxRect
anotherrect(rect_x
, rect_y
, width_label
, height_label
);
6925 m_cornerLabelWin
->Refresh(eraseb
, &anotherrect
);
6928 // Paint col labels part intersecting rect.
6929 if ( width_cell
> 0 && height_label
> 0 )
6931 wxRect
anotherrect(x
, rect_y
, width_cell
, height_label
);
6932 m_colLabelWin
->Refresh(eraseb
, &anotherrect
);
6935 // Paint row labels part intersecting rect.
6936 if ( width_label
> 0 && height_cell
> 0 )
6938 wxRect
anotherrect(rect_x
, y
, width_label
, height_cell
);
6939 m_rowLabelWin
->Refresh(eraseb
, &anotherrect
);
6942 // Paint cell area part intersecting rect.
6943 if ( width_cell
> 0 && height_cell
> 0 )
6945 wxRect
anotherrect(x
, y
, width_cell
, height_cell
);
6946 m_gridWin
->Refresh(eraseb
, &anotherrect
);
6951 m_cornerLabelWin
->Refresh(eraseb
, NULL
);
6952 m_colLabelWin
->Refresh(eraseb
, NULL
);
6953 m_rowLabelWin
->Refresh(eraseb
, NULL
);
6954 m_gridWin
->Refresh(eraseb
, NULL
);
6959 void wxGrid::OnSize(wxSizeEvent
& WXUNUSED(event
))
6961 if (m_targetWindow
!= this) // check whether initialisation has been done
6963 // update our children window positions and scrollbars
6968 void wxGrid::OnKeyDown( wxKeyEvent
& event
)
6970 if ( m_inOnKeyDown
)
6972 // shouldn't be here - we are going round in circles...
6974 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
6977 m_inOnKeyDown
= true;
6979 // propagate the event up and see if it gets processed
6980 wxWindow
*parent
= GetParent();
6981 wxKeyEvent
keyEvt( event
);
6982 keyEvt
.SetEventObject( parent
);
6984 if ( !parent
->GetEventHandler()->ProcessEvent( keyEvt
) )
6986 if (GetLayoutDirection() == wxLayout_RightToLeft
)
6988 if (event
.GetKeyCode() == WXK_RIGHT
)
6989 event
.m_keyCode
= WXK_LEFT
;
6990 else if (event
.GetKeyCode() == WXK_LEFT
)
6991 event
.m_keyCode
= WXK_RIGHT
;
6994 // try local handlers
6995 switch ( event
.GetKeyCode() )
6998 if ( event
.ControlDown() )
6999 MoveCursorUpBlock( event
.ShiftDown() );
7001 MoveCursorUp( event
.ShiftDown() );
7005 if ( event
.ControlDown() )
7006 MoveCursorDownBlock( event
.ShiftDown() );
7008 MoveCursorDown( event
.ShiftDown() );
7012 if ( event
.ControlDown() )
7013 MoveCursorLeftBlock( event
.ShiftDown() );
7015 MoveCursorLeft( event
.ShiftDown() );
7019 if ( event
.ControlDown() )
7020 MoveCursorRightBlock( event
.ShiftDown() );
7022 MoveCursorRight( event
.ShiftDown() );
7026 case WXK_NUMPAD_ENTER
:
7027 if ( event
.ControlDown() )
7029 event
.Skip(); // to let the edit control have the return
7033 if ( GetGridCursorRow() < GetNumberRows()-1 )
7035 MoveCursorDown( event
.ShiftDown() );
7039 // at the bottom of a column
7040 DisableCellEditControl();
7050 if (event
.ShiftDown())
7052 if ( GetGridCursorCol() > 0 )
7054 MoveCursorLeft( false );
7059 DisableCellEditControl();
7064 if ( GetGridCursorCol() < GetNumberCols() - 1 )
7066 MoveCursorRight( false );
7071 DisableCellEditControl();
7077 if ( event
.ControlDown() )
7079 MakeCellVisible( 0, 0 );
7080 SetCurrentCell( 0, 0 );
7089 if ( event
.ControlDown() )
7091 MakeCellVisible( m_numRows
- 1, m_numCols
- 1 );
7092 SetCurrentCell( m_numRows
- 1, m_numCols
- 1 );
7109 if ( event
.ControlDown() )
7113 m_selection
->ToggleCellSelection(
7114 m_currentCellCoords
.GetRow(),
7115 m_currentCellCoords
.GetCol(),
7116 event
.ControlDown(),
7124 if ( !IsEditable() )
7125 MoveCursorRight( false );
7136 m_inOnKeyDown
= false;
7139 void wxGrid::OnKeyUp( wxKeyEvent
& event
)
7141 // try local handlers
7143 if ( event
.GetKeyCode() == WXK_SHIFT
)
7145 if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
7146 m_selectingBottomRight
!= wxGridNoCellCoords
)
7150 m_selection
->SelectBlock(
7151 m_selectingTopLeft
.GetRow(),
7152 m_selectingTopLeft
.GetCol(),
7153 m_selectingBottomRight
.GetRow(),
7154 m_selectingBottomRight
.GetCol(),
7155 event
.ControlDown(),
7162 m_selectingTopLeft
= wxGridNoCellCoords
;
7163 m_selectingBottomRight
= wxGridNoCellCoords
;
7164 m_selectingKeyboard
= wxGridNoCellCoords
;
7168 void wxGrid::OnChar( wxKeyEvent
& event
)
7170 // is it possible to edit the current cell at all?
7171 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
7173 // yes, now check whether the cells editor accepts the key
7174 int row
= m_currentCellCoords
.GetRow();
7175 int col
= m_currentCellCoords
.GetCol();
7176 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7177 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
7179 // <F2> is special and will always start editing, for
7180 // other keys - ask the editor itself
7181 if ( (event
.GetKeyCode() == WXK_F2
&& !event
.HasModifiers())
7182 || editor
->IsAcceptedKey(event
) )
7184 // ensure cell is visble
7185 MakeCellVisible(row
, col
);
7186 EnableCellEditControl();
7188 // a problem can arise if the cell is not completely
7189 // visible (even after calling MakeCellVisible the
7190 // control is not created and calling StartingKey will
7192 if ( event
.GetKeyCode() != WXK_F2
&& editor
->IsCreated() && m_cellEditCtrlEnabled
)
7193 editor
->StartingKey(event
);
7209 void wxGrid::OnEraseBackground(wxEraseEvent
&)
7213 void wxGrid::SetCurrentCell( const wxGridCellCoords
& coords
)
7215 if ( SendEvent( wxEVT_GRID_SELECT_CELL
, coords
.GetRow(), coords
.GetCol() ) )
7217 // the event has been intercepted - do nothing
7221 #if !(defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS)
7222 wxClientDC
dc( m_gridWin
);
7226 if ( m_currentCellCoords
!= wxGridNoCellCoords
)
7228 DisableCellEditControl();
7230 if ( IsVisible( m_currentCellCoords
, false ) )
7233 r
= BlockToDeviceRect( m_currentCellCoords
, m_currentCellCoords
);
7234 if ( !m_gridLinesEnabled
)
7242 wxGridCellCoordsArray cells
= CalcCellsExposed( r
);
7244 // Otherwise refresh redraws the highlight!
7245 m_currentCellCoords
= coords
;
7247 #if defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS
7248 m_gridWin
->Refresh(true /*, & r */);
7250 DrawGridCellArea( dc
, cells
);
7251 DrawAllGridLines( dc
, r
);
7256 m_currentCellCoords
= coords
;
7258 wxGridCellAttr
*attr
= GetCellAttr( coords
);
7259 #if !(defined(__WXMAC__) && wxMAC_USE_CORE_GRAPHICS)
7260 DrawCellHighlight( dc
, attr
);
7265 void wxGrid::HighlightBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
)
7268 wxGridCellCoords updateTopLeft
, updateBottomRight
;
7272 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
7275 rightCol
= GetNumberCols() - 1;
7277 else if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
7280 bottomRow
= GetNumberRows() - 1;
7284 if ( topRow
> bottomRow
)
7291 if ( leftCol
> rightCol
)
7298 updateTopLeft
= wxGridCellCoords( topRow
, leftCol
);
7299 updateBottomRight
= wxGridCellCoords( bottomRow
, rightCol
);
7301 // First the case that we selected a completely new area
7302 if ( m_selectingTopLeft
== wxGridNoCellCoords
||
7303 m_selectingBottomRight
== wxGridNoCellCoords
)
7306 rect
= BlockToDeviceRect( wxGridCellCoords ( topRow
, leftCol
),
7307 wxGridCellCoords ( bottomRow
, rightCol
) );
7308 m_gridWin
->Refresh( false, &rect
);
7311 // Now handle changing an existing selection area.
7312 else if ( m_selectingTopLeft
!= updateTopLeft
||
7313 m_selectingBottomRight
!= updateBottomRight
)
7315 // Compute two optimal update rectangles:
7316 // Either one rectangle is a real subset of the
7317 // other, or they are (almost) disjoint!
7319 bool need_refresh
[4];
7323 need_refresh
[3] = false;
7326 // Store intermediate values
7327 wxCoord oldLeft
= m_selectingTopLeft
.GetCol();
7328 wxCoord oldTop
= m_selectingTopLeft
.GetRow();
7329 wxCoord oldRight
= m_selectingBottomRight
.GetCol();
7330 wxCoord oldBottom
= m_selectingBottomRight
.GetRow();
7332 // Determine the outer/inner coordinates.
7333 if (oldLeft
> leftCol
)
7339 if (oldTop
> topRow
)
7345 if (oldRight
< rightCol
)
7348 oldRight
= rightCol
;
7351 if (oldBottom
< bottomRow
)
7354 oldBottom
= bottomRow
;
7358 // Now, either the stuff marked old is the outer
7359 // rectangle or we don't have a situation where one
7360 // is contained in the other.
7362 if ( oldLeft
< leftCol
)
7364 // Refresh the newly selected or deselected
7365 // area to the left of the old or new selection.
7366 need_refresh
[0] = true;
7367 rect
[0] = BlockToDeviceRect(
7368 wxGridCellCoords( oldTop
, oldLeft
),
7369 wxGridCellCoords( oldBottom
, leftCol
- 1 ) );
7372 if ( oldTop
< topRow
)
7374 // Refresh the newly selected or deselected
7375 // area above the old or new selection.
7376 need_refresh
[1] = true;
7377 rect
[1] = BlockToDeviceRect(
7378 wxGridCellCoords( oldTop
, leftCol
),
7379 wxGridCellCoords( topRow
- 1, rightCol
) );
7382 if ( oldRight
> rightCol
)
7384 // Refresh the newly selected or deselected
7385 // area to the right of the old or new selection.
7386 need_refresh
[2] = true;
7387 rect
[2] = BlockToDeviceRect(
7388 wxGridCellCoords( oldTop
, rightCol
+ 1 ),
7389 wxGridCellCoords( oldBottom
, oldRight
) );
7392 if ( oldBottom
> bottomRow
)
7394 // Refresh the newly selected or deselected
7395 // area below the old or new selection.
7396 need_refresh
[3] = true;
7397 rect
[3] = BlockToDeviceRect(
7398 wxGridCellCoords( bottomRow
+ 1, leftCol
),
7399 wxGridCellCoords( oldBottom
, rightCol
) );
7402 // various Refresh() calls
7403 for (i
= 0; i
< 4; i
++ )
7404 if ( need_refresh
[i
] && rect
[i
] != wxGridNoCellRect
)
7405 m_gridWin
->Refresh( false, &(rect
[i
]) );
7409 m_selectingTopLeft
= updateTopLeft
;
7410 m_selectingBottomRight
= updateBottomRight
;
7414 // ------ functions to get/send data (see also public functions)
7417 bool wxGrid::GetModelValues()
7419 // Hide the editor, so it won't hide a changed value.
7420 HideCellEditControl();
7424 // all we need to do is repaint the grid
7426 m_gridWin
->Refresh();
7433 bool wxGrid::SetModelValues()
7437 // Disable the editor, so it won't hide a changed value.
7438 // Do we also want to save the current value of the editor first?
7440 DisableCellEditControl();
7444 for ( row
= 0; row
< m_numRows
; row
++ )
7446 for ( col
= 0; col
< m_numCols
; col
++ )
7448 m_table
->SetValue( row
, col
, GetCellValue(row
, col
) );
7458 // Note - this function only draws cells that are in the list of
7459 // exposed cells (usually set from the update region by
7460 // CalcExposedCells)
7462 void wxGrid::DrawGridCellArea( wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
7464 if ( !m_numRows
|| !m_numCols
)
7467 int i
, numCells
= cells
.GetCount();
7468 int row
, col
, cell_rows
, cell_cols
;
7469 wxGridCellCoordsArray redrawCells
;
7471 for ( i
= numCells
- 1; i
>= 0; i
-- )
7473 row
= cells
[i
].GetRow();
7474 col
= cells
[i
].GetCol();
7475 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7477 // If this cell is part of a multicell block, find owner for repaint
7478 if ( cell_rows
<= 0 || cell_cols
<= 0 )
7480 wxGridCellCoords
cell( row
+ cell_rows
, col
+ cell_cols
);
7481 bool marked
= false;
7482 for ( int j
= 0; j
< numCells
; j
++ )
7484 if ( cell
== cells
[j
] )
7493 int count
= redrawCells
.GetCount();
7494 for (int j
= 0; j
< count
; j
++)
7496 if ( cell
== redrawCells
[j
] )
7504 redrawCells
.Add( cell
);
7507 // don't bother drawing this cell
7511 // If this cell is empty, find cell to left that might want to overflow
7512 if (m_table
&& m_table
->IsEmptyCell(row
, col
))
7514 for ( int l
= 0; l
< cell_rows
; l
++ )
7516 // find a cell in this row to leave already marked for repaint
7518 for (int k
= 0; k
< int(redrawCells
.GetCount()); k
++)
7519 if ((redrawCells
[k
].GetCol() < left
) &&
7520 (redrawCells
[k
].GetRow() == row
))
7522 left
= redrawCells
[k
].GetCol();
7526 left
= 0; // oh well
7528 for (int j
= col
- 1; j
>= left
; j
--)
7530 if (!m_table
->IsEmptyCell(row
+ l
, j
))
7532 if (GetCellOverflow(row
+ l
, j
))
7534 wxGridCellCoords
cell(row
+ l
, j
);
7535 bool marked
= false;
7537 for (int k
= 0; k
< numCells
; k
++)
7539 if ( cell
== cells
[k
] )
7548 int count
= redrawCells
.GetCount();
7549 for (int k
= 0; k
< count
; k
++)
7551 if ( cell
== redrawCells
[k
] )
7558 redrawCells
.Add( cell
);
7567 DrawCell( dc
, cells
[i
] );
7570 numCells
= redrawCells
.GetCount();
7572 for ( i
= numCells
- 1; i
>= 0; i
-- )
7574 DrawCell( dc
, redrawCells
[i
] );
7578 void wxGrid::DrawGridSpace( wxDC
& dc
)
7581 m_gridWin
->GetClientSize( &cw
, &ch
);
7584 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
7586 int rightCol
= m_numCols
> 0 ? GetColRight(GetColAt( m_numCols
- 1 )) : 0;
7587 int bottomRow
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0;
7589 if ( right
> rightCol
|| bottom
> bottomRow
)
7592 CalcUnscrolledPosition( 0, 0, &left
, &top
);
7594 dc
.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxSOLID
) );
7595 dc
.SetPen( *wxTRANSPARENT_PEN
);
7597 if ( right
> rightCol
)
7599 dc
.DrawRectangle( rightCol
, top
, right
- rightCol
, ch
);
7602 if ( bottom
> bottomRow
)
7604 dc
.DrawRectangle( left
, bottomRow
, cw
, bottom
- bottomRow
);
7609 void wxGrid::DrawCell( wxDC
& dc
, const wxGridCellCoords
& coords
)
7611 int row
= coords
.GetRow();
7612 int col
= coords
.GetCol();
7614 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7617 // we draw the cell border ourselves
7618 #if !WXGRID_DRAW_LINES
7619 if ( m_gridLinesEnabled
)
7620 DrawCellBorder( dc
, coords
);
7623 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7625 bool isCurrent
= coords
== m_currentCellCoords
;
7627 wxRect rect
= CellToRect( row
, col
);
7629 // if the editor is shown, we should use it and not the renderer
7630 // Note: However, only if it is really _shown_, i.e. not hidden!
7631 if ( isCurrent
&& IsCellEditControlShown() )
7633 // NB: this "#if..." is temporary and fixes a problem where the
7634 // edit control is erased by this code after being rendered.
7635 // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
7636 // implicitly, causing this out-of order render.
7637 #if !defined(__WXMAC__)
7638 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
7639 editor
->PaintBackground(rect
, attr
);
7645 // but all the rest is drawn by the cell renderer and hence may be customized
7646 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
7647 renderer
->Draw(*this, *attr
, dc
, rect
, row
, col
, IsInSelection(coords
));
7654 void wxGrid::DrawCellHighlight( wxDC
& dc
, const wxGridCellAttr
*attr
)
7656 int row
= m_currentCellCoords
.GetRow();
7657 int col
= m_currentCellCoords
.GetCol();
7659 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7662 wxRect rect
= CellToRect(row
, col
);
7664 // hmmm... what could we do here to show that the cell is disabled?
7665 // for now, I just draw a thinner border than for the other ones, but
7666 // it doesn't look really good
7668 int penWidth
= attr
->IsReadOnly() ? m_cellHighlightROPenWidth
: m_cellHighlightPenWidth
;
7672 // The center of the drawn line is where the position/width/height of
7673 // the rectangle is actually at (on wxMSW at least), so the
7674 // size of the rectangle is reduced to compensate for the thickness of
7675 // the line. If this is too strange on non-wxMSW platforms then
7676 // please #ifdef this appropriately.
7677 rect
.x
+= penWidth
/ 2;
7678 rect
.y
+= penWidth
/ 2;
7679 rect
.width
-= penWidth
- 1;
7680 rect
.height
-= penWidth
- 1;
7682 // Now draw the rectangle
7683 // use the cellHighlightColour if the cell is inside a selection, this
7684 // will ensure the cell is always visible.
7685 dc
.SetPen(wxPen(IsInSelection(row
,col
) ? m_selectionForeground
: m_cellHighlightColour
, penWidth
, wxSOLID
));
7686 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
7687 dc
.DrawRectangle(rect
);
7691 // VZ: my experiments with 3D borders...
7693 // how to properly set colours for arbitrary bg?
7694 wxCoord x1
= rect
.x
,
7696 x2
= rect
.x
+ rect
.width
- 1,
7697 y2
= rect
.y
+ rect
.height
- 1;
7699 dc
.SetPen(*wxWHITE_PEN
);
7700 dc
.DrawLine(x1
, y1
, x2
, y1
);
7701 dc
.DrawLine(x1
, y1
, x1
, y2
);
7703 dc
.DrawLine(x1
+ 1, y2
- 1, x2
- 1, y2
- 1);
7704 dc
.DrawLine(x2
- 1, y1
+ 1, x2
- 1, y2
);
7706 dc
.SetPen(*wxBLACK_PEN
);
7707 dc
.DrawLine(x1
, y2
, x2
, y2
);
7708 dc
.DrawLine(x2
, y1
, x2
, y2
+ 1);
7712 wxPen
wxGrid::GetDefaultGridLinePen()
7714 return wxPen(GetGridLineColour(), 1, wxSOLID
);
7717 wxPen
wxGrid::GetRowGridLinePen(int WXUNUSED(row
))
7719 return GetDefaultGridLinePen();
7722 wxPen
wxGrid::GetColGridLinePen(int WXUNUSED(col
))
7724 return GetDefaultGridLinePen();
7727 void wxGrid::DrawCellBorder( wxDC
& dc
, const wxGridCellCoords
& coords
)
7729 int row
= coords
.GetRow();
7730 int col
= coords
.GetCol();
7731 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7735 wxRect rect
= CellToRect( row
, col
);
7737 // right hand border
7738 dc
.SetPen( GetColGridLinePen(col
) );
7739 dc
.DrawLine( rect
.x
+ rect
.width
, rect
.y
,
7740 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
+ 1 );
7743 dc
.SetPen( GetRowGridLinePen(row
) );
7744 dc
.DrawLine( rect
.x
, rect
.y
+ rect
.height
,
7745 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
7748 void wxGrid::DrawHighlight(wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
7750 // This if block was previously in wxGrid::OnPaint but that doesn't
7751 // seem to get called under wxGTK - MB
7753 if ( m_currentCellCoords
== wxGridNoCellCoords
&&
7754 m_numRows
&& m_numCols
)
7756 m_currentCellCoords
.Set(0, 0);
7759 if ( IsCellEditControlShown() )
7761 // don't show highlight when the edit control is shown
7765 // if the active cell was repainted, repaint its highlight too because it
7766 // might have been damaged by the grid lines
7767 size_t count
= cells
.GetCount();
7768 for ( size_t n
= 0; n
< count
; n
++ )
7770 if ( cells
[n
] == m_currentCellCoords
)
7772 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
7773 DrawCellHighlight(dc
, attr
);
7781 // TODO: remove this ???
7782 // This is used to redraw all grid lines e.g. when the grid line colour
7785 void wxGrid::DrawAllGridLines( wxDC
& dc
, const wxRegion
& WXUNUSED(reg
) )
7787 #if !WXGRID_DRAW_LINES
7791 if ( !m_gridLinesEnabled
|| !m_numRows
|| !m_numCols
)
7794 int top
, bottom
, left
, right
;
7796 #if 0 //#ifndef __WXGTK__
7800 m_gridWin
->GetClientSize(&cw
, &ch
);
7802 // virtual coords of visible area
7804 CalcUnscrolledPosition( 0, 0, &left
, &top
);
7805 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
7810 reg
.GetBox(x
, y
, w
, h
);
7811 CalcUnscrolledPosition( x
, y
, &left
, &top
);
7812 CalcUnscrolledPosition( x
+ w
, y
+ h
, &right
, &bottom
);
7816 m_gridWin
->GetClientSize(&cw
, &ch
);
7817 CalcUnscrolledPosition( 0, 0, &left
, &top
);
7818 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
7821 // avoid drawing grid lines past the last row and col
7823 right
= wxMin( right
, GetColRight(GetColAt( m_numCols
- 1 )) );
7824 bottom
= wxMin( bottom
, GetRowBottom(m_numRows
- 1) );
7826 // no gridlines inside multicells, clip them out
7827 int leftCol
= GetColPos( internalXToCol(left
) );
7828 int topRow
= internalYToRow(top
);
7829 int rightCol
= GetColPos( internalXToCol(right
) );
7830 int bottomRow
= internalYToRow(bottom
);
7832 #if !defined(__WXMAC__) || wxMAC_USE_CORE_GRAPHICS
7833 wxRegion
clippedcells(0, 0, cw
, ch
);
7835 int i
, j
, cell_rows
, cell_cols
;
7838 for (j
=topRow
; j
<=bottomRow
; j
++)
7841 for (colPos
=leftCol
; colPos
<=rightCol
; colPos
++)
7843 i
= GetColAt( colPos
);
7845 GetCellSize( j
, i
, &cell_rows
, &cell_cols
);
7846 if ((cell_rows
> 1) || (cell_cols
> 1))
7848 rect
= CellToRect(j
,i
);
7849 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7850 clippedcells
.Subtract(rect
);
7852 else if ((cell_rows
< 0) || (cell_cols
< 0))
7854 rect
= CellToRect(j
+ cell_rows
, i
+ cell_cols
);
7855 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7856 clippedcells
.Subtract(rect
);
7861 wxRegion
clippedcells( left
, top
, right
- left
, bottom
- top
);
7863 int i
, j
, cell_rows
, cell_cols
;
7866 for (j
=topRow
; j
<=bottomRow
; j
++)
7868 for (i
=leftCol
; i
<=rightCol
; i
++)
7870 GetCellSize( j
, i
, &cell_rows
, &cell_cols
);
7871 if ((cell_rows
> 1) || (cell_cols
> 1))
7873 rect
= CellToRect(j
, i
);
7874 clippedcells
.Subtract(rect
);
7876 else if ((cell_rows
< 0) || (cell_cols
< 0))
7878 rect
= CellToRect(j
+ cell_rows
, i
+ cell_cols
);
7879 clippedcells
.Subtract(rect
);
7885 dc
.SetClippingRegion( clippedcells
);
7888 // horizontal grid lines
7890 // already declared above - int i;
7891 for ( i
= internalYToRow(top
); i
< m_numRows
; i
++ )
7893 int bot
= GetRowBottom(i
) - 1;
7902 dc
.SetPen( GetRowGridLinePen(i
) );
7903 dc
.DrawLine( left
, bot
, right
, bot
);
7907 // vertical grid lines
7910 for ( colPos
= leftCol
; colPos
< m_numCols
; colPos
++ )
7912 i
= GetColAt( colPos
);
7914 int colRight
= GetColRight(i
);
7916 if (GetLayoutDirection() != wxLayout_RightToLeft
)
7920 if ( colRight
> right
)
7925 if ( colRight
>= left
)
7927 dc
.SetPen( GetColGridLinePen(i
) );
7928 dc
.DrawLine( colRight
, top
, colRight
, bottom
);
7932 dc
.DestroyClippingRegion();
7935 void wxGrid::DrawRowLabels( wxDC
& dc
, const wxArrayInt
& rows
)
7941 size_t numLabels
= rows
.GetCount();
7943 for ( i
= 0; i
< numLabels
; i
++ )
7945 DrawRowLabel( dc
, rows
[i
] );
7949 void wxGrid::DrawRowLabel( wxDC
& dc
, int row
)
7951 if ( GetRowHeight(row
) <= 0 || m_rowLabelWidth
<= 0 )
7959 rect
.SetY( GetRowTop(row
) + 1 );
7960 rect
.SetWidth( m_rowLabelWidth
- 2 );
7961 rect
.SetHeight( GetRowHeight(row
) - 2 );
7963 CalcScrolledPosition( 0, rect
.y
, NULL
, &rect
.y
);
7965 wxWindowDC
*win_dc
= (wxWindowDC
*) &dc
;
7967 wxRendererNative::Get().DrawHeaderButton( win_dc
->m_owner
, dc
, rect
, 0 );
7969 int rowTop
= GetRowTop(row
),
7970 rowBottom
= GetRowBottom(row
) - 1;
7972 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
), 1, wxSOLID
) );
7973 dc
.DrawLine( m_rowLabelWidth
- 1, rowTop
, m_rowLabelWidth
- 1, rowBottom
);
7974 dc
.DrawLine( 0, rowTop
, 0, rowBottom
);
7975 dc
.DrawLine( 0, rowBottom
, m_rowLabelWidth
, rowBottom
);
7977 dc
.SetPen( *wxWHITE_PEN
);
7978 dc
.DrawLine( 1, rowTop
, 1, rowBottom
);
7979 dc
.DrawLine( 1, rowTop
, m_rowLabelWidth
- 1, rowTop
);
7982 dc
.SetBackgroundMode( wxTRANSPARENT
);
7983 dc
.SetTextForeground( GetLabelTextColour() );
7984 dc
.SetFont( GetLabelFont() );
7987 GetRowLabelAlignment( &hAlign
, &vAlign
);
7990 rect
.SetY( GetRowTop(row
) + 2 );
7991 rect
.SetWidth( m_rowLabelWidth
- 4 );
7992 rect
.SetHeight( GetRowHeight(row
) - 4 );
7993 DrawTextRectangle( dc
, GetRowLabelValue( row
), rect
, hAlign
, vAlign
);
7996 void wxGrid::DrawColLabels( wxDC
& dc
,const wxArrayInt
& cols
)
8002 size_t numLabels
= cols
.GetCount();
8004 for ( i
= 0; i
< numLabels
; i
++ )
8006 DrawColLabel( dc
, cols
[i
] );
8010 void wxGrid::DrawColLabel( wxDC
& dc
, int col
)
8012 if ( GetColWidth(col
) <= 0 || m_colLabelHeight
<= 0 )
8015 int colLeft
= GetColLeft(col
);
8021 rect
.SetX( colLeft
+ 1 );
8023 rect
.SetWidth( GetColWidth(col
) - 2 );
8024 rect
.SetHeight( m_colLabelHeight
- 2 );
8026 wxWindowDC
*win_dc
= (wxWindowDC
*) &dc
;
8028 wxRendererNative::Get().DrawHeaderButton( win_dc
->m_owner
, dc
, rect
, 0 );
8030 int colRight
= GetColRight(col
) - 1;
8032 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
), 1, wxSOLID
) );
8033 dc
.DrawLine( colRight
, 0, colRight
, m_colLabelHeight
- 1 );
8034 dc
.DrawLine( colLeft
, 0, colRight
, 0 );
8035 dc
.DrawLine( colLeft
, m_colLabelHeight
- 1,
8036 colRight
+ 1, m_colLabelHeight
- 1 );
8038 dc
.SetPen( *wxWHITE_PEN
);
8039 dc
.DrawLine( colLeft
, 1, colLeft
, m_colLabelHeight
- 1 );
8040 dc
.DrawLine( colLeft
, 1, colRight
, 1 );
8043 dc
.SetBackgroundMode( wxTRANSPARENT
);
8044 dc
.SetTextForeground( GetLabelTextColour() );
8045 dc
.SetFont( GetLabelFont() );
8047 int hAlign
, vAlign
, orient
;
8048 GetColLabelAlignment( &hAlign
, &vAlign
);
8049 orient
= GetColLabelTextOrientation();
8051 rect
.SetX( colLeft
+ 2 );
8053 rect
.SetWidth( GetColWidth(col
) - 4 );
8054 rect
.SetHeight( m_colLabelHeight
- 4 );
8055 DrawTextRectangle( dc
, GetColLabelValue( col
), rect
, hAlign
, vAlign
, orient
);
8058 void wxGrid::DrawTextRectangle( wxDC
& dc
,
8059 const wxString
& value
,
8063 int textOrientation
)
8065 wxArrayString lines
;
8067 StringToLines( value
, lines
);
8069 // Forward to new API.
8070 DrawTextRectangle( dc
,
8078 // VZ: this should be replaced with wxDC::DrawLabel() to which we just have to
8079 // add textOrientation support
8080 void wxGrid::DrawTextRectangle(wxDC
& dc
,
8081 const wxArrayString
& lines
,
8085 int textOrientation
)
8087 if ( lines
.empty() )
8090 wxDCClipper
clip(dc
, rect
);
8095 if ( textOrientation
== wxHORIZONTAL
)
8096 GetTextBoxSize( dc
, lines
, &textWidth
, &textHeight
);
8098 GetTextBoxSize( dc
, lines
, &textHeight
, &textWidth
);
8102 switch ( vertAlign
)
8104 case wxALIGN_BOTTOM
:
8105 if ( textOrientation
== wxHORIZONTAL
)
8106 y
= rect
.y
+ (rect
.height
- textHeight
- 1);
8108 x
= rect
.x
+ rect
.width
- textWidth
;
8111 case wxALIGN_CENTRE
:
8112 if ( textOrientation
== wxHORIZONTAL
)
8113 y
= rect
.y
+ ((rect
.height
- textHeight
) / 2);
8115 x
= rect
.x
+ ((rect
.width
- textWidth
) / 2);
8120 if ( textOrientation
== wxHORIZONTAL
)
8127 // Align each line of a multi-line label
8128 size_t nLines
= lines
.GetCount();
8129 for ( size_t l
= 0; l
< nLines
; l
++ )
8131 const wxString
& line
= lines
[l
];
8135 *(textOrientation
== wxHORIZONTAL
? &y
: &x
) += dc
.GetCharHeight();
8139 wxCoord lineWidth
= 0,
8141 dc
.GetTextExtent(line
, &lineWidth
, &lineHeight
);
8143 switch ( horizAlign
)
8146 if ( textOrientation
== wxHORIZONTAL
)
8147 x
= rect
.x
+ (rect
.width
- lineWidth
- 1);
8149 y
= rect
.y
+ lineWidth
+ 1;
8152 case wxALIGN_CENTRE
:
8153 if ( textOrientation
== wxHORIZONTAL
)
8154 x
= rect
.x
+ ((rect
.width
- lineWidth
) / 2);
8156 y
= rect
.y
+ rect
.height
- ((rect
.height
- lineWidth
) / 2);
8161 if ( textOrientation
== wxHORIZONTAL
)
8164 y
= rect
.y
+ rect
.height
- 1;
8168 if ( textOrientation
== wxHORIZONTAL
)
8170 dc
.DrawText( line
, x
, y
);
8175 dc
.DrawRotatedText( line
, x
, y
, 90.0 );
8181 // Split multi-line text up into an array of strings.
8182 // Any existing contents of the string array are preserved.
8184 void wxGrid::StringToLines( const wxString
& value
, wxArrayString
& lines
) const
8188 wxString eol
= wxTextFile::GetEOL( wxTextFileType_Unix
);
8189 wxString tVal
= wxTextFile::Translate( value
, wxTextFileType_Unix
);
8191 while ( startPos
< (int)tVal
.length() )
8193 pos
= tVal
.Mid(startPos
).Find( eol
);
8198 else if ( pos
== 0 )
8200 lines
.Add( wxEmptyString
);
8204 lines
.Add( value
.Mid(startPos
, pos
) );
8207 startPos
+= pos
+ 1;
8210 if ( startPos
< (int)value
.length() )
8212 lines
.Add( value
.Mid( startPos
) );
8216 void wxGrid::GetTextBoxSize( const wxDC
& dc
,
8217 const wxArrayString
& lines
,
8218 long *width
, long *height
) const
8222 wxCoord lineW
= 0, lineH
= 0;
8225 for ( i
= 0; i
< lines
.GetCount(); i
++ )
8227 dc
.GetTextExtent( lines
[i
], &lineW
, &lineH
);
8228 w
= wxMax( w
, lineW
);
8237 // ------ Batch processing.
8239 void wxGrid::EndBatch()
8241 if ( m_batchCount
> 0 )
8244 if ( !m_batchCount
)
8247 m_rowLabelWin
->Refresh();
8248 m_colLabelWin
->Refresh();
8249 m_cornerLabelWin
->Refresh();
8250 m_gridWin
->Refresh();
8255 // Use this, rather than wxWindow::Refresh(), to force an immediate
8256 // repainting of the grid. Has no effect if you are already inside a
8257 // BeginBatch / EndBatch block.
8259 void wxGrid::ForceRefresh()
8265 bool wxGrid::Enable(bool enable
)
8267 if ( !wxScrolledWindow::Enable(enable
) )
8270 // redraw in the new state
8271 m_gridWin
->Refresh();
8277 // ------ Edit control functions
8280 void wxGrid::EnableEditing( bool edit
)
8282 // TODO: improve this ?
8284 if ( edit
!= m_editable
)
8287 EnableCellEditControl(edit
);
8292 void wxGrid::EnableCellEditControl( bool enable
)
8297 if ( enable
!= m_cellEditCtrlEnabled
)
8301 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN
) <0)
8304 // this should be checked by the caller!
8305 wxASSERT_MSG( CanEnableCellControl(), _T("can't enable editing for this cell!") );
8307 // do it before ShowCellEditControl()
8308 m_cellEditCtrlEnabled
= enable
;
8310 ShowCellEditControl();
8314 //FIXME:add veto support
8315 SendEvent( wxEVT_GRID_EDITOR_HIDDEN
);
8317 HideCellEditControl();
8318 SaveEditControlValue();
8320 // do it after HideCellEditControl()
8321 m_cellEditCtrlEnabled
= enable
;
8326 bool wxGrid::IsCurrentCellReadOnly() const
8329 wxGridCellAttr
* attr
= ((wxGrid
*)this)->GetCellAttr(m_currentCellCoords
);
8330 bool readonly
= attr
->IsReadOnly();
8336 bool wxGrid::CanEnableCellControl() const
8338 return m_editable
&& (m_currentCellCoords
!= wxGridNoCellCoords
) &&
8339 !IsCurrentCellReadOnly();
8342 bool wxGrid::IsCellEditControlEnabled() const
8344 // the cell edit control might be disable for all cells or just for the
8345 // current one if it's read only
8346 return m_cellEditCtrlEnabled
? !IsCurrentCellReadOnly() : false;
8349 bool wxGrid::IsCellEditControlShown() const
8351 bool isShown
= false;
8353 if ( m_cellEditCtrlEnabled
)
8355 int row
= m_currentCellCoords
.GetRow();
8356 int col
= m_currentCellCoords
.GetCol();
8357 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8358 wxGridCellEditor
* editor
= attr
->GetEditor((wxGrid
*) this, row
, col
);
8363 if ( editor
->IsCreated() )
8365 isShown
= editor
->GetControl()->IsShown();
8375 void wxGrid::ShowCellEditControl()
8377 if ( IsCellEditControlEnabled() )
8379 if ( !IsVisible( m_currentCellCoords
, false ) )
8381 m_cellEditCtrlEnabled
= false;
8386 wxRect rect
= CellToRect( m_currentCellCoords
);
8387 int row
= m_currentCellCoords
.GetRow();
8388 int col
= m_currentCellCoords
.GetCol();
8390 // if this is part of a multicell, find owner (topleft)
8391 int cell_rows
, cell_cols
;
8392 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8393 if ( cell_rows
<= 0 || cell_cols
<= 0 )
8397 m_currentCellCoords
.SetRow( row
);
8398 m_currentCellCoords
.SetCol( col
);
8401 // erase the highlight and the cell contents because the editor
8402 // might not cover the entire cell
8403 wxClientDC
dc( m_gridWin
);
8405 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8406 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
8407 dc
.SetPen(*wxTRANSPARENT_PEN
);
8408 dc
.DrawRectangle(rect
);
8410 // convert to scrolled coords
8411 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
8417 // cell is shifted by one pixel
8418 // However, don't allow x or y to become negative
8419 // since the SetSize() method interprets that as
8426 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
8427 if ( !editor
->IsCreated() )
8429 editor
->Create(m_gridWin
, wxID_ANY
,
8430 new wxGridCellEditorEvtHandler(this, editor
));
8432 wxGridEditorCreatedEvent
evt(GetId(),
8433 wxEVT_GRID_EDITOR_CREATED
,
8437 editor
->GetControl());
8438 GetEventHandler()->ProcessEvent(evt
);
8441 // resize editor to overflow into righthand cells if allowed
8442 int maxWidth
= rect
.width
;
8443 wxString value
= GetCellValue(row
, col
);
8444 if ( (value
!= wxEmptyString
) && (attr
->GetOverflow()) )
8447 GetTextExtent(value
, &maxWidth
, &y
, NULL
, NULL
, &attr
->GetFont());
8448 if (maxWidth
< rect
.width
)
8449 maxWidth
= rect
.width
;
8452 int client_right
= m_gridWin
->GetClientSize().GetWidth();
8453 if (rect
.x
+ maxWidth
> client_right
)
8454 maxWidth
= client_right
- rect
.x
;
8456 if ((maxWidth
> rect
.width
) && (col
< m_numCols
) && m_table
)
8458 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8459 // may have changed earlier
8460 for (int i
= col
+ cell_cols
; i
< m_numCols
; i
++)
8463 GetCellSize( row
, i
, &c_rows
, &c_cols
);
8465 // looks weird going over a multicell
8466 if (m_table
->IsEmptyCell( row
, i
) &&
8467 (rect
.width
< maxWidth
) && (c_rows
== 1))
8469 rect
.width
+= GetColWidth( i
);
8475 if (rect
.GetRight() > client_right
)
8476 rect
.SetRight( client_right
- 1 );
8479 editor
->SetCellAttr( attr
);
8480 editor
->SetSize( rect
);
8482 editor
->GetControl()->Move(
8483 editor
->GetControl()->GetPosition().x
+ nXMove
,
8484 editor
->GetControl()->GetPosition().y
);
8485 editor
->Show( true, attr
);
8487 // recalc dimensions in case we need to
8488 // expand the scrolled window to account for editor
8491 editor
->BeginEdit(row
, col
, this);
8492 editor
->SetCellAttr(NULL
);
8500 void wxGrid::HideCellEditControl()
8502 if ( IsCellEditControlEnabled() )
8504 int row
= m_currentCellCoords
.GetRow();
8505 int col
= m_currentCellCoords
.GetCol();
8507 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8508 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
8509 editor
->Show( false );
8513 m_gridWin
->SetFocus();
8515 // refresh whole row to the right
8516 wxRect
rect( CellToRect(row
, col
) );
8517 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
8518 rect
.width
= m_gridWin
->GetClientSize().GetWidth() - rect
.x
;
8521 // ensure that the pixels under the focus ring get refreshed as well
8522 rect
.Inflate(10, 10);
8525 m_gridWin
->Refresh( false, &rect
);
8529 void wxGrid::SaveEditControlValue()
8531 if ( IsCellEditControlEnabled() )
8533 int row
= m_currentCellCoords
.GetRow();
8534 int col
= m_currentCellCoords
.GetCol();
8536 wxString oldval
= GetCellValue(row
, col
);
8538 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8539 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
8540 bool changed
= editor
->EndEdit(row
, col
, this);
8547 if ( SendEvent( wxEVT_GRID_CELL_CHANGE
,
8548 m_currentCellCoords
.GetRow(),
8549 m_currentCellCoords
.GetCol() ) < 0 )
8551 // Event has been vetoed, set the data back.
8552 SetCellValue(row
, col
, oldval
);
8559 // ------ Grid location functions
8560 // Note that all of these functions work with the logical coordinates of
8561 // grid cells and labels so you will need to convert from device
8562 // coordinates for mouse events etc.
8565 void wxGrid::XYToCell( int x
, int y
, wxGridCellCoords
& coords
) const
8567 int row
= YToRow(y
);
8568 int col
= XToCol(x
);
8570 if ( row
== -1 || col
== -1 )
8572 coords
= wxGridNoCellCoords
;
8576 coords
.Set( row
, col
);
8580 // Internal Helper function for computing row or column from some
8581 // (unscrolled) coordinate value, using either
8582 // m_defaultRowHeight/m_defaultColWidth or binary search on array
8583 // of m_rowBottoms/m_ColRights to speed up the search!
8585 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
8586 const wxArrayInt
& BorderArray
, int nMax
,
8590 return clipToMinMax
&& (nMax
> 0) ? 0 : -1;
8595 size_t i_max
= coord
/ defaultDist
,
8598 if (BorderArray
.IsEmpty())
8600 if ((int) i_max
< nMax
)
8602 return clipToMinMax
? nMax
- 1 : -1;
8605 if ( i_max
>= BorderArray
.GetCount())
8607 i_max
= BorderArray
.GetCount() - 1;
8611 if ( coord
>= BorderArray
[i_max
])
8615 i_max
= coord
/ minDist
;
8617 i_max
= BorderArray
.GetCount() - 1;
8620 if ( i_max
>= BorderArray
.GetCount())
8621 i_max
= BorderArray
.GetCount() - 1;
8624 if ( coord
>= BorderArray
[i_max
])
8625 return clipToMinMax
? (int)i_max
: -1;
8626 if ( coord
< BorderArray
[0] )
8629 while ( i_max
- i_min
> 0 )
8631 wxCHECK_MSG(BorderArray
[i_min
] <= coord
&& coord
< BorderArray
[i_max
],
8632 0, _T("wxGrid: internal error in CoordToRowOrCol"));
8633 if (coord
>= BorderArray
[ i_max
- 1])
8637 int median
= i_min
+ (i_max
- i_min
+ 1) / 2;
8638 if (coord
< BorderArray
[median
])
8647 int wxGrid::YToRow( int y
) const
8649 return CoordToRowOrCol(y
, m_defaultRowHeight
,
8650 m_minAcceptableRowHeight
, m_rowBottoms
, m_numRows
, false);
8653 int wxGrid::XToCol( int x
, bool clipToMinMax
) const
8656 return clipToMinMax
&& (m_numCols
> 0) ? GetColAt( 0 ) : -1;
8658 wxASSERT_MSG(m_defaultColWidth
> 0, wxT("Default column width can not be zero"));
8660 int maxPos
= x
/ m_defaultColWidth
;
8663 if (m_colRights
.IsEmpty())
8665 if(maxPos
< m_numCols
)
8666 return GetColAt( maxPos
);
8667 return clipToMinMax
? GetColAt( m_numCols
- 1 ) : -1;
8670 if ( maxPos
>= m_numCols
)
8671 maxPos
= m_numCols
- 1;
8674 if ( x
>= m_colRights
[GetColAt( maxPos
)])
8677 if (m_minAcceptableColWidth
)
8678 maxPos
= x
/ m_minAcceptableColWidth
;
8680 maxPos
= m_numCols
- 1;
8682 if ( maxPos
>= m_numCols
)
8683 maxPos
= m_numCols
- 1;
8686 //X is beyond the last column
8687 if ( x
>= m_colRights
[GetColAt( maxPos
)])
8688 return clipToMinMax
? GetColAt( maxPos
) : -1;
8690 //X is before the first column
8691 if ( x
< m_colRights
[GetColAt( 0 )] )
8692 return GetColAt( 0 );
8694 //Perform a binary search
8695 while ( maxPos
- minPos
> 0 )
8697 wxCHECK_MSG(m_colRights
[GetColAt( minPos
)] <= x
&& x
< m_colRights
[GetColAt( maxPos
)],
8698 0, _T("wxGrid: internal error in XToCol"));
8700 if (x
>= m_colRights
[GetColAt( maxPos
- 1 )])
8701 return GetColAt( maxPos
);
8704 int median
= minPos
+ (maxPos
- minPos
+ 1) / 2;
8705 if (x
< m_colRights
[GetColAt( median
)])
8710 return GetColAt( maxPos
);
8713 // return the row number that that the y coord is near
8714 // the edge of, or -1 if not near an edge.
8715 // coords can only possibly be near an edge if
8716 // (a) the row/column is large enough to still allow for an "inner" area
8717 // that is _not_ nead the edge (i.e., if the height/width is smaller
8718 // than WXGRID_LABEL_EDGE_ZONE, coords are _never_ considered to be
8721 // (b) resizing rows/columns (the thing for which edge detection is
8722 // relevant at all) is enabled.
8724 int wxGrid::YToEdgeOfRow( int y
) const
8727 i
= internalYToRow(y
);
8729 if ( GetRowHeight(i
) > WXGRID_LABEL_EDGE_ZONE
&& CanDragRowSize() )
8731 // We know that we are in row i, test whether we are
8732 // close enough to lower or upper border, respectively.
8733 if ( abs(GetRowBottom(i
) - y
) < WXGRID_LABEL_EDGE_ZONE
)
8735 else if ( i
> 0 && y
- GetRowTop(i
) < WXGRID_LABEL_EDGE_ZONE
)
8742 // return the col number that that the x coord is near the edge of, or
8743 // -1 if not near an edge
8744 // See comment at YToEdgeOfRow for conditions on edge detection.
8746 int wxGrid::XToEdgeOfCol( int x
) const
8749 i
= internalXToCol(x
);
8751 if ( GetColWidth(i
) > WXGRID_LABEL_EDGE_ZONE
&& CanDragColSize() )
8753 // We know that we are in column i; test whether we are
8754 // close enough to right or left border, respectively.
8755 if ( abs(GetColRight(i
) - x
) < WXGRID_LABEL_EDGE_ZONE
)
8757 else if ( i
> 0 && x
- GetColLeft(i
) < WXGRID_LABEL_EDGE_ZONE
)
8764 wxRect
wxGrid::CellToRect( int row
, int col
) const
8766 wxRect
rect( -1, -1, -1, -1 );
8768 if ( row
>= 0 && row
< m_numRows
&&
8769 col
>= 0 && col
< m_numCols
)
8771 int i
, cell_rows
, cell_cols
;
8772 rect
.width
= rect
.height
= 0;
8773 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8774 // if negative then find multicell owner
8779 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8781 rect
.x
= GetColLeft(col
);
8782 rect
.y
= GetRowTop(row
);
8783 for (i
=col
; i
< col
+ cell_cols
; i
++)
8784 rect
.width
+= GetColWidth(i
);
8785 for (i
=row
; i
< row
+ cell_rows
; i
++)
8786 rect
.height
+= GetRowHeight(i
);
8789 // if grid lines are enabled, then the area of the cell is a bit smaller
8790 if (m_gridLinesEnabled
)
8799 bool wxGrid::IsVisible( int row
, int col
, bool wholeCellVisible
) const
8801 // get the cell rectangle in logical coords
8803 wxRect
r( CellToRect( row
, col
) );
8805 // convert to device coords
8807 int left
, top
, right
, bottom
;
8808 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
8809 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
8811 // check against the client area of the grid window
8813 m_gridWin
->GetClientSize( &cw
, &ch
);
8815 if ( wholeCellVisible
)
8817 // is the cell wholly visible ?
8818 return ( left
>= 0 && right
<= cw
&&
8819 top
>= 0 && bottom
<= ch
);
8823 // is the cell partly visible ?
8825 return ( ((left
>= 0 && left
< cw
) || (right
> 0 && right
<= cw
)) &&
8826 ((top
>= 0 && top
< ch
) || (bottom
> 0 && bottom
<= ch
)) );
8830 // make the specified cell location visible by doing a minimal amount
8833 void wxGrid::MakeCellVisible( int row
, int col
)
8836 int xpos
= -1, ypos
= -1;
8838 if ( row
>= 0 && row
< m_numRows
&&
8839 col
>= 0 && col
< m_numCols
)
8841 // get the cell rectangle in logical coords
8842 wxRect
r( CellToRect( row
, col
) );
8844 // convert to device coords
8845 int left
, top
, right
, bottom
;
8846 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
8847 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
8850 m_gridWin
->GetClientSize( &cw
, &ch
);
8856 else if ( bottom
> ch
)
8858 int h
= r
.GetHeight();
8860 for ( i
= row
- 1; i
>= 0; i
-- )
8862 int rowHeight
= GetRowHeight(i
);
8863 if ( h
+ rowHeight
> ch
)
8870 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
8871 // have rounding errors (this is important, because if we do,
8872 // we might not scroll at all and some cells won't be redrawn)
8874 // Sometimes GRID_SCROLL_LINE / 2 is not enough,
8875 // so just add a full scroll unit...
8876 ypos
+= m_scrollLineY
;
8879 // special handling for wide cells - show always left part of the cell!
8880 // Otherwise, e.g. when stepping from row to row, it would jump between
8881 // left and right part of the cell on every step!
8883 if ( left
< 0 || (right
- left
) >= cw
)
8887 else if ( right
> cw
)
8889 // position the view so that the cell is on the right
8891 CalcUnscrolledPosition(0, 0, &x0
, &y0
);
8892 xpos
= x0
+ (right
- cw
);
8894 // see comment for ypos above
8895 xpos
+= m_scrollLineX
;
8898 if ( xpos
!= -1 || ypos
!= -1 )
8901 xpos
/= m_scrollLineX
;
8903 ypos
/= m_scrollLineY
;
8904 Scroll( xpos
, ypos
);
8911 // ------ Grid cursor movement functions
8914 bool wxGrid::MoveCursorUp( bool expandSelection
)
8916 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
8917 m_currentCellCoords
.GetRow() >= 0 )
8919 if ( expandSelection
)
8921 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
8922 m_selectingKeyboard
= m_currentCellCoords
;
8923 if ( m_selectingKeyboard
.GetRow() > 0 )
8925 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() - 1 );
8926 MakeCellVisible( m_selectingKeyboard
.GetRow(),
8927 m_selectingKeyboard
.GetCol() );
8928 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8931 else if ( m_currentCellCoords
.GetRow() > 0 )
8933 int row
= m_currentCellCoords
.GetRow() - 1;
8934 int col
= m_currentCellCoords
.GetCol();
8936 MakeCellVisible( row
, col
);
8937 SetCurrentCell( row
, col
);
8948 bool wxGrid::MoveCursorDown( bool expandSelection
)
8950 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
8951 m_currentCellCoords
.GetRow() < m_numRows
)
8953 if ( expandSelection
)
8955 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
8956 m_selectingKeyboard
= m_currentCellCoords
;
8957 if ( m_selectingKeyboard
.GetRow() < m_numRows
- 1 )
8959 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() + 1 );
8960 MakeCellVisible( m_selectingKeyboard
.GetRow(),
8961 m_selectingKeyboard
.GetCol() );
8962 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8965 else if ( m_currentCellCoords
.GetRow() < m_numRows
- 1 )
8967 int row
= m_currentCellCoords
.GetRow() + 1;
8968 int col
= m_currentCellCoords
.GetCol();
8970 MakeCellVisible( row
, col
);
8971 SetCurrentCell( row
, col
);
8982 bool wxGrid::MoveCursorLeft( bool expandSelection
)
8984 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
8985 m_currentCellCoords
.GetCol() >= 0 )
8987 if ( expandSelection
)
8989 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
8990 m_selectingKeyboard
= m_currentCellCoords
;
8991 if ( m_selectingKeyboard
.GetCol() > 0 )
8993 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() - 1 );
8994 MakeCellVisible( m_selectingKeyboard
.GetRow(),
8995 m_selectingKeyboard
.GetCol() );
8996 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8999 else if ( GetColPos( m_currentCellCoords
.GetCol() ) > 0 )
9001 int row
= m_currentCellCoords
.GetRow();
9002 int col
= GetColAt( GetColPos( m_currentCellCoords
.GetCol() ) - 1 );
9005 MakeCellVisible( row
, col
);
9006 SetCurrentCell( row
, col
);
9017 bool wxGrid::MoveCursorRight( bool expandSelection
)
9019 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
9020 m_currentCellCoords
.GetCol() < m_numCols
)
9022 if ( expandSelection
)
9024 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
9025 m_selectingKeyboard
= m_currentCellCoords
;
9026 if ( m_selectingKeyboard
.GetCol() < m_numCols
- 1 )
9028 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() + 1 );
9029 MakeCellVisible( m_selectingKeyboard
.GetRow(),
9030 m_selectingKeyboard
.GetCol() );
9031 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9034 else if ( GetColPos( m_currentCellCoords
.GetCol() ) < m_numCols
- 1 )
9036 int row
= m_currentCellCoords
.GetRow();
9037 int col
= GetColAt( GetColPos( m_currentCellCoords
.GetCol() ) + 1 );
9040 MakeCellVisible( row
, col
);
9041 SetCurrentCell( row
, col
);
9052 bool wxGrid::MovePageUp()
9054 if ( m_currentCellCoords
== wxGridNoCellCoords
)
9057 int row
= m_currentCellCoords
.GetRow();
9061 m_gridWin
->GetClientSize( &cw
, &ch
);
9063 int y
= GetRowTop(row
);
9064 int newRow
= internalYToRow( y
- ch
+ 1 );
9066 if ( newRow
== row
)
9068 // row > 0, so newRow can never be less than 0 here.
9072 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
9073 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
9081 bool wxGrid::MovePageDown()
9083 if ( m_currentCellCoords
== wxGridNoCellCoords
)
9086 int row
= m_currentCellCoords
.GetRow();
9087 if ( (row
+ 1) < m_numRows
)
9090 m_gridWin
->GetClientSize( &cw
, &ch
);
9092 int y
= GetRowTop(row
);
9093 int newRow
= internalYToRow( y
+ ch
);
9094 if ( newRow
== row
)
9096 // row < m_numRows, so newRow can't overflow here.
9100 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
9101 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
9109 bool wxGrid::MoveCursorUpBlock( bool expandSelection
)
9112 m_currentCellCoords
!= wxGridNoCellCoords
&&
9113 m_currentCellCoords
.GetRow() > 0 )
9115 int row
= m_currentCellCoords
.GetRow();
9116 int col
= m_currentCellCoords
.GetCol();
9118 if ( m_table
->IsEmptyCell(row
, col
) )
9120 // starting in an empty cell: find the next block of
9126 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9130 else if ( m_table
->IsEmptyCell(row
- 1, col
) )
9132 // starting at the top of a block: find the next block
9138 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9144 // starting within a block: find the top of the block
9149 if ( m_table
->IsEmptyCell(row
, col
) )
9157 MakeCellVisible( row
, col
);
9158 if ( expandSelection
)
9160 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9161 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9166 SetCurrentCell( row
, col
);
9175 bool wxGrid::MoveCursorDownBlock( bool expandSelection
)
9178 m_currentCellCoords
!= wxGridNoCellCoords
&&
9179 m_currentCellCoords
.GetRow() < m_numRows
- 1 )
9181 int row
= m_currentCellCoords
.GetRow();
9182 int col
= m_currentCellCoords
.GetCol();
9184 if ( m_table
->IsEmptyCell(row
, col
) )
9186 // starting in an empty cell: find the next block of
9189 while ( row
< m_numRows
- 1 )
9192 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9196 else if ( m_table
->IsEmptyCell(row
+ 1, col
) )
9198 // starting at the bottom of a block: find the next block
9201 while ( row
< m_numRows
- 1 )
9204 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9210 // starting within a block: find the bottom of the block
9212 while ( row
< m_numRows
- 1 )
9215 if ( m_table
->IsEmptyCell(row
, col
) )
9223 MakeCellVisible( row
, col
);
9224 if ( expandSelection
)
9226 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9227 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9232 SetCurrentCell( row
, col
);
9241 bool wxGrid::MoveCursorLeftBlock( bool expandSelection
)
9244 m_currentCellCoords
!= wxGridNoCellCoords
&&
9245 m_currentCellCoords
.GetCol() > 0 )
9247 int row
= m_currentCellCoords
.GetRow();
9248 int col
= m_currentCellCoords
.GetCol();
9250 if ( m_table
->IsEmptyCell(row
, col
) )
9252 // starting in an empty cell: find the next block of
9258 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9262 else if ( m_table
->IsEmptyCell(row
, col
- 1) )
9264 // starting at the left of a block: find the next block
9270 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9276 // starting within a block: find the left of the block
9281 if ( m_table
->IsEmptyCell(row
, col
) )
9289 MakeCellVisible( row
, col
);
9290 if ( expandSelection
)
9292 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9293 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9298 SetCurrentCell( row
, col
);
9307 bool wxGrid::MoveCursorRightBlock( bool expandSelection
)
9310 m_currentCellCoords
!= wxGridNoCellCoords
&&
9311 m_currentCellCoords
.GetCol() < m_numCols
- 1 )
9313 int row
= m_currentCellCoords
.GetRow();
9314 int col
= m_currentCellCoords
.GetCol();
9316 if ( m_table
->IsEmptyCell(row
, col
) )
9318 // starting in an empty cell: find the next block of
9321 while ( col
< m_numCols
- 1 )
9324 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9328 else if ( m_table
->IsEmptyCell(row
, col
+ 1) )
9330 // starting at the right of a block: find the next block
9333 while ( col
< m_numCols
- 1 )
9336 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9342 // starting within a block: find the right of the block
9344 while ( col
< m_numCols
- 1 )
9347 if ( m_table
->IsEmptyCell(row
, col
) )
9355 MakeCellVisible( row
, col
);
9356 if ( expandSelection
)
9358 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9359 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9364 SetCurrentCell( row
, col
);
9374 // ------ Label values and formatting
9377 void wxGrid::GetRowLabelAlignment( int *horiz
, int *vert
) const
9380 *horiz
= m_rowLabelHorizAlign
;
9382 *vert
= m_rowLabelVertAlign
;
9385 void wxGrid::GetColLabelAlignment( int *horiz
, int *vert
) const
9388 *horiz
= m_colLabelHorizAlign
;
9390 *vert
= m_colLabelVertAlign
;
9393 int wxGrid::GetColLabelTextOrientation() const
9395 return m_colLabelTextOrientation
;
9398 wxString
wxGrid::GetRowLabelValue( int row
) const
9402 return m_table
->GetRowLabelValue( row
);
9412 wxString
wxGrid::GetColLabelValue( int col
) const
9416 return m_table
->GetColLabelValue( col
);
9426 void wxGrid::SetRowLabelSize( int width
)
9428 wxASSERT( width
>= 0 || width
== wxGRID_AUTOSIZE
);
9430 if ( width
== wxGRID_AUTOSIZE
)
9432 width
= CalcColOrRowLabelAreaMinSize(wxGRID_ROW
);
9435 if ( width
!= m_rowLabelWidth
)
9439 m_rowLabelWin
->Show( false );
9440 m_cornerLabelWin
->Show( false );
9442 else if ( m_rowLabelWidth
== 0 )
9444 m_rowLabelWin
->Show( true );
9445 if ( m_colLabelHeight
> 0 )
9446 m_cornerLabelWin
->Show( true );
9449 m_rowLabelWidth
= width
;
9451 wxScrolledWindow::Refresh( true );
9455 void wxGrid::SetColLabelSize( int height
)
9457 wxASSERT( height
>=0 || height
== wxGRID_AUTOSIZE
);
9459 if ( height
== wxGRID_AUTOSIZE
)
9461 height
= CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN
);
9464 if ( height
!= m_colLabelHeight
)
9468 m_colLabelWin
->Show( false );
9469 m_cornerLabelWin
->Show( false );
9471 else if ( m_colLabelHeight
== 0 )
9473 m_colLabelWin
->Show( true );
9474 if ( m_rowLabelWidth
> 0 )
9475 m_cornerLabelWin
->Show( true );
9478 m_colLabelHeight
= height
;
9480 wxScrolledWindow::Refresh( true );
9484 void wxGrid::SetLabelBackgroundColour( const wxColour
& colour
)
9486 if ( m_labelBackgroundColour
!= colour
)
9488 m_labelBackgroundColour
= colour
;
9489 m_rowLabelWin
->SetBackgroundColour( colour
);
9490 m_colLabelWin
->SetBackgroundColour( colour
);
9491 m_cornerLabelWin
->SetBackgroundColour( colour
);
9493 if ( !GetBatchCount() )
9495 m_rowLabelWin
->Refresh();
9496 m_colLabelWin
->Refresh();
9497 m_cornerLabelWin
->Refresh();
9502 void wxGrid::SetLabelTextColour( const wxColour
& colour
)
9504 if ( m_labelTextColour
!= colour
)
9506 m_labelTextColour
= colour
;
9507 if ( !GetBatchCount() )
9509 m_rowLabelWin
->Refresh();
9510 m_colLabelWin
->Refresh();
9515 void wxGrid::SetLabelFont( const wxFont
& font
)
9518 if ( !GetBatchCount() )
9520 m_rowLabelWin
->Refresh();
9521 m_colLabelWin
->Refresh();
9525 void wxGrid::SetRowLabelAlignment( int horiz
, int vert
)
9527 // allow old (incorrect) defs to be used
9530 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
9531 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
9532 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
9537 case wxTOP
: vert
= wxALIGN_TOP
; break;
9538 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
9539 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
9542 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
9544 m_rowLabelHorizAlign
= horiz
;
9547 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
9549 m_rowLabelVertAlign
= vert
;
9552 if ( !GetBatchCount() )
9554 m_rowLabelWin
->Refresh();
9558 void wxGrid::SetColLabelAlignment( int horiz
, int vert
)
9560 // allow old (incorrect) defs to be used
9563 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
9564 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
9565 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
9570 case wxTOP
: vert
= wxALIGN_TOP
; break;
9571 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
9572 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
9575 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
9577 m_colLabelHorizAlign
= horiz
;
9580 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
9582 m_colLabelVertAlign
= vert
;
9585 if ( !GetBatchCount() )
9587 m_colLabelWin
->Refresh();
9591 // Note: under MSW, the default column label font must be changed because it
9592 // does not support vertical printing
9594 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
9595 // pGrid->SetLabelFont(font);
9596 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
9598 void wxGrid::SetColLabelTextOrientation( int textOrientation
)
9600 if ( textOrientation
== wxHORIZONTAL
|| textOrientation
== wxVERTICAL
)
9601 m_colLabelTextOrientation
= textOrientation
;
9603 if ( !GetBatchCount() )
9604 m_colLabelWin
->Refresh();
9607 void wxGrid::SetRowLabelValue( int row
, const wxString
& s
)
9611 m_table
->SetRowLabelValue( row
, s
);
9612 if ( !GetBatchCount() )
9614 wxRect rect
= CellToRect( row
, 0 );
9615 if ( rect
.height
> 0 )
9617 CalcScrolledPosition(0, rect
.y
, &rect
.x
, &rect
.y
);
9619 rect
.width
= m_rowLabelWidth
;
9620 m_rowLabelWin
->Refresh( true, &rect
);
9626 void wxGrid::SetColLabelValue( int col
, const wxString
& s
)
9630 m_table
->SetColLabelValue( col
, s
);
9631 if ( !GetBatchCount() )
9633 wxRect rect
= CellToRect( 0, col
);
9634 if ( rect
.width
> 0 )
9636 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &rect
.y
);
9638 rect
.height
= m_colLabelHeight
;
9639 m_colLabelWin
->Refresh( true, &rect
);
9645 void wxGrid::SetGridLineColour( const wxColour
& colour
)
9647 if ( m_gridLineColour
!= colour
)
9649 m_gridLineColour
= colour
;
9651 wxClientDC
dc( m_gridWin
);
9653 DrawAllGridLines( dc
, wxRegion() );
9657 void wxGrid::SetCellHighlightColour( const wxColour
& colour
)
9659 if ( m_cellHighlightColour
!= colour
)
9661 m_cellHighlightColour
= colour
;
9663 wxClientDC
dc( m_gridWin
);
9665 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
9666 DrawCellHighlight(dc
, attr
);
9671 void wxGrid::SetCellHighlightPenWidth(int width
)
9673 if (m_cellHighlightPenWidth
!= width
)
9675 m_cellHighlightPenWidth
= width
;
9677 // Just redrawing the cell highlight is not enough since that won't
9678 // make any visible change if the the thickness is getting smaller.
9679 int row
= m_currentCellCoords
.GetRow();
9680 int col
= m_currentCellCoords
.GetCol();
9681 if ( row
== -1 || col
== -1 || GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
9684 wxRect rect
= CellToRect(row
, col
);
9685 m_gridWin
->Refresh(true, &rect
);
9689 void wxGrid::SetCellHighlightROPenWidth(int width
)
9691 if (m_cellHighlightROPenWidth
!= width
)
9693 m_cellHighlightROPenWidth
= width
;
9695 // Just redrawing the cell highlight is not enough since that won't
9696 // make any visible change if the the thickness is getting smaller.
9697 int row
= m_currentCellCoords
.GetRow();
9698 int col
= m_currentCellCoords
.GetCol();
9699 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
9702 wxRect rect
= CellToRect(row
, col
);
9703 m_gridWin
->Refresh(true, &rect
);
9707 void wxGrid::EnableGridLines( bool enable
)
9709 if ( enable
!= m_gridLinesEnabled
)
9711 m_gridLinesEnabled
= enable
;
9713 if ( !GetBatchCount() )
9717 wxClientDC
dc( m_gridWin
);
9719 DrawAllGridLines( dc
, wxRegion() );
9723 m_gridWin
->Refresh();
9729 int wxGrid::GetDefaultRowSize() const
9731 return m_defaultRowHeight
;
9734 int wxGrid::GetRowSize( int row
) const
9736 wxCHECK_MSG( row
>= 0 && row
< m_numRows
, 0, _T("invalid row index") );
9738 return GetRowHeight(row
);
9741 int wxGrid::GetDefaultColSize() const
9743 return m_defaultColWidth
;
9746 int wxGrid::GetColSize( int col
) const
9748 wxCHECK_MSG( col
>= 0 && col
< m_numCols
, 0, _T("invalid column index") );
9750 return GetColWidth(col
);
9753 // ============================================================================
9754 // access to the grid attributes: each of them has a default value in the grid
9755 // itself and may be overidden on a per-cell basis
9756 // ============================================================================
9758 // ----------------------------------------------------------------------------
9759 // setting default attributes
9760 // ----------------------------------------------------------------------------
9762 void wxGrid::SetDefaultCellBackgroundColour( const wxColour
& col
)
9764 m_defaultCellAttr
->SetBackgroundColour(col
);
9766 m_gridWin
->SetBackgroundColour(col
);
9770 void wxGrid::SetDefaultCellTextColour( const wxColour
& col
)
9772 m_defaultCellAttr
->SetTextColour(col
);
9775 void wxGrid::SetDefaultCellAlignment( int horiz
, int vert
)
9777 m_defaultCellAttr
->SetAlignment(horiz
, vert
);
9780 void wxGrid::SetDefaultCellOverflow( bool allow
)
9782 m_defaultCellAttr
->SetOverflow(allow
);
9785 void wxGrid::SetDefaultCellFont( const wxFont
& font
)
9787 m_defaultCellAttr
->SetFont(font
);
9790 // For editors and renderers the type registry takes precedence over the
9791 // default attr, so we need to register the new editor/renderer for the string
9792 // data type in order to make setting a default editor/renderer appear to
9795 void wxGrid::SetDefaultRenderer(wxGridCellRenderer
*renderer
)
9797 RegisterDataType(wxGRID_VALUE_STRING
,
9799 GetDefaultEditorForType(wxGRID_VALUE_STRING
));
9802 void wxGrid::SetDefaultEditor(wxGridCellEditor
*editor
)
9804 RegisterDataType(wxGRID_VALUE_STRING
,
9805 GetDefaultRendererForType(wxGRID_VALUE_STRING
),
9809 // ----------------------------------------------------------------------------
9810 // access to the default attributes
9811 // ----------------------------------------------------------------------------
9813 wxColour
wxGrid::GetDefaultCellBackgroundColour() const
9815 return m_defaultCellAttr
->GetBackgroundColour();
9818 wxColour
wxGrid::GetDefaultCellTextColour() const
9820 return m_defaultCellAttr
->GetTextColour();
9823 wxFont
wxGrid::GetDefaultCellFont() const
9825 return m_defaultCellAttr
->GetFont();
9828 void wxGrid::GetDefaultCellAlignment( int *horiz
, int *vert
) const
9830 m_defaultCellAttr
->GetAlignment(horiz
, vert
);
9833 bool wxGrid::GetDefaultCellOverflow() const
9835 return m_defaultCellAttr
->GetOverflow();
9838 wxGridCellRenderer
*wxGrid::GetDefaultRenderer() const
9840 return m_defaultCellAttr
->GetRenderer(NULL
, 0, 0);
9843 wxGridCellEditor
*wxGrid::GetDefaultEditor() const
9845 return m_defaultCellAttr
->GetEditor(NULL
, 0, 0);
9848 // ----------------------------------------------------------------------------
9849 // access to cell attributes
9850 // ----------------------------------------------------------------------------
9852 wxColour
wxGrid::GetCellBackgroundColour(int row
, int col
) const
9854 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
9855 wxColour colour
= attr
->GetBackgroundColour();
9861 wxColour
wxGrid::GetCellTextColour( int row
, int col
) const
9863 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
9864 wxColour colour
= attr
->GetTextColour();
9870 wxFont
wxGrid::GetCellFont( int row
, int col
) const
9872 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
9873 wxFont font
= attr
->GetFont();
9879 void wxGrid::GetCellAlignment( int row
, int col
, int *horiz
, int *vert
) const
9881 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
9882 attr
->GetAlignment(horiz
, vert
);
9886 bool wxGrid::GetCellOverflow( int row
, int col
) const
9888 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
9889 bool allow
= attr
->GetOverflow();
9895 void wxGrid::GetCellSize( int row
, int col
, int *num_rows
, int *num_cols
) const
9897 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
9898 attr
->GetSize( num_rows
, num_cols
);
9902 wxGridCellRenderer
* wxGrid::GetCellRenderer(int row
, int col
) const
9904 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
9905 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
9911 wxGridCellEditor
* wxGrid::GetCellEditor(int row
, int col
) const
9913 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
9914 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
9920 bool wxGrid::IsReadOnly(int row
, int col
) const
9922 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
9923 bool isReadOnly
= attr
->IsReadOnly();
9929 // ----------------------------------------------------------------------------
9930 // attribute support: cache, automatic provider creation, ...
9931 // ----------------------------------------------------------------------------
9933 bool wxGrid::CanHaveAttributes() const
9940 return m_table
->CanHaveAttributes();
9943 void wxGrid::ClearAttrCache()
9945 if ( m_attrCache
.row
!= -1 )
9947 wxSafeDecRef(m_attrCache
.attr
);
9948 m_attrCache
.attr
= NULL
;
9949 m_attrCache
.row
= -1;
9953 void wxGrid::CacheAttr(int row
, int col
, wxGridCellAttr
*attr
) const
9957 wxGrid
*self
= (wxGrid
*)this; // const_cast
9959 self
->ClearAttrCache();
9960 self
->m_attrCache
.row
= row
;
9961 self
->m_attrCache
.col
= col
;
9962 self
->m_attrCache
.attr
= attr
;
9967 bool wxGrid::LookupAttr(int row
, int col
, wxGridCellAttr
**attr
) const
9969 if ( row
== m_attrCache
.row
&& col
== m_attrCache
.col
)
9971 *attr
= m_attrCache
.attr
;
9972 wxSafeIncRef(m_attrCache
.attr
);
9974 #ifdef DEBUG_ATTR_CACHE
9975 gs_nAttrCacheHits
++;
9982 #ifdef DEBUG_ATTR_CACHE
9983 gs_nAttrCacheMisses
++;
9990 wxGridCellAttr
*wxGrid::GetCellAttr(int row
, int col
) const
9992 wxGridCellAttr
*attr
= NULL
;
9993 // Additional test to avoid looking at the cache e.g. for
9994 // wxNoCellCoords, as this will confuse memory management.
9997 if ( !LookupAttr(row
, col
, &attr
) )
9999 attr
= m_table
? m_table
->GetAttr(row
, col
, wxGridCellAttr::Any
)
10000 : (wxGridCellAttr
*)NULL
;
10001 CacheAttr(row
, col
, attr
);
10007 attr
->SetDefAttr(m_defaultCellAttr
);
10011 attr
= m_defaultCellAttr
;
10018 wxGridCellAttr
*wxGrid::GetOrCreateCellAttr(int row
, int col
) const
10020 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
10021 bool canHave
= ((wxGrid
*)this)->CanHaveAttributes();
10023 wxCHECK_MSG( canHave
, attr
, _T("Cell attributes not allowed"));
10024 wxCHECK_MSG( m_table
, attr
, _T("must have a table") );
10026 attr
= m_table
->GetAttr(row
, col
, wxGridCellAttr::Cell
);
10029 attr
= new wxGridCellAttr(m_defaultCellAttr
);
10031 // artificially inc the ref count to match DecRef() in caller
10033 m_table
->SetAttr(attr
, row
, col
);
10039 // ----------------------------------------------------------------------------
10040 // setting column attributes (wrappers around SetColAttr)
10041 // ----------------------------------------------------------------------------
10043 void wxGrid::SetColFormatBool(int col
)
10045 SetColFormatCustom(col
, wxGRID_VALUE_BOOL
);
10048 void wxGrid::SetColFormatNumber(int col
)
10050 SetColFormatCustom(col
, wxGRID_VALUE_NUMBER
);
10053 void wxGrid::SetColFormatFloat(int col
, int width
, int precision
)
10055 wxString typeName
= wxGRID_VALUE_FLOAT
;
10056 if ( (width
!= -1) || (precision
!= -1) )
10058 typeName
<< _T(':') << width
<< _T(',') << precision
;
10061 SetColFormatCustom(col
, typeName
);
10064 void wxGrid::SetColFormatCustom(int col
, const wxString
& typeName
)
10066 wxGridCellAttr
*attr
= m_table
->GetAttr(-1, col
, wxGridCellAttr::Col
);
10068 attr
= new wxGridCellAttr
;
10069 wxGridCellRenderer
*renderer
= GetDefaultRendererForType(typeName
);
10070 attr
->SetRenderer(renderer
);
10072 SetColAttr(col
, attr
);
10076 // ----------------------------------------------------------------------------
10077 // setting cell attributes: this is forwarded to the table
10078 // ----------------------------------------------------------------------------
10080 void wxGrid::SetAttr(int row
, int col
, wxGridCellAttr
*attr
)
10082 if ( CanHaveAttributes() )
10084 m_table
->SetAttr(attr
, row
, col
);
10089 wxSafeDecRef(attr
);
10093 void wxGrid::SetRowAttr(int row
, wxGridCellAttr
*attr
)
10095 if ( CanHaveAttributes() )
10097 m_table
->SetRowAttr(attr
, row
);
10102 wxSafeDecRef(attr
);
10106 void wxGrid::SetColAttr(int col
, wxGridCellAttr
*attr
)
10108 if ( CanHaveAttributes() )
10110 m_table
->SetColAttr(attr
, col
);
10115 wxSafeDecRef(attr
);
10119 void wxGrid::SetCellBackgroundColour( int row
, int col
, const wxColour
& colour
)
10121 if ( CanHaveAttributes() )
10123 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10124 attr
->SetBackgroundColour(colour
);
10129 void wxGrid::SetCellTextColour( int row
, int col
, const wxColour
& colour
)
10131 if ( CanHaveAttributes() )
10133 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10134 attr
->SetTextColour(colour
);
10139 void wxGrid::SetCellFont( int row
, int col
, const wxFont
& font
)
10141 if ( CanHaveAttributes() )
10143 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10144 attr
->SetFont(font
);
10149 void wxGrid::SetCellAlignment( int row
, int col
, int horiz
, int vert
)
10151 if ( CanHaveAttributes() )
10153 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10154 attr
->SetAlignment(horiz
, vert
);
10159 void wxGrid::SetCellOverflow( int row
, int col
, bool allow
)
10161 if ( CanHaveAttributes() )
10163 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10164 attr
->SetOverflow(allow
);
10169 void wxGrid::SetCellSize( int row
, int col
, int num_rows
, int num_cols
)
10171 if ( CanHaveAttributes() )
10173 int cell_rows
, cell_cols
;
10175 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10176 attr
->GetSize(&cell_rows
, &cell_cols
);
10177 attr
->SetSize(num_rows
, num_cols
);
10180 // Cannot set the size of a cell to 0 or negative values
10181 // While it is perfectly legal to do that, this function cannot
10182 // handle all the possibilies, do it by hand by getting the CellAttr.
10183 // You can only set the size of a cell to 1,1 or greater with this fn
10184 wxASSERT_MSG( !((cell_rows
< 1) || (cell_cols
< 1)),
10185 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
10186 wxASSERT_MSG( !((num_rows
< 1) || (num_cols
< 1)),
10187 wxT("wxGrid::SetCellSize setting cell size to < 1"));
10189 // if this was already a multicell then "turn off" the other cells first
10190 if ((cell_rows
> 1) || (cell_rows
> 1))
10193 for (j
=row
; j
< row
+ cell_rows
; j
++)
10195 for (i
=col
; i
< col
+ cell_cols
; i
++)
10197 if ((i
!= col
) || (j
!= row
))
10199 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
10200 attr_stub
->SetSize( 1, 1 );
10201 attr_stub
->DecRef();
10207 // mark the cells that will be covered by this cell to
10208 // negative or zero values to point back at this cell
10209 if (((num_rows
> 1) || (num_cols
> 1)) && (num_rows
>= 1) && (num_cols
>= 1))
10212 for (j
=row
; j
< row
+ num_rows
; j
++)
10214 for (i
=col
; i
< col
+ num_cols
; i
++)
10216 if ((i
!= col
) || (j
!= row
))
10218 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
10219 attr_stub
->SetSize( row
- j
, col
- i
);
10220 attr_stub
->DecRef();
10228 void wxGrid::SetCellRenderer(int row
, int col
, wxGridCellRenderer
*renderer
)
10230 if ( CanHaveAttributes() )
10232 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10233 attr
->SetRenderer(renderer
);
10238 void wxGrid::SetCellEditor(int row
, int col
, wxGridCellEditor
* editor
)
10240 if ( CanHaveAttributes() )
10242 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10243 attr
->SetEditor(editor
);
10248 void wxGrid::SetReadOnly(int row
, int col
, bool isReadOnly
)
10250 if ( CanHaveAttributes() )
10252 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10253 attr
->SetReadOnly(isReadOnly
);
10258 // ----------------------------------------------------------------------------
10259 // Data type registration
10260 // ----------------------------------------------------------------------------
10262 void wxGrid::RegisterDataType(const wxString
& typeName
,
10263 wxGridCellRenderer
* renderer
,
10264 wxGridCellEditor
* editor
)
10266 m_typeRegistry
->RegisterDataType(typeName
, renderer
, editor
);
10270 wxGridCellEditor
* wxGrid::GetDefaultEditorForCell(int row
, int col
) const
10272 wxString typeName
= m_table
->GetTypeName(row
, col
);
10273 return GetDefaultEditorForType(typeName
);
10276 wxGridCellRenderer
* wxGrid::GetDefaultRendererForCell(int row
, int col
) const
10278 wxString typeName
= m_table
->GetTypeName(row
, col
);
10279 return GetDefaultRendererForType(typeName
);
10282 wxGridCellEditor
* wxGrid::GetDefaultEditorForType(const wxString
& typeName
) const
10284 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
10285 if ( index
== wxNOT_FOUND
)
10287 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName
.c_str()));
10292 return m_typeRegistry
->GetEditor(index
);
10295 wxGridCellRenderer
* wxGrid::GetDefaultRendererForType(const wxString
& typeName
) const
10297 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
10298 if ( index
== wxNOT_FOUND
)
10300 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName
.c_str()));
10305 return m_typeRegistry
->GetRenderer(index
);
10308 // ----------------------------------------------------------------------------
10310 // ----------------------------------------------------------------------------
10312 void wxGrid::EnableDragRowSize( bool enable
)
10314 m_canDragRowSize
= enable
;
10317 void wxGrid::EnableDragColSize( bool enable
)
10319 m_canDragColSize
= enable
;
10322 void wxGrid::EnableDragGridSize( bool enable
)
10324 m_canDragGridSize
= enable
;
10327 void wxGrid::EnableDragCell( bool enable
)
10329 m_canDragCell
= enable
;
10332 void wxGrid::SetDefaultRowSize( int height
, bool resizeExistingRows
)
10334 m_defaultRowHeight
= wxMax( height
, m_minAcceptableRowHeight
);
10336 if ( resizeExistingRows
)
10338 // since we are resizing all rows to the default row size,
10339 // we can simply clear the row heights and row bottoms
10340 // arrays (which also allows us to take advantage of
10341 // some speed optimisations)
10342 m_rowHeights
.Empty();
10343 m_rowBottoms
.Empty();
10344 if ( !GetBatchCount() )
10349 void wxGrid::SetRowSize( int row
, int height
)
10351 wxCHECK_RET( row
>= 0 && row
< m_numRows
, _T("invalid row index") );
10353 // See comment in SetColSize
10354 if ( height
< GetRowMinimalAcceptableHeight())
10357 if ( m_rowHeights
.IsEmpty() )
10359 // need to really create the array
10363 int h
= wxMax( 0, height
);
10364 int diff
= h
- m_rowHeights
[row
];
10366 m_rowHeights
[row
] = h
;
10367 for ( int i
= row
; i
< m_numRows
; i
++ )
10369 m_rowBottoms
[i
] += diff
;
10372 if ( !GetBatchCount() )
10376 void wxGrid::SetDefaultColSize( int width
, bool resizeExistingCols
)
10378 // we dont allow zero default column width
10379 m_defaultColWidth
= wxMax( wxMax( width
, m_minAcceptableColWidth
), 1 );
10381 if ( resizeExistingCols
)
10383 // since we are resizing all columns to the default column size,
10384 // we can simply clear the col widths and col rights
10385 // arrays (which also allows us to take advantage of
10386 // some speed optimisations)
10387 m_colWidths
.Empty();
10388 m_colRights
.Empty();
10389 if ( !GetBatchCount() )
10394 void wxGrid::SetColSize( int col
, int width
)
10396 wxCHECK_RET( col
>= 0 && col
< m_numCols
, _T("invalid column index") );
10398 // should we check that it's bigger than GetColMinimalWidth(col) here?
10400 // No, because it is reasonable to assume the library user know's
10401 // what he is doing. However we should test against the weaker
10402 // constraint of minimalAcceptableWidth, as this breaks rendering
10404 // This test then fixes sf.net bug #645734
10406 if ( width
< GetColMinimalAcceptableWidth() )
10409 if ( m_colWidths
.IsEmpty() )
10411 // need to really create the array
10415 // if < 0 then calculate new width from label
10419 wxArrayString lines
;
10420 wxClientDC
dc(m_colLabelWin
);
10421 dc
.SetFont(GetLabelFont());
10422 StringToLines(GetColLabelValue(col
), lines
);
10423 GetTextBoxSize(dc
, lines
, &w
, &h
);
10427 int w
= wxMax( 0, width
);
10428 int diff
= w
- m_colWidths
[col
];
10429 m_colWidths
[col
] = w
;
10431 for ( int colPos
= GetColPos(col
); colPos
< m_numCols
; colPos
++ )
10433 m_colRights
[GetColAt(colPos
)] += diff
;
10436 if ( !GetBatchCount() )
10440 void wxGrid::SetColMinimalWidth( int col
, int width
)
10442 if (width
> GetColMinimalAcceptableWidth())
10444 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)col
;
10445 m_colMinWidths
[key
] = width
;
10449 void wxGrid::SetRowMinimalHeight( int row
, int width
)
10451 if (width
> GetRowMinimalAcceptableHeight())
10453 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)row
;
10454 m_rowMinHeights
[key
] = width
;
10458 int wxGrid::GetColMinimalWidth(int col
) const
10460 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)col
;
10461 wxLongToLongHashMap::const_iterator it
= m_colMinWidths
.find(key
);
10463 return it
!= m_colMinWidths
.end() ? (int)it
->second
: m_minAcceptableColWidth
;
10466 int wxGrid::GetRowMinimalHeight(int row
) const
10468 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)row
;
10469 wxLongToLongHashMap::const_iterator it
= m_rowMinHeights
.find(key
);
10471 return it
!= m_rowMinHeights
.end() ? (int)it
->second
: m_minAcceptableRowHeight
;
10474 void wxGrid::SetColMinimalAcceptableWidth( int width
)
10476 // We do allow a width of 0 since this gives us
10477 // an easy way to temporarily hiding columns.
10479 m_minAcceptableColWidth
= width
;
10482 void wxGrid::SetRowMinimalAcceptableHeight( int height
)
10484 // We do allow a height of 0 since this gives us
10485 // an easy way to temporarily hiding rows.
10487 m_minAcceptableRowHeight
= height
;
10490 int wxGrid::GetColMinimalAcceptableWidth() const
10492 return m_minAcceptableColWidth
;
10495 int wxGrid::GetRowMinimalAcceptableHeight() const
10497 return m_minAcceptableRowHeight
;
10500 // ----------------------------------------------------------------------------
10502 // ----------------------------------------------------------------------------
10505 wxGrid::AutoSizeColOrRow(int colOrRow
, bool setAsMin
, wxGridDirection direction
)
10507 const bool column
= direction
== wxGRID_COLUMN
;
10509 wxClientDC
dc(m_gridWin
);
10511 // cancel editing of cell
10512 HideCellEditControl();
10513 SaveEditControlValue();
10515 // init both of them to avoid compiler warnings, even if we only need one
10523 wxCoord extent
, extentMax
= 0;
10524 int max
= column
? m_numRows
: m_numCols
;
10525 for ( int rowOrCol
= 0; rowOrCol
< max
; rowOrCol
++ )
10532 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
10533 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
10536 wxSize size
= renderer
->GetBestSize(*this, *attr
, dc
, row
, col
);
10537 extent
= column
? size
.x
: size
.y
;
10538 if ( extent
> extentMax
)
10539 extentMax
= extent
;
10541 renderer
->DecRef();
10547 // now also compare with the column label extent
10549 dc
.SetFont( GetLabelFont() );
10553 dc
.GetMultiLineTextExtent( GetColLabelValue(col
), &w
, &h
);
10554 if ( GetColLabelTextOrientation() == wxVERTICAL
)
10558 dc
.GetMultiLineTextExtent( GetRowLabelValue(row
), &w
, &h
);
10560 extent
= column
? w
: h
;
10561 if ( extent
> extentMax
)
10562 extentMax
= extent
;
10566 // empty column - give default extent (notice that if extentMax is less
10567 // than default extent but != 0, it's OK)
10568 extentMax
= column
? m_defaultColWidth
: m_defaultRowHeight
;
10573 // leave some space around text
10581 SetColSize( col
, extentMax
);
10582 if ( !GetBatchCount() )
10585 m_gridWin
->GetClientSize( &cw
, &ch
);
10586 wxRect
rect ( CellToRect( 0, col
) );
10588 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
10589 rect
.width
= cw
- rect
.x
;
10590 rect
.height
= m_colLabelHeight
;
10591 m_colLabelWin
->Refresh( true, &rect
);
10596 SetRowSize(row
, extentMax
);
10597 if ( !GetBatchCount() )
10600 m_gridWin
->GetClientSize( &cw
, &ch
);
10601 wxRect
rect( CellToRect( row
, 0 ) );
10603 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
10604 rect
.width
= m_rowLabelWidth
;
10605 rect
.height
= ch
- rect
.y
;
10606 m_rowLabelWin
->Refresh( true, &rect
);
10613 SetColMinimalWidth(col
, extentMax
);
10615 SetRowMinimalHeight(row
, extentMax
);
10619 wxCoord
wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction
)
10621 // calculate size for the rows or columns?
10622 const bool calcRows
= direction
== wxGRID_ROW
;
10624 wxClientDC
dc(calcRows
? GetGridRowLabelWindow()
10625 : GetGridColLabelWindow());
10626 dc
.SetFont(GetLabelFont());
10628 // which dimension should we take into account for calculations?
10630 // for columns, the text can be only horizontal so it's easy but for rows
10631 // we also have to take into account the text orientation
10633 useWidth
= calcRows
|| (GetColLabelTextOrientation() == wxVERTICAL
);
10635 wxArrayString lines
;
10636 wxCoord extentMax
= 0;
10638 const int numRowsOrCols
= calcRows
? m_numRows
: m_numCols
;
10639 for ( int rowOrCol
= 0; rowOrCol
< numRowsOrCols
; rowOrCol
++ )
10643 wxString label
= calcRows
? GetRowLabelValue(rowOrCol
)
10644 : GetColLabelValue(rowOrCol
);
10645 StringToLines(label
, lines
);
10648 GetTextBoxSize(dc
, lines
, &w
, &h
);
10650 const wxCoord extent
= useWidth
? w
: h
;
10651 if ( extent
> extentMax
)
10652 extentMax
= extent
;
10657 // empty column - give default extent (notice that if extentMax is less
10658 // than default extent but != 0, it's OK)
10659 extentMax
= calcRows
? GetDefaultRowLabelSize()
10660 : GetDefaultColLabelSize();
10663 // leave some space around text (taken from AutoSizeColOrRow)
10672 int wxGrid::SetOrCalcColumnSizes(bool calcOnly
, bool setAsMin
)
10674 int width
= m_rowLabelWidth
;
10676 wxGridUpdateLocker locker
;
10678 locker
.Create(this);
10680 for ( int col
= 0; col
< m_numCols
; col
++ )
10683 AutoSizeColumn(col
, setAsMin
);
10685 width
+= GetColWidth(col
);
10691 int wxGrid::SetOrCalcRowSizes(bool calcOnly
, bool setAsMin
)
10693 int height
= m_colLabelHeight
;
10695 wxGridUpdateLocker locker
;
10697 locker
.Create(this);
10699 for ( int row
= 0; row
< m_numRows
; row
++ )
10702 AutoSizeRow(row
, setAsMin
);
10704 height
+= GetRowHeight(row
);
10710 void wxGrid::AutoSize()
10712 wxGridUpdateLocker
locker(this);
10714 // we need to round up the size of the scrollable area to a multiple of
10715 // scroll step to ensure that we don't get the scrollbars when we're sized
10716 // exactly to fit our contents
10717 wxSize
size(SetOrCalcColumnSizes(false) - m_rowLabelWidth
+ m_extraWidth
,
10718 SetOrCalcRowSizes(false) - m_colLabelHeight
+ m_extraHeight
);
10719 wxSize
sizeFit(GetScrollX(size
.x
) * GetScrollLineX(),
10720 GetScrollY(size
.y
) * GetScrollLineY());
10722 // distribute the extra space between the columns/rows to avoid having
10723 // extra white space
10724 wxCoord diff
= sizeFit
.x
- size
.x
;
10725 if ( diff
&& m_numCols
)
10727 // try to resize the columns uniformly
10728 wxCoord diffPerCol
= diff
/ m_numCols
;
10731 for ( int col
= 0; col
< m_numCols
; col
++ )
10733 SetColSize(col
, GetColWidth(col
) + diffPerCol
);
10737 // add remaining amount to the last columns
10738 diff
-= diffPerCol
* m_numCols
;
10741 for ( int col
= m_numCols
- 1; col
>= m_numCols
- diff
; col
-- )
10743 SetColSize(col
, GetColWidth(col
) + 1);
10749 diff
= sizeFit
.y
- size
.y
;
10750 if ( diff
&& m_numRows
)
10752 // try to resize the columns uniformly
10753 wxCoord diffPerRow
= diff
/ m_numRows
;
10756 for ( int row
= 0; row
< m_numRows
; row
++ )
10758 SetRowSize(row
, GetRowHeight(row
) + diffPerRow
);
10762 // add remaining amount to the last rows
10763 diff
-= diffPerRow
* m_numRows
;
10766 for ( int row
= m_numRows
- 1; row
>= m_numRows
- diff
; row
-- )
10768 SetRowSize(row
, GetRowHeight(row
) + 1);
10773 // we know that we're not going to have scrollbars so disable them now to
10774 // avoid trouble in SetClientSize() which can otherwise set the correct
10775 // client size but also leave space for (not needed any more) scrollbars
10776 SetScrollbars(0, 0, 0, 0, 0, 0, true);
10777 SetClientSize(sizeFit
.x
+ m_rowLabelWidth
, sizeFit
.y
+ m_colLabelHeight
);
10780 void wxGrid::AutoSizeRowLabelSize( int row
)
10782 wxArrayString lines
;
10785 // Hide the edit control, so it
10786 // won't interfere with drag-shrinking.
10787 if ( IsCellEditControlShown() )
10789 HideCellEditControl();
10790 SaveEditControlValue();
10793 // autosize row height depending on label text
10794 StringToLines( GetRowLabelValue( row
), lines
);
10795 wxClientDC
dc( m_rowLabelWin
);
10796 GetTextBoxSize( dc
, lines
, &w
, &h
);
10797 if ( h
< m_defaultRowHeight
)
10798 h
= m_defaultRowHeight
;
10799 SetRowSize(row
, h
);
10803 void wxGrid::AutoSizeColLabelSize( int col
)
10805 wxArrayString lines
;
10808 // Hide the edit control, so it
10809 // won't interfere with drag-shrinking.
10810 if ( IsCellEditControlShown() )
10812 HideCellEditControl();
10813 SaveEditControlValue();
10816 // autosize column width depending on label text
10817 StringToLines( GetColLabelValue( col
), lines
);
10818 wxClientDC
dc( m_colLabelWin
);
10819 if ( GetColLabelTextOrientation() == wxHORIZONTAL
)
10820 GetTextBoxSize( dc
, lines
, &w
, &h
);
10822 GetTextBoxSize( dc
, lines
, &h
, &w
);
10823 if ( w
< m_defaultColWidth
)
10824 w
= m_defaultColWidth
;
10825 SetColSize(col
, w
);
10829 wxSize
wxGrid::DoGetBestSize() const
10831 wxGrid
*self
= (wxGrid
*)this; // const_cast
10833 // we do the same as in AutoSize() here with the exception that we don't
10834 // change the column/row sizes, only calculate them
10835 wxSize
size(self
->SetOrCalcColumnSizes(true) - m_rowLabelWidth
+ m_extraWidth
,
10836 self
->SetOrCalcRowSizes(true) - m_colLabelHeight
+ m_extraHeight
);
10837 wxSize
sizeFit(GetScrollX(size
.x
) * GetScrollLineX(),
10838 GetScrollY(size
.y
) * GetScrollLineY());
10840 // NOTE: This size should be cached, but first we need to add calls to
10841 // InvalidateBestSize everywhere that could change the results of this
10843 // CacheBestSize(size);
10845 return wxSize(sizeFit
.x
+ m_rowLabelWidth
, sizeFit
.y
+ m_colLabelHeight
)
10846 + GetWindowBorderSize();
10854 wxPen
& wxGrid::GetDividerPen() const
10859 // ----------------------------------------------------------------------------
10860 // cell value accessor functions
10861 // ----------------------------------------------------------------------------
10863 void wxGrid::SetCellValue( int row
, int col
, const wxString
& s
)
10867 m_table
->SetValue( row
, col
, s
);
10868 if ( !GetBatchCount() )
10871 wxRect
rect( CellToRect( row
, col
) );
10873 rect
.width
= m_gridWin
->GetClientSize().GetWidth();
10874 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
10875 m_gridWin
->Refresh( false, &rect
);
10878 if ( m_currentCellCoords
.GetRow() == row
&&
10879 m_currentCellCoords
.GetCol() == col
&&
10880 IsCellEditControlShown())
10881 // Note: If we are using IsCellEditControlEnabled,
10882 // this interacts badly with calling SetCellValue from
10883 // an EVT_GRID_CELL_CHANGE handler.
10885 HideCellEditControl();
10886 ShowCellEditControl(); // will reread data from table
10891 // ----------------------------------------------------------------------------
10892 // block, row and column selection
10893 // ----------------------------------------------------------------------------
10895 void wxGrid::SelectRow( int row
, bool addToSelected
)
10897 if ( IsSelection() && !addToSelected
)
10901 m_selection
->SelectRow( row
, false, addToSelected
);
10904 void wxGrid::SelectCol( int col
, bool addToSelected
)
10906 if ( IsSelection() && !addToSelected
)
10910 m_selection
->SelectCol( col
, false, addToSelected
);
10913 void wxGrid::SelectBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
,
10914 bool addToSelected
)
10916 if ( IsSelection() && !addToSelected
)
10920 m_selection
->SelectBlock( topRow
, leftCol
, bottomRow
, rightCol
,
10921 false, addToSelected
);
10924 void wxGrid::SelectAll()
10926 if ( m_numRows
> 0 && m_numCols
> 0 )
10929 m_selection
->SelectBlock( 0, 0, m_numRows
- 1, m_numCols
- 1 );
10933 // ----------------------------------------------------------------------------
10934 // cell, row and col deselection
10935 // ----------------------------------------------------------------------------
10937 void wxGrid::DeselectRow( int row
)
10939 if ( !m_selection
)
10942 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
10944 if ( m_selection
->IsInSelection(row
, 0 ) )
10945 m_selection
->ToggleCellSelection(row
, 0);
10949 int nCols
= GetNumberCols();
10950 for ( int i
= 0; i
< nCols
; i
++ )
10952 if ( m_selection
->IsInSelection(row
, i
) )
10953 m_selection
->ToggleCellSelection(row
, i
);
10958 void wxGrid::DeselectCol( int col
)
10960 if ( !m_selection
)
10963 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
10965 if ( m_selection
->IsInSelection(0, col
) )
10966 m_selection
->ToggleCellSelection(0, col
);
10970 int nRows
= GetNumberRows();
10971 for ( int i
= 0; i
< nRows
; i
++ )
10973 if ( m_selection
->IsInSelection(i
, col
) )
10974 m_selection
->ToggleCellSelection(i
, col
);
10979 void wxGrid::DeselectCell( int row
, int col
)
10981 if ( m_selection
&& m_selection
->IsInSelection(row
, col
) )
10982 m_selection
->ToggleCellSelection(row
, col
);
10985 bool wxGrid::IsSelection() const
10987 return ( m_selection
&& (m_selection
->IsSelection() ||
10988 ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
10989 m_selectingBottomRight
!= wxGridNoCellCoords
) ) );
10992 bool wxGrid::IsInSelection( int row
, int col
) const
10994 return ( m_selection
&& (m_selection
->IsInSelection( row
, col
) ||
10995 ( row
>= m_selectingTopLeft
.GetRow() &&
10996 col
>= m_selectingTopLeft
.GetCol() &&
10997 row
<= m_selectingBottomRight
.GetRow() &&
10998 col
<= m_selectingBottomRight
.GetCol() )) );
11001 wxGridCellCoordsArray
wxGrid::GetSelectedCells() const
11005 wxGridCellCoordsArray a
;
11009 return m_selection
->m_cellSelection
;
11012 wxGridCellCoordsArray
wxGrid::GetSelectionBlockTopLeft() const
11016 wxGridCellCoordsArray a
;
11020 return m_selection
->m_blockSelectionTopLeft
;
11023 wxGridCellCoordsArray
wxGrid::GetSelectionBlockBottomRight() const
11027 wxGridCellCoordsArray a
;
11031 return m_selection
->m_blockSelectionBottomRight
;
11034 wxArrayInt
wxGrid::GetSelectedRows() const
11042 return m_selection
->m_rowSelection
;
11045 wxArrayInt
wxGrid::GetSelectedCols() const
11053 return m_selection
->m_colSelection
;
11056 void wxGrid::ClearSelection()
11058 m_selectingTopLeft
=
11059 m_selectingBottomRight
=
11060 m_selectingKeyboard
= wxGridNoCellCoords
;
11062 m_selection
->ClearSelection();
11065 // This function returns the rectangle that encloses the given block
11066 // in device coords clipped to the client size of the grid window.
11068 wxRect
wxGrid::BlockToDeviceRect( const wxGridCellCoords
&topLeft
,
11069 const wxGridCellCoords
&bottomRight
) const
11071 wxRect
rect( wxGridNoCellRect
);
11074 cellRect
= CellToRect( topLeft
);
11075 if ( cellRect
!= wxGridNoCellRect
)
11081 rect
= wxRect(0, 0, 0, 0);
11084 cellRect
= CellToRect( bottomRight
);
11085 if ( cellRect
!= wxGridNoCellRect
)
11091 return wxGridNoCellRect
;
11095 int left
= rect
.GetLeft();
11096 int top
= rect
.GetTop();
11097 int right
= rect
.GetRight();
11098 int bottom
= rect
.GetBottom();
11100 int leftCol
= topLeft
.GetCol();
11101 int topRow
= topLeft
.GetRow();
11102 int rightCol
= bottomRight
.GetCol();
11103 int bottomRow
= bottomRight
.GetRow();
11111 leftCol
= rightCol
;
11121 topRow
= bottomRow
;
11125 for ( j
= topRow
; j
<= bottomRow
; j
++ )
11127 for ( i
= leftCol
; i
<= rightCol
; i
++ )
11129 if ((j
== topRow
) || (j
== bottomRow
) || (i
== leftCol
) || (i
== rightCol
))
11131 cellRect
= CellToRect( j
, i
);
11133 if (cellRect
.x
< left
)
11135 if (cellRect
.y
< top
)
11137 if (cellRect
.x
+ cellRect
.width
> right
)
11138 right
= cellRect
.x
+ cellRect
.width
;
11139 if (cellRect
.y
+ cellRect
.height
> bottom
)
11140 bottom
= cellRect
.y
+ cellRect
.height
;
11144 i
= rightCol
; // jump over inner cells.
11149 // convert to scrolled coords
11151 CalcScrolledPosition( left
, top
, &left
, &top
);
11152 CalcScrolledPosition( right
, bottom
, &right
, &bottom
);
11155 m_gridWin
->GetClientSize( &cw
, &ch
);
11157 if (right
< 0 || bottom
< 0 || left
> cw
|| top
> ch
)
11158 return wxRect(0,0,0,0);
11160 rect
.SetLeft( wxMax(0, left
) );
11161 rect
.SetTop( wxMax(0, top
) );
11162 rect
.SetRight( wxMin(cw
, right
) );
11163 rect
.SetBottom( wxMin(ch
, bottom
) );
11168 // ----------------------------------------------------------------------------
11169 // grid event classes
11170 // ----------------------------------------------------------------------------
11172 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent
, wxNotifyEvent
)
11174 wxGridEvent::wxGridEvent( int id
, wxEventType type
, wxObject
* obj
,
11175 int row
, int col
, int x
, int y
, bool sel
,
11176 bool control
, bool shift
, bool alt
, bool meta
)
11177 : wxNotifyEvent( type
, id
)
11184 m_control
= control
;
11189 SetEventObject(obj
);
11193 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent
, wxNotifyEvent
)
11195 wxGridSizeEvent::wxGridSizeEvent( int id
, wxEventType type
, wxObject
* obj
,
11196 int rowOrCol
, int x
, int y
,
11197 bool control
, bool shift
, bool alt
, bool meta
)
11198 : wxNotifyEvent( type
, id
)
11200 m_rowOrCol
= rowOrCol
;
11203 m_control
= control
;
11208 SetEventObject(obj
);
11212 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent
, wxNotifyEvent
)
11214 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id
, wxEventType type
, wxObject
* obj
,
11215 const wxGridCellCoords
& topLeft
,
11216 const wxGridCellCoords
& bottomRight
,
11217 bool sel
, bool control
,
11218 bool shift
, bool alt
, bool meta
)
11219 : wxNotifyEvent( type
, id
)
11221 m_topLeft
= topLeft
;
11222 m_bottomRight
= bottomRight
;
11224 m_control
= control
;
11229 SetEventObject(obj
);
11233 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent
, wxCommandEvent
)
11235 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id
, wxEventType type
,
11236 wxObject
* obj
, int row
,
11237 int col
, wxControl
* ctrl
)
11238 : wxCommandEvent(type
, id
)
11240 SetEventObject(obj
);
11246 #endif // wxUSE_GRID