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_
)
76 wxGridCellWithAttr(const wxGridCellWithAttr
& other
)
77 : coords(other
.coords
),
83 wxGridCellWithAttr
& operator=(const wxGridCellWithAttr
& other
)
85 coords
= other
.coords
;
86 if (attr
!= other
.attr
)
95 void ChangeAttr(wxGridCellAttr
* new_attr
)
99 // "Delete" (i.e. DecRef) the old attribute.
102 // Take ownership of the new attribute, i.e. no IncRef.
106 ~wxGridCellWithAttr()
111 wxGridCellCoords coords
;
112 wxGridCellAttr
*attr
;
115 WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellWithAttr
, wxGridCellWithAttrArray
,
116 class WXDLLIMPEXP_ADV
);
118 #include "wx/arrimpl.cpp"
120 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray
)
121 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray
)
123 // ----------------------------------------------------------------------------
125 // ----------------------------------------------------------------------------
127 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK
)
128 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK
)
129 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK
)
130 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK
)
131 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_BEGIN_DRAG
)
132 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK
)
133 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK
)
134 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK
)
135 DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK
)
136 DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE
)
137 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE
)
138 DEFINE_EVENT_TYPE(wxEVT_GRID_COL_MOVE
)
139 DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT
)
140 DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE
)
141 DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL
)
142 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN
)
143 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN
)
144 DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED
)
146 // ----------------------------------------------------------------------------
148 // ----------------------------------------------------------------------------
150 // common base class for various grid subwindows
151 class WXDLLIMPEXP_ADV wxGridSubwindow
: public wxWindow
154 wxGridSubwindow() { m_owner
= NULL
; }
155 wxGridSubwindow(wxGrid
*owner
,
159 int additionalStyle
= 0,
160 const wxString
& name
= wxPanelNameStr
)
161 : wxWindow(owner
, id
, pos
, size
,
162 wxBORDER_NONE
| additionalStyle
,
168 virtual bool AcceptsFocus() const { return false; }
170 wxGrid
*GetOwner() { return m_owner
; }
173 void OnMouseCaptureLost(wxMouseCaptureLostEvent
& event
);
177 DECLARE_EVENT_TABLE()
178 DECLARE_NO_COPY_CLASS(wxGridSubwindow
)
181 class WXDLLIMPEXP_ADV wxGridRowLabelWindow
: public wxGridSubwindow
184 wxGridRowLabelWindow() { }
185 wxGridRowLabelWindow( wxGrid
*parent
, wxWindowID id
,
186 const wxPoint
&pos
, const wxSize
&size
);
189 void OnPaint( wxPaintEvent
& event
);
190 void OnMouseEvent( wxMouseEvent
& event
);
191 void OnMouseWheel( wxMouseEvent
& event
);
193 DECLARE_DYNAMIC_CLASS(wxGridRowLabelWindow
)
194 DECLARE_EVENT_TABLE()
195 DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow
)
199 class WXDLLIMPEXP_ADV wxGridColLabelWindow
: public wxGridSubwindow
202 wxGridColLabelWindow() { }
203 wxGridColLabelWindow( wxGrid
*parent
, wxWindowID id
,
204 const wxPoint
&pos
, const wxSize
&size
);
207 void OnPaint( wxPaintEvent
& event
);
208 void OnMouseEvent( wxMouseEvent
& event
);
209 void OnMouseWheel( wxMouseEvent
& event
);
211 DECLARE_DYNAMIC_CLASS(wxGridColLabelWindow
)
212 DECLARE_EVENT_TABLE()
213 DECLARE_NO_COPY_CLASS(wxGridColLabelWindow
)
217 class WXDLLIMPEXP_ADV wxGridCornerLabelWindow
: public wxGridSubwindow
220 wxGridCornerLabelWindow() { }
221 wxGridCornerLabelWindow( wxGrid
*parent
, wxWindowID id
,
222 const wxPoint
&pos
, const wxSize
&size
);
225 void OnMouseEvent( wxMouseEvent
& event
);
226 void OnMouseWheel( wxMouseEvent
& event
);
227 void OnPaint( wxPaintEvent
& event
);
229 DECLARE_DYNAMIC_CLASS(wxGridCornerLabelWindow
)
230 DECLARE_EVENT_TABLE()
231 DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow
)
234 class WXDLLIMPEXP_ADV wxGridWindow
: public wxGridSubwindow
239 m_rowLabelWin
= NULL
;
240 m_colLabelWin
= NULL
;
243 wxGridWindow( wxGrid
*parent
,
244 wxGridRowLabelWindow
*rowLblWin
,
245 wxGridColLabelWindow
*colLblWin
,
246 wxWindowID id
, const wxPoint
&pos
, const wxSize
&size
);
248 void ScrollWindow( int dx
, int dy
, const wxRect
*rect
);
250 virtual bool AcceptsFocus() const { return true; }
253 wxGridRowLabelWindow
*m_rowLabelWin
;
254 wxGridColLabelWindow
*m_colLabelWin
;
256 void OnPaint( wxPaintEvent
&event
);
257 void OnMouseWheel( wxMouseEvent
& event
);
258 void OnMouseEvent( wxMouseEvent
& event
);
259 void OnKeyDown( wxKeyEvent
& );
260 void OnKeyUp( wxKeyEvent
& );
261 void OnChar( wxKeyEvent
& );
262 void OnEraseBackground( wxEraseEvent
& );
263 void OnFocus( wxFocusEvent
& );
265 DECLARE_DYNAMIC_CLASS(wxGridWindow
)
266 DECLARE_EVENT_TABLE()
267 DECLARE_NO_COPY_CLASS(wxGridWindow
)
271 class wxGridCellEditorEvtHandler
: public wxEvtHandler
274 wxGridCellEditorEvtHandler(wxGrid
* grid
, wxGridCellEditor
* editor
)
281 void OnKillFocus(wxFocusEvent
& event
);
282 void OnKeyDown(wxKeyEvent
& event
);
283 void OnChar(wxKeyEvent
& event
);
285 void SetInSetFocus(bool inSetFocus
) { m_inSetFocus
= inSetFocus
; }
289 wxGridCellEditor
*m_editor
;
291 // Work around the fact that a focus kill event can be sent to
292 // a combobox within a set focus event.
295 DECLARE_EVENT_TABLE()
296 DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler
)
297 DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler
)
301 IMPLEMENT_ABSTRACT_CLASS(wxGridCellEditorEvtHandler
, wxEvtHandler
)
303 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler
, wxEvtHandler
)
304 EVT_KILL_FOCUS( wxGridCellEditorEvtHandler::OnKillFocus
)
305 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown
)
306 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar
)
310 // ----------------------------------------------------------------------------
311 // the internal data representation used by wxGridCellAttrProvider
312 // ----------------------------------------------------------------------------
314 // this class stores attributes set for cells
315 class WXDLLIMPEXP_ADV wxGridCellAttrData
318 void SetAttr(wxGridCellAttr
*attr
, int row
, int col
);
319 wxGridCellAttr
*GetAttr(int row
, int col
) const;
320 void UpdateAttrRows( size_t pos
, int numRows
);
321 void UpdateAttrCols( size_t pos
, int numCols
);
324 // searches for the attr for given cell, returns wxNOT_FOUND if not found
325 int FindIndex(int row
, int col
) const;
327 wxGridCellWithAttrArray m_attrs
;
330 // this class stores attributes set for rows or columns
331 class WXDLLIMPEXP_ADV wxGridRowOrColAttrData
334 // empty ctor to suppress warnings
335 wxGridRowOrColAttrData() {}
336 ~wxGridRowOrColAttrData();
338 void SetAttr(wxGridCellAttr
*attr
, int rowOrCol
);
339 wxGridCellAttr
*GetAttr(int rowOrCol
) const;
340 void UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
);
343 wxArrayInt m_rowsOrCols
;
344 wxArrayAttrs m_attrs
;
347 // NB: this is just a wrapper around 3 objects: one which stores cell
348 // attributes, and 2 others for row/col ones
349 class WXDLLIMPEXP_ADV wxGridCellAttrProviderData
352 wxGridCellAttrData m_cellAttrs
;
353 wxGridRowOrColAttrData m_rowAttrs
,
358 // ----------------------------------------------------------------------------
359 // data structures used for the data type registry
360 // ----------------------------------------------------------------------------
362 struct wxGridDataTypeInfo
364 wxGridDataTypeInfo(const wxString
& typeName
,
365 wxGridCellRenderer
* renderer
,
366 wxGridCellEditor
* editor
)
367 : m_typeName(typeName
), m_renderer(renderer
), m_editor(editor
)
370 ~wxGridDataTypeInfo()
372 wxSafeDecRef(m_renderer
);
373 wxSafeDecRef(m_editor
);
377 wxGridCellRenderer
* m_renderer
;
378 wxGridCellEditor
* m_editor
;
380 DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo
)
384 WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridDataTypeInfo
*, wxGridDataTypeInfoArray
,
385 class WXDLLIMPEXP_ADV
);
388 class WXDLLIMPEXP_ADV wxGridTypeRegistry
391 wxGridTypeRegistry() {}
392 ~wxGridTypeRegistry();
394 void RegisterDataType(const wxString
& typeName
,
395 wxGridCellRenderer
* renderer
,
396 wxGridCellEditor
* editor
);
398 // find one of already registered data types
399 int FindRegisteredDataType(const wxString
& typeName
);
401 // try to FindRegisteredDataType(), if this fails and typeName is one of
402 // standard typenames, register it and return its index
403 int FindDataType(const wxString
& typeName
);
405 // try to FindDataType(), if it fails see if it is not one of already
406 // registered data types with some params in which case clone the
407 // registered data type and set params for it
408 int FindOrCloneDataType(const wxString
& typeName
);
410 wxGridCellRenderer
* GetRenderer(int index
);
411 wxGridCellEditor
* GetEditor(int index
);
414 wxGridDataTypeInfoArray m_typeinfo
;
418 // ----------------------------------------------------------------------------
419 // conditional compilation
420 // ----------------------------------------------------------------------------
422 #ifndef WXGRID_DRAW_LINES
423 #define WXGRID_DRAW_LINES 1
426 // ----------------------------------------------------------------------------
428 // ----------------------------------------------------------------------------
430 //#define DEBUG_ATTR_CACHE
431 #ifdef DEBUG_ATTR_CACHE
432 static size_t gs_nAttrCacheHits
= 0;
433 static size_t gs_nAttrCacheMisses
= 0;
436 // ----------------------------------------------------------------------------
438 // ----------------------------------------------------------------------------
440 wxGridCellCoords
wxGridNoCellCoords( -1, -1 );
441 wxRect
wxGridNoCellRect( -1, -1, -1, -1 );
444 // TODO: this doesn't work at all, grid cells have different sizes and approx
445 // calculations don't work as because of the size mismatch scrollbars
446 // sometimes fail to be shown when they should be or vice versa
448 // The scroll bars may be a little flakey once in a while, but that is
449 // surely much less horrible than having scroll lines of only 1!!!
452 // Well, it's still seriously broken so it might be better but needs
455 static const size_t GRID_SCROLL_LINE_X
= 15; // 1;
456 static const size_t GRID_SCROLL_LINE_Y
= GRID_SCROLL_LINE_X
;
458 // the size of hash tables used a bit everywhere (the max number of elements
459 // in these hash tables is the number of rows/columns)
460 static const int GRID_HASH_SIZE
= 100;
463 // ----------------------------------------------------------------------------
465 // ----------------------------------------------------------------------------
467 static inline int GetScrollX(int x
)
469 return (x
+ GRID_SCROLL_LINE_X
- 1) / GRID_SCROLL_LINE_X
;
472 static inline int GetScrollY(int y
)
474 return (y
+ GRID_SCROLL_LINE_Y
- 1) / GRID_SCROLL_LINE_Y
;
478 // ============================================================================
480 // ============================================================================
482 // ----------------------------------------------------------------------------
484 // ----------------------------------------------------------------------------
486 wxGridCellEditor::wxGridCellEditor()
492 wxGridCellEditor::~wxGridCellEditor()
497 void wxGridCellEditor::Create(wxWindow
* WXUNUSED(parent
),
498 wxWindowID
WXUNUSED(id
),
499 wxEvtHandler
* evtHandler
)
502 m_control
->PushEventHandler(evtHandler
);
505 void wxGridCellEditor::PaintBackground(const wxRect
& rectCell
,
506 wxGridCellAttr
*attr
)
508 // erase the background because we might not fill the cell
509 wxClientDC
dc(m_control
->GetParent());
510 wxGridWindow
* gridWindow
= wxDynamicCast(m_control
->GetParent(), wxGridWindow
);
512 gridWindow
->GetOwner()->PrepareDC(dc
);
514 dc
.SetPen(*wxTRANSPARENT_PEN
);
515 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour(), wxBRUSHSTYLE_SOLID
));
516 dc
.DrawRectangle(rectCell
);
518 // redraw the control we just painted over
519 m_control
->Refresh();
522 void wxGridCellEditor::Destroy()
526 m_control
->PopEventHandler( true /* delete it*/ );
528 m_control
->Destroy();
533 void wxGridCellEditor::Show(bool show
, wxGridCellAttr
*attr
)
535 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
537 m_control
->Show(show
);
541 // set the colours/fonts if we have any
544 m_colFgOld
= m_control
->GetForegroundColour();
545 m_control
->SetForegroundColour(attr
->GetTextColour());
547 m_colBgOld
= m_control
->GetBackgroundColour();
548 m_control
->SetBackgroundColour(attr
->GetBackgroundColour());
550 // Workaround for GTK+1 font setting problem on some platforms
551 #if !defined(__WXGTK__) || defined(__WXGTK20__)
552 m_fontOld
= m_control
->GetFont();
553 m_control
->SetFont(attr
->GetFont());
556 // can't do anything more in the base class version, the other
557 // attributes may only be used by the derived classes
562 // restore the standard colours fonts
563 if ( m_colFgOld
.Ok() )
565 m_control
->SetForegroundColour(m_colFgOld
);
566 m_colFgOld
= wxNullColour
;
569 if ( m_colBgOld
.Ok() )
571 m_control
->SetBackgroundColour(m_colBgOld
);
572 m_colBgOld
= wxNullColour
;
575 // Workaround for GTK+1 font setting problem on some platforms
576 #if !defined(__WXGTK__) || defined(__WXGTK20__)
577 if ( m_fontOld
.Ok() )
579 m_control
->SetFont(m_fontOld
);
580 m_fontOld
= wxNullFont
;
586 void wxGridCellEditor::SetSize(const wxRect
& rect
)
588 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
590 m_control
->SetSize(rect
, wxSIZE_ALLOW_MINUS_ONE
);
593 void wxGridCellEditor::HandleReturn(wxKeyEvent
& event
)
598 bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent
& event
)
600 bool ctrl
= event
.ControlDown();
601 bool alt
= event
.AltDown();
604 // On the Mac the Alt key is more like shift and is used for entry of
605 // valid characters, so check for Ctrl and Meta instead.
606 alt
= event
.MetaDown();
609 // Assume it's not a valid char if ctrl or alt is down, but if both are
610 // down then it may be because of an AltGr key combination, so let them
611 // through in that case.
612 if ((ctrl
|| alt
) && !(ctrl
&& alt
))
619 // If it's a F-Key or other special key then it shouldn't start the
621 if (event
.GetKeyCode() >= WXK_START
)
625 // if the unicode key code is not really a unicode character (it may
626 // be a function key or etc., the platforms appear to always give us a
627 // small value in this case) then fallback to the ASCII key code but
628 // don't do anything for function keys or etc.
629 key
= event
.GetUnicodeKey();
632 key
= event
.GetKeyCode();
633 keyOk
= (key
<= 127);
636 key
= event
.GetKeyCode();
637 keyOk
= (key
<= 255);
643 void wxGridCellEditor::StartingKey(wxKeyEvent
& event
)
648 void wxGridCellEditor::StartingClick()
654 // ----------------------------------------------------------------------------
655 // wxGridCellTextEditor
656 // ----------------------------------------------------------------------------
658 wxGridCellTextEditor::wxGridCellTextEditor()
663 void wxGridCellTextEditor::Create(wxWindow
* parent
,
665 wxEvtHandler
* evtHandler
)
667 DoCreate(parent
, id
, evtHandler
);
670 void wxGridCellTextEditor::DoCreate(wxWindow
* parent
,
672 wxEvtHandler
* evtHandler
,
675 style
|= wxTE_PROCESS_ENTER
| wxTE_PROCESS_TAB
| wxNO_BORDER
;
677 m_control
= new wxTextCtrl(parent
, id
, wxEmptyString
,
678 wxDefaultPosition
, wxDefaultSize
,
681 // set max length allowed in the textctrl, if the parameter was set
682 if ( m_maxChars
!= 0 )
684 Text()->SetMaxLength(m_maxChars
);
687 wxGridCellEditor::Create(parent
, id
, evtHandler
);
690 void wxGridCellTextEditor::PaintBackground(const wxRect
& WXUNUSED(rectCell
),
691 wxGridCellAttr
* WXUNUSED(attr
))
693 // as we fill the entire client area,
694 // don't do anything here to minimize flicker
697 void wxGridCellTextEditor::SetSize(const wxRect
& rectOrig
)
699 wxRect
rect(rectOrig
);
701 // Make the edit control large enough to allow for internal margins
703 // TODO: remove this if the text ctrl sizing is improved esp. for unix
705 #if defined(__WXGTK__)
713 #elif defined(__WXMSW__)
727 int extra_x
= ( rect
.x
> 2 ) ? 2 : 1;
728 int extra_y
= ( rect
.y
> 2 ) ? 2 : 1;
730 #if defined(__WXMOTIF__)
735 rect
.SetLeft( wxMax(0, rect
.x
- extra_x
) );
736 rect
.SetTop( wxMax(0, rect
.y
- extra_y
) );
737 rect
.SetRight( rect
.GetRight() + 2 * extra_x
);
738 rect
.SetBottom( rect
.GetBottom() + 2 * extra_y
);
741 wxGridCellEditor::SetSize(rect
);
744 void wxGridCellTextEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
746 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
748 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
750 DoBeginEdit(m_startValue
);
753 void wxGridCellTextEditor::DoBeginEdit(const wxString
& startValue
)
755 Text()->SetValue(startValue
);
756 Text()->SetInsertionPointEnd();
757 Text()->SetSelection(-1, -1);
761 bool wxGridCellTextEditor::EndEdit(int row
, int col
, wxGrid
* grid
)
763 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
765 bool changed
= false;
766 wxString value
= Text()->GetValue();
767 if (value
!= m_startValue
)
771 grid
->GetTable()->SetValue(row
, col
, value
);
773 m_startValue
= wxEmptyString
;
775 // No point in setting the text of the hidden control
776 //Text()->SetValue(m_startValue);
781 void wxGridCellTextEditor::Reset()
783 wxASSERT_MSG(m_control
, wxT("The wxGridCellEditor must be created first!"));
785 DoReset(m_startValue
);
788 void wxGridCellTextEditor::DoReset(const wxString
& startValue
)
790 Text()->SetValue(startValue
);
791 Text()->SetInsertionPointEnd();
794 bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent
& event
)
796 return wxGridCellEditor::IsAcceptedKey(event
);
799 void wxGridCellTextEditor::StartingKey(wxKeyEvent
& event
)
801 // Since this is now happening in the EVT_CHAR event EmulateKeyPress is no
802 // longer an appropriate way to get the character into the text control.
803 // Do it ourselves instead. We know that if we get this far that we have
804 // a valid character, so not a whole lot of testing needs to be done.
806 wxTextCtrl
* tc
= Text();
811 ch
= event
.GetUnicodeKey();
813 ch
= (wxChar
)event
.GetKeyCode();
815 ch
= (wxChar
)event
.GetKeyCode();
821 // delete the character at the cursor
822 pos
= tc
->GetInsertionPoint();
823 if (pos
< tc
->GetLastPosition())
824 tc
->Remove(pos
, pos
+ 1);
828 // delete the character before the cursor
829 pos
= tc
->GetInsertionPoint();
831 tc
->Remove(pos
- 1, pos
);
840 void wxGridCellTextEditor::HandleReturn( wxKeyEvent
&
841 WXUNUSED_GTK(WXUNUSED_MOTIF(event
)) )
843 #if defined(__WXMOTIF__) || defined(__WXGTK__)
844 // wxMotif needs a little extra help...
845 size_t pos
= (size_t)( Text()->GetInsertionPoint() );
846 wxString
s( Text()->GetValue() );
847 s
= s
.Left(pos
) + wxT("\n") + s
.Mid(pos
);
849 Text()->SetInsertionPoint( pos
);
851 // the other ports can handle a Return key press
857 void wxGridCellTextEditor::SetParameters(const wxString
& params
)
867 if ( params
.ToLong(&tmp
) )
869 m_maxChars
= (size_t)tmp
;
873 wxLogDebug( _T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params
.c_str() );
878 // return the value in the text control
879 wxString
wxGridCellTextEditor::GetValue() const
881 return Text()->GetValue();
884 // ----------------------------------------------------------------------------
885 // wxGridCellNumberEditor
886 // ----------------------------------------------------------------------------
888 wxGridCellNumberEditor::wxGridCellNumberEditor(int min
, int max
)
894 void wxGridCellNumberEditor::Create(wxWindow
* parent
,
896 wxEvtHandler
* evtHandler
)
901 // create a spin ctrl
902 m_control
= new wxSpinCtrl(parent
, wxID_ANY
, wxEmptyString
,
903 wxDefaultPosition
, wxDefaultSize
,
907 wxGridCellEditor::Create(parent
, id
, evtHandler
);
912 // just a text control
913 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
916 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
921 void wxGridCellNumberEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
923 // first get the value
924 wxGridTableBase
*table
= grid
->GetTable();
925 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
927 m_valueOld
= table
->GetValueAsLong(row
, col
);
932 wxString sValue
= table
->GetValue(row
, col
);
933 if (! sValue
.ToLong(&m_valueOld
) && ! sValue
.empty())
935 wxFAIL_MSG( _T("this cell doesn't have numeric value") );
943 Spin()->SetValue((int)m_valueOld
);
949 DoBeginEdit(GetString());
953 bool wxGridCellNumberEditor::EndEdit(int row
, int col
,
962 value
= Spin()->GetValue();
963 if ( value
== m_valueOld
)
966 text
.Printf(wxT("%ld"), value
);
968 else // using unconstrained input
969 #endif // wxUSE_SPINCTRL
971 const wxString
textOld(grid
->GetCellValue(row
, col
));
972 text
= Text()->GetValue();
975 if ( textOld
.empty() )
978 else // non-empty text now (maybe 0)
980 if ( !text
.ToLong(&value
) )
983 // if value == m_valueOld == 0 but old text was "" and new one is
984 // "0" something still did change
985 if ( value
== m_valueOld
&& (value
|| !textOld
.empty()) )
990 wxGridTableBase
* const table
= grid
->GetTable();
991 if ( table
->CanSetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
992 table
->SetValueAsLong(row
, col
, value
);
994 table
->SetValue(row
, col
, text
);
999 void wxGridCellNumberEditor::Reset()
1004 Spin()->SetValue((int)m_valueOld
);
1009 DoReset(GetString());
1013 bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent
& event
)
1015 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1017 int keycode
= event
.GetKeyCode();
1018 if ( (keycode
< 128) &&
1019 (wxIsdigit(keycode
) || keycode
== '+' || keycode
== '-'))
1028 void wxGridCellNumberEditor::StartingKey(wxKeyEvent
& event
)
1030 int keycode
= event
.GetKeyCode();
1033 if ( wxIsdigit(keycode
) || keycode
== '+' || keycode
== '-')
1035 wxGridCellTextEditor::StartingKey(event
);
1037 // skip Skip() below
1044 if ( wxIsdigit(keycode
) )
1046 wxSpinCtrl
* spin
= (wxSpinCtrl
*)m_control
;
1047 spin
->SetValue(keycode
- '0');
1048 spin
->SetSelection(1,1);
1057 void wxGridCellNumberEditor::SetParameters(const wxString
& params
)
1068 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
1072 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
1076 // skip the error message below
1081 wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params
.c_str());
1085 // return the value in the spin control if it is there (the text control otherwise)
1086 wxString
wxGridCellNumberEditor::GetValue() const
1093 long value
= Spin()->GetValue();
1094 s
.Printf(wxT("%ld"), value
);
1099 s
= Text()->GetValue();
1105 // ----------------------------------------------------------------------------
1106 // wxGridCellFloatEditor
1107 // ----------------------------------------------------------------------------
1109 wxGridCellFloatEditor::wxGridCellFloatEditor(int width
, int precision
)
1112 m_precision
= precision
;
1115 void wxGridCellFloatEditor::Create(wxWindow
* parent
,
1117 wxEvtHandler
* evtHandler
)
1119 wxGridCellTextEditor::Create(parent
, id
, evtHandler
);
1121 #if wxUSE_VALIDATORS
1122 Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC
));
1126 void wxGridCellFloatEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1128 // first get the value
1129 wxGridTableBase
* const table
= grid
->GetTable();
1130 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
1132 m_valueOld
= table
->GetValueAsDouble(row
, col
);
1138 const wxString value
= table
->GetValue(row
, col
);
1139 if ( !value
.empty() )
1141 if ( !value
.ToDouble(&m_valueOld
) )
1143 wxFAIL_MSG( _T("this cell doesn't have float value") );
1149 DoBeginEdit(GetString());
1152 bool wxGridCellFloatEditor::EndEdit(int row
, int col
, wxGrid
* grid
)
1154 const wxString
text(Text()->GetValue()),
1155 textOld(grid
->GetCellValue(row
, col
));
1158 if ( !text
.empty() )
1160 if ( !text
.ToDouble(&value
) )
1163 else // new value is empty string
1165 if ( textOld
.empty() )
1166 return false; // nothing changed
1171 // the test for empty strings ensures that we don't skip the value setting
1172 // when "" is replaced by "0" or vice versa as "" numeric value is also 0.
1173 if ( wxIsSameDouble(value
, m_valueOld
) && !text
.empty() && !textOld
.empty() )
1174 return false; // nothing changed
1176 wxGridTableBase
* const table
= grid
->GetTable();
1178 if ( table
->CanSetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
1179 table
->SetValueAsDouble(row
, col
, value
);
1181 table
->SetValue(row
, col
, text
);
1186 void wxGridCellFloatEditor::Reset()
1188 DoReset(GetString());
1191 void wxGridCellFloatEditor::StartingKey(wxKeyEvent
& event
)
1193 int keycode
= event
.GetKeyCode();
1195 tmpbuf
[0] = (char) keycode
;
1197 wxString
strbuf(tmpbuf
, *wxConvCurrent
);
1200 bool is_decimal_point
= ( strbuf
==
1201 wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT
, wxLOCALE_CAT_NUMBER
) );
1203 bool is_decimal_point
= ( strbuf
== _T(".") );
1206 if ( wxIsdigit(keycode
) || keycode
== '+' || keycode
== '-'
1207 || is_decimal_point
)
1209 wxGridCellTextEditor::StartingKey(event
);
1211 // skip Skip() below
1218 void wxGridCellFloatEditor::SetParameters(const wxString
& params
)
1229 if ( params
.BeforeFirst(_T(',')).ToLong(&tmp
) )
1233 if ( params
.AfterFirst(_T(',')).ToLong(&tmp
) )
1235 m_precision
= (int)tmp
;
1237 // skip the error message below
1242 wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params
.c_str());
1246 wxString
wxGridCellFloatEditor::GetString() const
1249 if ( m_precision
== -1 && m_width
!= -1)
1251 // default precision
1252 fmt
.Printf(_T("%%%d.f"), m_width
);
1254 else if ( m_precision
!= -1 && m_width
== -1)
1257 fmt
.Printf(_T("%%.%df"), m_precision
);
1259 else if ( m_precision
!= -1 && m_width
!= -1 )
1261 fmt
.Printf(_T("%%%d.%df"), m_width
, m_precision
);
1265 // default width/precision
1269 return wxString::Format(fmt
, m_valueOld
);
1272 bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent
& event
)
1274 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1276 const int keycode
= event
.GetKeyCode();
1277 if ( isascii(keycode
) )
1280 tmpbuf
[0] = (char) keycode
;
1282 wxString
strbuf(tmpbuf
, *wxConvCurrent
);
1285 const wxString decimalPoint
=
1286 wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT
, wxLOCALE_CAT_NUMBER
);
1288 const wxString
decimalPoint(_T('.'));
1291 // accept digits, 'e' as in '1e+6', also '-', '+', and '.'
1292 if ( wxIsdigit(keycode
) ||
1293 tolower(keycode
) == 'e' ||
1294 keycode
== decimalPoint
||
1306 #endif // wxUSE_TEXTCTRL
1310 // ----------------------------------------------------------------------------
1311 // wxGridCellBoolEditor
1312 // ----------------------------------------------------------------------------
1314 // the default values for GetValue()
1315 wxString
wxGridCellBoolEditor::ms_stringValues
[2] = { _T(""), _T("1") };
1317 void wxGridCellBoolEditor::Create(wxWindow
* parent
,
1319 wxEvtHandler
* evtHandler
)
1321 m_control
= new wxCheckBox(parent
, id
, wxEmptyString
,
1322 wxDefaultPosition
, wxDefaultSize
,
1325 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1328 void wxGridCellBoolEditor::SetSize(const wxRect
& r
)
1330 bool resize
= false;
1331 wxSize size
= m_control
->GetSize();
1332 wxCoord minSize
= wxMin(r
.width
, r
.height
);
1334 // check if the checkbox is not too big/small for this cell
1335 wxSize sizeBest
= m_control
->GetBestSize();
1336 if ( !(size
== sizeBest
) )
1338 // reset to default size if it had been made smaller
1344 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
1346 // leave 1 pixel margin
1347 size
.x
= size
.y
= minSize
- 2;
1354 m_control
->SetSize(size
);
1357 // position it in the centre of the rectangle (TODO: support alignment?)
1359 #if defined(__WXGTK__) || defined (__WXMOTIF__)
1360 // the checkbox without label still has some space to the right in wxGTK,
1361 // so shift it to the right
1363 #elif defined(__WXMSW__)
1364 // here too, but in other way
1369 int hAlign
= wxALIGN_CENTRE
;
1370 int vAlign
= wxALIGN_CENTRE
;
1372 GetCellAttr()->GetAlignment(& hAlign
, & vAlign
);
1375 if (hAlign
== wxALIGN_LEFT
)
1383 y
= r
.y
+ r
.height
/ 2 - size
.y
/ 2;
1385 else if (hAlign
== wxALIGN_RIGHT
)
1387 x
= r
.x
+ r
.width
- size
.x
- 2;
1388 y
= r
.y
+ r
.height
/ 2 - size
.y
/ 2;
1390 else if (hAlign
== wxALIGN_CENTRE
)
1392 x
= r
.x
+ r
.width
/ 2 - size
.x
/ 2;
1393 y
= r
.y
+ r
.height
/ 2 - size
.y
/ 2;
1396 m_control
->Move(x
, y
);
1399 void wxGridCellBoolEditor::Show(bool show
, wxGridCellAttr
*attr
)
1401 m_control
->Show(show
);
1405 wxColour colBg
= attr
? attr
->GetBackgroundColour() : *wxLIGHT_GREY
;
1406 CBox()->SetBackgroundColour(colBg
);
1410 void wxGridCellBoolEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1412 wxASSERT_MSG(m_control
,
1413 wxT("The wxGridCellEditor must be created first!"));
1415 if (grid
->GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
))
1417 m_startValue
= grid
->GetTable()->GetValueAsBool(row
, col
);
1421 wxString
cellval( grid
->GetTable()->GetValue(row
, col
) );
1423 if ( cellval
== ms_stringValues
[false] )
1424 m_startValue
= false;
1425 else if ( cellval
== ms_stringValues
[true] )
1426 m_startValue
= true;
1429 // do not try to be smart here and convert it to true or false
1430 // because we'll still overwrite it with something different and
1431 // this risks to be very surprising for the user code, let them
1433 wxFAIL_MSG( _T("invalid value for a cell with bool editor!") );
1437 CBox()->SetValue(m_startValue
);
1441 bool wxGridCellBoolEditor::EndEdit(int row
, int col
,
1444 wxASSERT_MSG(m_control
,
1445 wxT("The wxGridCellEditor must be created first!"));
1447 bool changed
= false;
1448 bool value
= CBox()->GetValue();
1449 if ( value
!= m_startValue
)
1454 wxGridTableBase
* const table
= grid
->GetTable();
1455 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
) )
1456 table
->SetValueAsBool(row
, col
, value
);
1458 table
->SetValue(row
, col
, GetValue());
1464 void wxGridCellBoolEditor::Reset()
1466 wxASSERT_MSG(m_control
,
1467 wxT("The wxGridCellEditor must be created first!"));
1469 CBox()->SetValue(m_startValue
);
1472 void wxGridCellBoolEditor::StartingClick()
1474 CBox()->SetValue(!CBox()->GetValue());
1477 bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent
& event
)
1479 if ( wxGridCellEditor::IsAcceptedKey(event
) )
1481 int keycode
= event
.GetKeyCode();
1494 void wxGridCellBoolEditor::StartingKey(wxKeyEvent
& event
)
1496 int keycode
= event
.GetKeyCode();
1500 CBox()->SetValue(!CBox()->GetValue());
1504 CBox()->SetValue(true);
1508 CBox()->SetValue(false);
1513 wxString
wxGridCellBoolEditor::GetValue() const
1515 return ms_stringValues
[CBox()->GetValue()];
1519 wxGridCellBoolEditor::UseStringValues(const wxString
& valueTrue
,
1520 const wxString
& valueFalse
)
1522 ms_stringValues
[false] = valueFalse
;
1523 ms_stringValues
[true] = valueTrue
;
1527 wxGridCellBoolEditor::IsTrueValue(const wxString
& value
)
1529 return value
== ms_stringValues
[true];
1532 #endif // wxUSE_CHECKBOX
1536 // ----------------------------------------------------------------------------
1537 // wxGridCellChoiceEditor
1538 // ----------------------------------------------------------------------------
1540 wxGridCellChoiceEditor::wxGridCellChoiceEditor(const wxArrayString
& choices
,
1542 : m_choices(choices
),
1543 m_allowOthers(allowOthers
) { }
1545 wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count
,
1546 const wxString choices
[],
1548 : m_allowOthers(allowOthers
)
1552 m_choices
.Alloc(count
);
1553 for ( size_t n
= 0; n
< count
; n
++ )
1555 m_choices
.Add(choices
[n
]);
1560 wxGridCellEditor
*wxGridCellChoiceEditor::Clone() const
1562 wxGridCellChoiceEditor
*editor
= new wxGridCellChoiceEditor
;
1563 editor
->m_allowOthers
= m_allowOthers
;
1564 editor
->m_choices
= m_choices
;
1569 void wxGridCellChoiceEditor::Create(wxWindow
* parent
,
1571 wxEvtHandler
* evtHandler
)
1573 int style
= wxTE_PROCESS_ENTER
|
1577 if ( !m_allowOthers
)
1578 style
|= wxCB_READONLY
;
1579 m_control
= new wxComboBox(parent
, id
, wxEmptyString
,
1580 wxDefaultPosition
, wxDefaultSize
,
1584 wxGridCellEditor::Create(parent
, id
, evtHandler
);
1587 void wxGridCellChoiceEditor::PaintBackground(const wxRect
& rectCell
,
1588 wxGridCellAttr
* attr
)
1590 // as we fill the entire client area, don't do anything here to minimize
1593 // TODO: It doesn't actually fill the client area since the height of a
1594 // combo always defaults to the standard. Until someone has time to
1595 // figure out the right rectangle to paint, just do it the normal way.
1596 wxGridCellEditor::PaintBackground(rectCell
, attr
);
1599 void wxGridCellChoiceEditor::BeginEdit(int row
, int col
, wxGrid
* grid
)
1601 wxASSERT_MSG(m_control
,
1602 wxT("The wxGridCellEditor must be created first!"));
1604 wxGridCellEditorEvtHandler
* evtHandler
= NULL
;
1606 evtHandler
= wxDynamicCast(m_control
->GetEventHandler(), wxGridCellEditorEvtHandler
);
1608 // Don't immediately end if we get a kill focus event within BeginEdit
1610 evtHandler
->SetInSetFocus(true);
1612 m_startValue
= grid
->GetTable()->GetValue(row
, col
);
1614 Reset(); // this updates combo box to correspond to m_startValue
1616 Combo()->SetFocus();
1620 // When dropping down the menu, a kill focus event
1621 // happens after this point, so we can't reset the flag yet.
1622 #if !defined(__WXGTK20__)
1623 evtHandler
->SetInSetFocus(false);
1628 bool wxGridCellChoiceEditor::EndEdit(int row
, int col
,
1631 wxString value
= Combo()->GetValue();
1632 if ( value
== m_startValue
)
1635 grid
->GetTable()->SetValue(row
, col
, value
);
1640 void wxGridCellChoiceEditor::Reset()
1644 Combo()->SetValue(m_startValue
);
1645 Combo()->SetInsertionPointEnd();
1647 else // the combobox is read-only
1649 // find the right position, or default to the first if not found
1650 int pos
= Combo()->FindString(m_startValue
);
1651 if (pos
== wxNOT_FOUND
)
1653 Combo()->SetSelection(pos
);
1657 void wxGridCellChoiceEditor::SetParameters(const wxString
& params
)
1667 wxStringTokenizer
tk(params
, _T(','));
1668 while ( tk
.HasMoreTokens() )
1670 m_choices
.Add(tk
.GetNextToken());
1674 // return the value in the text control
1675 wxString
wxGridCellChoiceEditor::GetValue() const
1677 return Combo()->GetValue();
1680 #endif // wxUSE_COMBOBOX
1682 // ----------------------------------------------------------------------------
1683 // wxGridCellEditorEvtHandler
1684 // ----------------------------------------------------------------------------
1686 void wxGridCellEditorEvtHandler::OnKillFocus(wxFocusEvent
& event
)
1688 // Don't disable the cell if we're just starting to edit it
1693 m_grid
->DisableCellEditControl();
1698 void wxGridCellEditorEvtHandler::OnKeyDown(wxKeyEvent
& event
)
1700 switch ( event
.GetKeyCode() )
1704 m_grid
->DisableCellEditControl();
1708 m_grid
->GetEventHandler()->ProcessEvent( event
);
1712 case WXK_NUMPAD_ENTER
:
1713 if (!m_grid
->GetEventHandler()->ProcessEvent(event
))
1714 m_editor
->HandleReturn(event
);
1723 void wxGridCellEditorEvtHandler::OnChar(wxKeyEvent
& event
)
1725 int row
= m_grid
->GetGridCursorRow();
1726 int col
= m_grid
->GetGridCursorCol();
1727 wxRect rect
= m_grid
->CellToRect( row
, col
);
1729 m_grid
->GetGridWindow()->GetClientSize( &cw
, &ch
);
1731 // if cell width is smaller than grid client area, cell is wholly visible
1732 bool wholeCellVisible
= (rect
.GetWidth() < cw
);
1734 switch ( event
.GetKeyCode() )
1739 case WXK_NUMPAD_ENTER
:
1744 if ( wholeCellVisible
)
1746 // no special processing needed...
1751 // do special processing for partly visible cell...
1753 // get the widths of all cells previous to this one
1755 for ( int i
= 0; i
< col
; i
++ )
1757 colXPos
+= m_grid
->GetColSize(i
);
1760 int xUnit
= 1, yUnit
= 1;
1761 m_grid
->GetScrollPixelsPerUnit(&xUnit
, &yUnit
);
1764 m_grid
->Scroll(colXPos
/ xUnit
- 1, m_grid
->GetScrollPos(wxVERTICAL
));
1768 m_grid
->Scroll(colXPos
/ xUnit
, m_grid
->GetScrollPos(wxVERTICAL
));
1776 if ( wholeCellVisible
)
1778 // no special processing needed...
1783 // do special processing for partly visible cell...
1786 wxString value
= m_grid
->GetCellValue(row
, col
);
1787 if ( wxEmptyString
!= value
)
1789 // get width of cell CONTENTS (text)
1791 wxFont font
= m_grid
->GetCellFont(row
, col
);
1792 m_grid
->GetTextExtent(value
, &textWidth
, &y
, NULL
, NULL
, &font
);
1794 // try to RIGHT align the text by scrolling
1795 int client_right
= m_grid
->GetGridWindow()->GetClientSize().GetWidth();
1797 // (m_grid->GetScrollLineX()*2) is a factor for not scrolling to far,
1798 // otherwise the last part of the cell content might be hidden below the scroll bar
1799 // FIXME: maybe there is a more suitable correction?
1800 textWidth
-= (client_right
- (m_grid
->GetScrollLineX() * 2));
1801 if ( textWidth
< 0 )
1807 // get the widths of all cells previous to this one
1809 for ( int i
= 0; i
< col
; i
++ )
1811 colXPos
+= m_grid
->GetColSize(i
);
1814 // and add the (modified) text width of the cell contents
1815 // as we'd like to see the last part of the cell contents
1816 colXPos
+= textWidth
;
1818 int xUnit
= 1, yUnit
= 1;
1819 m_grid
->GetScrollPixelsPerUnit(&xUnit
, &yUnit
);
1820 m_grid
->Scroll(colXPos
/ xUnit
- 1, m_grid
->GetScrollPos(wxVERTICAL
));
1831 // ----------------------------------------------------------------------------
1832 // wxGridCellWorker is an (almost) empty common base class for
1833 // wxGridCellRenderer and wxGridCellEditor managing ref counting
1834 // ----------------------------------------------------------------------------
1836 void wxGridCellWorker::SetParameters(const wxString
& WXUNUSED(params
))
1841 wxGridCellWorker::~wxGridCellWorker()
1845 // ============================================================================
1847 // ============================================================================
1849 // ----------------------------------------------------------------------------
1850 // wxGridCellRenderer
1851 // ----------------------------------------------------------------------------
1853 void wxGridCellRenderer::Draw(wxGrid
& grid
,
1854 wxGridCellAttr
& attr
,
1857 int WXUNUSED(row
), int WXUNUSED(col
),
1860 dc
.SetBackgroundMode( wxBRUSHSTYLE_SOLID
);
1862 // grey out fields if the grid is disabled
1863 if ( grid
.IsEnabled() )
1868 if ( grid
.HasFocus() )
1869 clr
= grid
.GetSelectionBackground();
1871 clr
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW
);
1872 dc
.SetBrush( wxBrush(clr
, wxBRUSHSTYLE_SOLID
) );
1876 dc
.SetBrush( wxBrush(attr
.GetBackgroundColour(), wxBRUSHSTYLE_SOLID
) );
1881 dc
.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
), wxBRUSHSTYLE_SOLID
));
1884 dc
.SetPen( *wxTRANSPARENT_PEN
);
1885 dc
.DrawRectangle(rect
);
1888 // ----------------------------------------------------------------------------
1889 // wxGridCellStringRenderer
1890 // ----------------------------------------------------------------------------
1892 void wxGridCellStringRenderer::SetTextColoursAndFont(const wxGrid
& grid
,
1893 const wxGridCellAttr
& attr
,
1897 dc
.SetBackgroundMode( wxBRUSHSTYLE_TRANSPARENT
);
1899 // TODO some special colours for attr.IsReadOnly() case?
1901 // different coloured text when the grid is disabled
1902 if ( grid
.IsEnabled() )
1907 if ( grid
.HasFocus() )
1908 clr
= grid
.GetSelectionBackground();
1910 clr
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW
);
1911 dc
.SetTextBackground( clr
);
1912 dc
.SetTextForeground( grid
.GetSelectionForeground() );
1916 dc
.SetTextBackground( attr
.GetBackgroundColour() );
1917 dc
.SetTextForeground( attr
.GetTextColour() );
1922 dc
.SetTextBackground(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
));
1923 dc
.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT
));
1926 dc
.SetFont( attr
.GetFont() );
1929 wxSize
wxGridCellStringRenderer::DoGetBestSize(const wxGridCellAttr
& attr
,
1931 const wxString
& text
)
1933 wxCoord x
= 0, y
= 0, max_x
= 0;
1934 dc
.SetFont(attr
.GetFont());
1935 wxStringTokenizer
tk(text
, _T('\n'));
1936 while ( tk
.HasMoreTokens() )
1938 dc
.GetTextExtent(tk
.GetNextToken(), &x
, &y
);
1939 max_x
= wxMax(max_x
, x
);
1942 y
*= 1 + text
.Freq(wxT('\n')); // multiply by the number of lines.
1944 return wxSize(max_x
, y
);
1947 wxSize
wxGridCellStringRenderer::GetBestSize(wxGrid
& grid
,
1948 wxGridCellAttr
& attr
,
1952 return DoGetBestSize(attr
, dc
, grid
.GetCellValue(row
, col
));
1955 void wxGridCellStringRenderer::Draw(wxGrid
& grid
,
1956 wxGridCellAttr
& attr
,
1958 const wxRect
& rectCell
,
1962 wxRect rect
= rectCell
;
1965 // erase only this cells background, overflow cells should have been erased
1966 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
1969 attr
.GetAlignment(&hAlign
, &vAlign
);
1971 int overflowCols
= 0;
1973 if (attr
.GetOverflow())
1975 int cols
= grid
.GetNumberCols();
1976 int best_width
= GetBestSize(grid
,attr
,dc
,row
,col
).GetWidth();
1977 int cell_rows
, cell_cols
;
1978 attr
.GetSize( &cell_rows
, &cell_cols
); // shouldn't get here if <= 0
1979 if ((best_width
> rectCell
.width
) && (col
< cols
) && grid
.GetTable())
1981 int i
, c_cols
, c_rows
;
1982 for (i
= col
+cell_cols
; i
< cols
; i
++)
1984 bool is_empty
= true;
1985 for (int j
=row
; j
< row
+ cell_rows
; j
++)
1987 // check w/ anchor cell for multicell block
1988 grid
.GetCellSize(j
, i
, &c_rows
, &c_cols
);
1991 if (!grid
.GetTable()->IsEmptyCell(j
+ c_rows
, i
))
2000 rect
.width
+= grid
.GetColSize(i
);
2008 if (rect
.width
>= best_width
)
2012 overflowCols
= i
- col
- cell_cols
+ 1;
2013 if (overflowCols
>= cols
)
2014 overflowCols
= cols
- 1;
2017 if (overflowCols
> 0) // redraw overflow cells w/ proper hilight
2019 hAlign
= wxALIGN_LEFT
; // if oveflowed then it's left aligned
2021 clip
.x
+= rectCell
.width
;
2022 // draw each overflow cell individually
2023 int col_end
= col
+ cell_cols
+ overflowCols
;
2024 if (col_end
>= grid
.GetNumberCols())
2025 col_end
= grid
.GetNumberCols() - 1;
2026 for (int i
= col
+ cell_cols
; i
<= col_end
; i
++)
2028 clip
.width
= grid
.GetColSize(i
) - 1;
2029 dc
.DestroyClippingRegion();
2030 dc
.SetClippingRegion(clip
);
2032 SetTextColoursAndFont(grid
, attr
, dc
,
2033 grid
.IsInSelection(row
,i
));
2035 grid
.DrawTextRectangle(dc
, grid
.GetCellValue(row
, col
),
2036 rect
, hAlign
, vAlign
);
2037 clip
.x
+= grid
.GetColSize(i
) - 1;
2043 dc
.DestroyClippingRegion();
2047 // now we only have to draw the text
2048 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
2050 grid
.DrawTextRectangle(dc
, grid
.GetCellValue(row
, col
),
2051 rect
, hAlign
, vAlign
);
2054 // ----------------------------------------------------------------------------
2055 // wxGridCellNumberRenderer
2056 // ----------------------------------------------------------------------------
2058 wxString
wxGridCellNumberRenderer::GetString(const wxGrid
& grid
, int row
, int col
)
2060 wxGridTableBase
*table
= grid
.GetTable();
2062 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_NUMBER
) )
2064 text
.Printf(_T("%ld"), table
->GetValueAsLong(row
, col
));
2068 text
= table
->GetValue(row
, col
);
2074 void wxGridCellNumberRenderer::Draw(wxGrid
& grid
,
2075 wxGridCellAttr
& attr
,
2077 const wxRect
& rectCell
,
2081 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
2083 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
2085 // draw the text right aligned by default
2087 attr
.GetAlignment(&hAlign
, &vAlign
);
2088 hAlign
= wxALIGN_RIGHT
;
2090 wxRect rect
= rectCell
;
2093 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
2096 wxSize
wxGridCellNumberRenderer::GetBestSize(wxGrid
& grid
,
2097 wxGridCellAttr
& attr
,
2101 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
2104 // ----------------------------------------------------------------------------
2105 // wxGridCellFloatRenderer
2106 // ----------------------------------------------------------------------------
2108 wxGridCellFloatRenderer::wxGridCellFloatRenderer(int width
, int precision
)
2111 SetPrecision(precision
);
2114 wxGridCellRenderer
*wxGridCellFloatRenderer::Clone() const
2116 wxGridCellFloatRenderer
*renderer
= new wxGridCellFloatRenderer
;
2117 renderer
->m_width
= m_width
;
2118 renderer
->m_precision
= m_precision
;
2119 renderer
->m_format
= m_format
;
2124 wxString
wxGridCellFloatRenderer::GetString(const wxGrid
& grid
, int row
, int col
)
2126 wxGridTableBase
*table
= grid
.GetTable();
2131 if ( table
->CanGetValueAs(row
, col
, wxGRID_VALUE_FLOAT
) )
2133 val
= table
->GetValueAsDouble(row
, col
);
2138 text
= table
->GetValue(row
, col
);
2139 hasDouble
= text
.ToDouble(&val
);
2146 if ( m_width
== -1 )
2148 if ( m_precision
== -1 )
2150 // default width/precision
2151 m_format
= _T("%f");
2155 m_format
.Printf(_T("%%.%df"), m_precision
);
2158 else if ( m_precision
== -1 )
2160 // default precision
2161 m_format
.Printf(_T("%%%d.f"), m_width
);
2165 m_format
.Printf(_T("%%%d.%df"), m_width
, m_precision
);
2169 text
.Printf(m_format
, val
);
2172 //else: text already contains the string
2177 void wxGridCellFloatRenderer::Draw(wxGrid
& grid
,
2178 wxGridCellAttr
& attr
,
2180 const wxRect
& rectCell
,
2184 wxGridCellRenderer::Draw(grid
, attr
, dc
, rectCell
, row
, col
, isSelected
);
2186 SetTextColoursAndFont(grid
, attr
, dc
, isSelected
);
2188 // draw the text right aligned by default
2190 attr
.GetAlignment(&hAlign
, &vAlign
);
2191 hAlign
= wxALIGN_RIGHT
;
2193 wxRect rect
= rectCell
;
2196 grid
.DrawTextRectangle(dc
, GetString(grid
, row
, col
), rect
, hAlign
, vAlign
);
2199 wxSize
wxGridCellFloatRenderer::GetBestSize(wxGrid
& grid
,
2200 wxGridCellAttr
& attr
,
2204 return DoGetBestSize(attr
, dc
, GetString(grid
, row
, col
));
2207 void wxGridCellFloatRenderer::SetParameters(const wxString
& params
)
2211 // reset to defaults
2217 wxString tmp
= params
.BeforeFirst(_T(','));
2221 if ( tmp
.ToLong(&width
) )
2223 SetWidth((int)width
);
2227 wxLogDebug(_T("Invalid wxGridCellFloatRenderer width parameter string '%s ignored"), params
.c_str());
2231 tmp
= params
.AfterFirst(_T(','));
2235 if ( tmp
.ToLong(&precision
) )
2237 SetPrecision((int)precision
);
2241 wxLogDebug(_T("Invalid wxGridCellFloatRenderer precision parameter string '%s ignored"), params
.c_str());
2247 // ----------------------------------------------------------------------------
2248 // wxGridCellBoolRenderer
2249 // ----------------------------------------------------------------------------
2251 wxSize
wxGridCellBoolRenderer::ms_sizeCheckMark
;
2253 // FIXME these checkbox size calculations are really ugly...
2255 // between checkmark and box
2256 static const wxCoord wxGRID_CHECKMARK_MARGIN
= 2;
2258 wxSize
wxGridCellBoolRenderer::GetBestSize(wxGrid
& grid
,
2259 wxGridCellAttr
& WXUNUSED(attr
),
2264 // compute it only once (no locks for MT safeness in GUI thread...)
2265 if ( !ms_sizeCheckMark
.x
)
2267 // get checkbox size
2268 wxCheckBox
*checkbox
= new wxCheckBox(&grid
, wxID_ANY
, wxEmptyString
);
2269 wxSize size
= checkbox
->GetBestSize();
2270 wxCoord checkSize
= size
.y
+ 2 * wxGRID_CHECKMARK_MARGIN
;
2272 #if defined(__WXMOTIF__)
2273 checkSize
-= size
.y
/ 2;
2278 ms_sizeCheckMark
.x
= ms_sizeCheckMark
.y
= checkSize
;
2281 return ms_sizeCheckMark
;
2284 void wxGridCellBoolRenderer::Draw(wxGrid
& grid
,
2285 wxGridCellAttr
& attr
,
2291 wxGridCellRenderer::Draw(grid
, attr
, dc
, rect
, row
, col
, isSelected
);
2293 // draw a check mark in the centre (ignoring alignment - TODO)
2294 wxSize size
= GetBestSize(grid
, attr
, dc
, row
, col
);
2296 // don't draw outside the cell
2297 wxCoord minSize
= wxMin(rect
.width
, rect
.height
);
2298 if ( size
.x
>= minSize
|| size
.y
>= minSize
)
2300 // and even leave (at least) 1 pixel margin
2301 size
.x
= size
.y
= minSize
;
2304 // draw a border around checkmark
2306 attr
.GetAlignment(&hAlign
, &vAlign
);
2309 if (hAlign
== wxALIGN_CENTRE
)
2311 rectBorder
.x
= rect
.x
+ rect
.width
/ 2 - size
.x
/ 2;
2312 rectBorder
.y
= rect
.y
+ rect
.height
/ 2 - size
.y
/ 2;
2313 rectBorder
.width
= size
.x
;
2314 rectBorder
.height
= size
.y
;
2316 else if (hAlign
== wxALIGN_LEFT
)
2318 rectBorder
.x
= rect
.x
+ 2;
2319 rectBorder
.y
= rect
.y
+ rect
.height
/ 2 - size
.y
/ 2;
2320 rectBorder
.width
= size
.x
;
2321 rectBorder
.height
= size
.y
;
2323 else if (hAlign
== wxALIGN_RIGHT
)
2325 rectBorder
.x
= rect
.x
+ rect
.width
- size
.x
- 2;
2326 rectBorder
.y
= rect
.y
+ rect
.height
/ 2 - size
.y
/ 2;
2327 rectBorder
.width
= size
.x
;
2328 rectBorder
.height
= size
.y
;
2332 if ( grid
.GetTable()->CanGetValueAs(row
, col
, wxGRID_VALUE_BOOL
) )
2334 value
= grid
.GetTable()->GetValueAsBool(row
, col
);
2338 wxString
cellval( grid
.GetTable()->GetValue(row
, col
) );
2339 value
= wxGridCellBoolEditor::IsTrueValue(cellval
);
2344 flags
|= wxCONTROL_CHECKED
;
2346 wxRendererNative::Get().DrawCheckBox( &grid
, dc
, rectBorder
, flags
);
2349 // ----------------------------------------------------------------------------
2351 // ----------------------------------------------------------------------------
2353 void wxGridCellAttr::Init(wxGridCellAttr
*attrDefault
)
2357 m_isReadOnly
= Unset
;
2362 m_attrkind
= wxGridCellAttr::Cell
;
2364 m_sizeRows
= m_sizeCols
= 1;
2365 m_overflow
= UnsetOverflow
;
2367 SetDefAttr(attrDefault
);
2370 wxGridCellAttr
*wxGridCellAttr::Clone() const
2372 wxGridCellAttr
*attr
= new wxGridCellAttr(m_defGridAttr
);
2374 if ( HasTextColour() )
2375 attr
->SetTextColour(GetTextColour());
2376 if ( HasBackgroundColour() )
2377 attr
->SetBackgroundColour(GetBackgroundColour());
2379 attr
->SetFont(GetFont());
2380 if ( HasAlignment() )
2381 attr
->SetAlignment(m_hAlign
, m_vAlign
);
2383 attr
->SetSize( m_sizeRows
, m_sizeCols
);
2387 attr
->SetRenderer(m_renderer
);
2388 m_renderer
->IncRef();
2392 attr
->SetEditor(m_editor
);
2397 attr
->SetReadOnly();
2399 attr
->SetOverflow( m_overflow
== Overflow
);
2400 attr
->SetKind( m_attrkind
);
2405 void wxGridCellAttr::MergeWith(wxGridCellAttr
*mergefrom
)
2407 if ( !HasTextColour() && mergefrom
->HasTextColour() )
2408 SetTextColour(mergefrom
->GetTextColour());
2409 if ( !HasBackgroundColour() && mergefrom
->HasBackgroundColour() )
2410 SetBackgroundColour(mergefrom
->GetBackgroundColour());
2411 if ( !HasFont() && mergefrom
->HasFont() )
2412 SetFont(mergefrom
->GetFont());
2413 if ( !HasAlignment() && mergefrom
->HasAlignment() )
2416 mergefrom
->GetAlignment( &hAlign
, &vAlign
);
2417 SetAlignment(hAlign
, vAlign
);
2419 if ( !HasSize() && mergefrom
->HasSize() )
2420 mergefrom
->GetSize( &m_sizeRows
, &m_sizeCols
);
2422 // Directly access member functions as GetRender/Editor don't just return
2423 // m_renderer/m_editor
2425 // Maybe add support for merge of Render and Editor?
2426 if (!HasRenderer() && mergefrom
->HasRenderer() )
2428 m_renderer
= mergefrom
->m_renderer
;
2429 m_renderer
->IncRef();
2431 if ( !HasEditor() && mergefrom
->HasEditor() )
2433 m_editor
= mergefrom
->m_editor
;
2436 if ( !HasReadWriteMode() && mergefrom
->HasReadWriteMode() )
2437 SetReadOnly(mergefrom
->IsReadOnly());
2439 if (!HasOverflowMode() && mergefrom
->HasOverflowMode() )
2440 SetOverflow(mergefrom
->GetOverflow());
2442 SetDefAttr(mergefrom
->m_defGridAttr
);
2445 void wxGridCellAttr::SetSize(int num_rows
, int num_cols
)
2447 // The size of a cell is normally 1,1
2449 // If this cell is larger (2,2) then this is the top left cell
2450 // the other cells that will be covered (lower right cells) must be
2451 // set to negative or zero values such that
2452 // row + num_rows of the covered cell points to the larger cell (this cell)
2453 // same goes for the col + num_cols.
2455 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
2457 wxASSERT_MSG( (!((num_rows
> 0) && (num_cols
<= 0)) ||
2458 !((num_rows
<= 0) && (num_cols
> 0)) ||
2459 !((num_rows
== 0) && (num_cols
== 0))),
2460 wxT("wxGridCellAttr::SetSize only takes two postive values or negative/zero values"));
2462 m_sizeRows
= num_rows
;
2463 m_sizeCols
= num_cols
;
2466 const wxColour
& wxGridCellAttr::GetTextColour() const
2468 if (HasTextColour())
2472 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2474 return m_defGridAttr
->GetTextColour();
2478 wxFAIL_MSG(wxT("Missing default cell attribute"));
2479 return wxNullColour
;
2483 const wxColour
& wxGridCellAttr::GetBackgroundColour() const
2485 if (HasBackgroundColour())
2489 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2491 return m_defGridAttr
->GetBackgroundColour();
2495 wxFAIL_MSG(wxT("Missing default cell attribute"));
2496 return wxNullColour
;
2500 const wxFont
& wxGridCellAttr::GetFont() const
2506 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2508 return m_defGridAttr
->GetFont();
2512 wxFAIL_MSG(wxT("Missing default cell attribute"));
2517 void wxGridCellAttr::GetAlignment(int *hAlign
, int *vAlign
) const
2526 else if (m_defGridAttr
&& m_defGridAttr
!= this)
2528 m_defGridAttr
->GetAlignment(hAlign
, vAlign
);
2532 wxFAIL_MSG(wxT("Missing default cell attribute"));
2536 void wxGridCellAttr::GetSize( int *num_rows
, int *num_cols
) const
2539 *num_rows
= m_sizeRows
;
2541 *num_cols
= m_sizeCols
;
2544 // GetRenderer and GetEditor use a slightly different decision path about
2545 // which attribute to use. If a non-default attr object has one then it is
2546 // used, otherwise the default editor or renderer is fetched from the grid and
2547 // used. It should be the default for the data type of the cell. If it is
2548 // NULL (because the table has a type that the grid does not have in its
2549 // registry), then the grid's default editor or renderer is used.
2551 wxGridCellRenderer
* wxGridCellAttr::GetRenderer(const wxGrid
* grid
, int row
, int col
) const
2553 wxGridCellRenderer
*renderer
= NULL
;
2555 if ( m_renderer
&& this != m_defGridAttr
)
2557 // use the cells renderer if it has one
2558 renderer
= m_renderer
;
2561 else // no non-default cell renderer
2563 // get default renderer for the data type
2566 // GetDefaultRendererForCell() will do IncRef() for us
2567 renderer
= grid
->GetDefaultRendererForCell(row
, col
);
2570 if ( renderer
== NULL
)
2572 if ( (m_defGridAttr
!= NULL
) && (m_defGridAttr
!= this) )
2574 // if we still don't have one then use the grid default
2575 // (no need for IncRef() here neither)
2576 renderer
= m_defGridAttr
->GetRenderer(NULL
, 0, 0);
2578 else // default grid attr
2580 // use m_renderer which we had decided not to use initially
2581 renderer
= m_renderer
;
2588 // we're supposed to always find something
2589 wxASSERT_MSG(renderer
, wxT("Missing default cell renderer"));
2594 // same as above, except for s/renderer/editor/g
2595 wxGridCellEditor
* wxGridCellAttr::GetEditor(const wxGrid
* grid
, int row
, int col
) const
2597 wxGridCellEditor
*editor
= NULL
;
2599 if ( m_editor
&& this != m_defGridAttr
)
2601 // use the cells editor if it has one
2605 else // no non default cell editor
2607 // get default editor for the data type
2610 // GetDefaultEditorForCell() will do IncRef() for us
2611 editor
= grid
->GetDefaultEditorForCell(row
, col
);
2614 if ( editor
== NULL
)
2616 if ( (m_defGridAttr
!= NULL
) && (m_defGridAttr
!= this) )
2618 // if we still don't have one then use the grid default
2619 // (no need for IncRef() here neither)
2620 editor
= m_defGridAttr
->GetEditor(NULL
, 0, 0);
2622 else // default grid attr
2624 // use m_editor which we had decided not to use initially
2632 // we're supposed to always find something
2633 wxASSERT_MSG(editor
, wxT("Missing default cell editor"));
2638 // ----------------------------------------------------------------------------
2639 // wxGridCellAttrData
2640 // ----------------------------------------------------------------------------
2642 void wxGridCellAttrData::SetAttr(wxGridCellAttr
*attr
, int row
, int col
)
2644 // Note: contrary to wxGridRowOrColAttrData::SetAttr, we must not
2645 // touch attribute's reference counting explicitly, since this
2646 // is managed by class wxGridCellWithAttr
2647 int n
= FindIndex(row
, col
);
2648 if ( n
== wxNOT_FOUND
)
2652 // add the attribute
2653 m_attrs
.Add(new wxGridCellWithAttr(row
, col
, attr
));
2655 //else: nothing to do
2657 else // we already have an attribute for this cell
2661 // change the attribute
2662 m_attrs
[(size_t)n
].ChangeAttr(attr
);
2666 // remove this attribute
2667 m_attrs
.RemoveAt((size_t)n
);
2672 wxGridCellAttr
*wxGridCellAttrData::GetAttr(int row
, int col
) const
2674 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2676 int n
= FindIndex(row
, col
);
2677 if ( n
!= wxNOT_FOUND
)
2679 attr
= m_attrs
[(size_t)n
].attr
;
2686 void wxGridCellAttrData::UpdateAttrRows( size_t pos
, int numRows
)
2688 size_t count
= m_attrs
.GetCount();
2689 for ( size_t n
= 0; n
< count
; n
++ )
2691 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2692 wxCoord row
= coords
.GetRow();
2693 if ((size_t)row
>= pos
)
2697 // If rows inserted, include row counter where necessary
2698 coords
.SetRow(row
+ numRows
);
2700 else if (numRows
< 0)
2702 // If rows deleted ...
2703 if ((size_t)row
>= pos
- numRows
)
2705 // ...either decrement row counter (if row still exists)...
2706 coords
.SetRow(row
+ numRows
);
2710 // ...or remove the attribute
2711 m_attrs
.RemoveAt(n
);
2720 void wxGridCellAttrData::UpdateAttrCols( size_t pos
, int numCols
)
2722 size_t count
= m_attrs
.GetCount();
2723 for ( size_t n
= 0; n
< count
; n
++ )
2725 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2726 wxCoord col
= coords
.GetCol();
2727 if ( (size_t)col
>= pos
)
2731 // If rows inserted, include row counter where necessary
2732 coords
.SetCol(col
+ numCols
);
2734 else if (numCols
< 0)
2736 // If rows deleted ...
2737 if ((size_t)col
>= pos
- numCols
)
2739 // ...either decrement row counter (if row still exists)...
2740 coords
.SetCol(col
+ numCols
);
2744 // ...or remove the attribute
2745 m_attrs
.RemoveAt(n
);
2754 int wxGridCellAttrData::FindIndex(int row
, int col
) const
2756 size_t count
= m_attrs
.GetCount();
2757 for ( size_t n
= 0; n
< count
; n
++ )
2759 const wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
2760 if ( (coords
.GetRow() == row
) && (coords
.GetCol() == col
) )
2769 // ----------------------------------------------------------------------------
2770 // wxGridRowOrColAttrData
2771 // ----------------------------------------------------------------------------
2773 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
2775 size_t count
= m_attrs
.GetCount();
2776 for ( size_t n
= 0; n
< count
; n
++ )
2778 m_attrs
[n
]->DecRef();
2782 wxGridCellAttr
*wxGridRowOrColAttrData::GetAttr(int rowOrCol
) const
2784 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2786 int n
= m_rowsOrCols
.Index(rowOrCol
);
2787 if ( n
!= wxNOT_FOUND
)
2789 attr
= m_attrs
[(size_t)n
];
2796 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr
*attr
, int rowOrCol
)
2798 int i
= m_rowsOrCols
.Index(rowOrCol
);
2799 if ( i
== wxNOT_FOUND
)
2803 // add the attribute - no need to do anything to reference count
2804 // since we take ownership of the attribute.
2805 m_rowsOrCols
.Add(rowOrCol
);
2808 // nothing to remove
2812 size_t n
= (size_t)i
;
2813 if ( m_attrs
[n
] == attr
)
2818 // change the attribute, handling reference count manually,
2819 // taking ownership of the new attribute.
2820 m_attrs
[n
]->DecRef();
2825 // remove this attribute, handling reference count manually
2826 m_attrs
[n
]->DecRef();
2827 m_rowsOrCols
.RemoveAt(n
);
2828 m_attrs
.RemoveAt(n
);
2833 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
)
2835 size_t count
= m_attrs
.GetCount();
2836 for ( size_t n
= 0; n
< count
; n
++ )
2838 int & rowOrCol
= m_rowsOrCols
[n
];
2839 if ( (size_t)rowOrCol
>= pos
)
2841 if ( numRowsOrCols
> 0 )
2843 // If rows inserted, include row counter where necessary
2844 rowOrCol
+= numRowsOrCols
;
2846 else if ( numRowsOrCols
< 0)
2848 // If rows deleted, either decrement row counter (if row still exists)
2849 if ((size_t)rowOrCol
>= pos
- numRowsOrCols
)
2850 rowOrCol
+= numRowsOrCols
;
2853 m_rowsOrCols
.RemoveAt(n
);
2854 m_attrs
[n
]->DecRef();
2855 m_attrs
.RemoveAt(n
);
2864 // ----------------------------------------------------------------------------
2865 // wxGridCellAttrProvider
2866 // ----------------------------------------------------------------------------
2868 wxGridCellAttrProvider::wxGridCellAttrProvider()
2870 m_data
= (wxGridCellAttrProviderData
*)NULL
;
2873 wxGridCellAttrProvider::~wxGridCellAttrProvider()
2878 void wxGridCellAttrProvider::InitData()
2880 m_data
= new wxGridCellAttrProviderData
;
2883 wxGridCellAttr
*wxGridCellAttrProvider::GetAttr(int row
, int col
,
2884 wxGridCellAttr::wxAttrKind kind
) const
2886 wxGridCellAttr
*attr
= (wxGridCellAttr
*)NULL
;
2891 case (wxGridCellAttr::Any
):
2892 // Get cached merge attributes.
2893 // Currently not used as no cache implemented as not mutable
2894 // attr = m_data->m_mergeAttr.GetAttr(row, col);
2897 // Basically implement old version.
2898 // Also check merge cache, so we don't have to re-merge every time..
2899 wxGridCellAttr
*attrcell
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2900 wxGridCellAttr
*attrrow
= m_data
->m_rowAttrs
.GetAttr(row
);
2901 wxGridCellAttr
*attrcol
= m_data
->m_colAttrs
.GetAttr(col
);
2903 if ((attrcell
!= attrrow
) && (attrrow
!= attrcol
) && (attrcell
!= attrcol
))
2905 // Two or more are non NULL
2906 attr
= new wxGridCellAttr
;
2907 attr
->SetKind(wxGridCellAttr::Merged
);
2909 // Order is important..
2912 attr
->MergeWith(attrcell
);
2917 attr
->MergeWith(attrcol
);
2922 attr
->MergeWith(attrrow
);
2926 // store merge attr if cache implemented
2928 //m_data->m_mergeAttr.SetAttr(attr, row, col);
2932 // one or none is non null return it or null.
2951 case (wxGridCellAttr::Cell
):
2952 attr
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
2955 case (wxGridCellAttr::Col
):
2956 attr
= m_data
->m_colAttrs
.GetAttr(col
);
2959 case (wxGridCellAttr::Row
):
2960 attr
= m_data
->m_rowAttrs
.GetAttr(row
);
2965 // (wxGridCellAttr::Default):
2966 // (wxGridCellAttr::Merged):
2974 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr
*attr
,
2980 m_data
->m_cellAttrs
.SetAttr(attr
, row
, col
);
2983 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr
*attr
, int row
)
2988 m_data
->m_rowAttrs
.SetAttr(attr
, row
);
2991 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr
*attr
, int col
)
2996 m_data
->m_colAttrs
.SetAttr(attr
, col
);
2999 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos
, int numRows
)
3003 m_data
->m_cellAttrs
.UpdateAttrRows( pos
, numRows
);
3005 m_data
->m_rowAttrs
.UpdateAttrRowsOrCols( pos
, numRows
);
3009 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos
, int numCols
)
3013 m_data
->m_cellAttrs
.UpdateAttrCols( pos
, numCols
);
3015 m_data
->m_colAttrs
.UpdateAttrRowsOrCols( pos
, numCols
);
3019 // ----------------------------------------------------------------------------
3020 // wxGridTypeRegistry
3021 // ----------------------------------------------------------------------------
3023 wxGridTypeRegistry::~wxGridTypeRegistry()
3025 size_t count
= m_typeinfo
.GetCount();
3026 for ( size_t i
= 0; i
< count
; i
++ )
3027 delete m_typeinfo
[i
];
3030 void wxGridTypeRegistry::RegisterDataType(const wxString
& typeName
,
3031 wxGridCellRenderer
* renderer
,
3032 wxGridCellEditor
* editor
)
3034 wxGridDataTypeInfo
* info
= new wxGridDataTypeInfo(typeName
, renderer
, editor
);
3036 // is it already registered?
3037 int loc
= FindRegisteredDataType(typeName
);
3038 if ( loc
!= wxNOT_FOUND
)
3040 delete m_typeinfo
[loc
];
3041 m_typeinfo
[loc
] = info
;
3045 m_typeinfo
.Add(info
);
3049 int wxGridTypeRegistry::FindRegisteredDataType(const wxString
& typeName
)
3051 size_t count
= m_typeinfo
.GetCount();
3052 for ( size_t i
= 0; i
< count
; i
++ )
3054 if ( typeName
== m_typeinfo
[i
]->m_typeName
)
3063 int wxGridTypeRegistry::FindDataType(const wxString
& typeName
)
3065 int index
= FindRegisteredDataType(typeName
);
3066 if ( index
== wxNOT_FOUND
)
3068 // check whether this is one of the standard ones, in which case
3069 // register it "on the fly"
3071 if ( typeName
== wxGRID_VALUE_STRING
)
3073 RegisterDataType(wxGRID_VALUE_STRING
,
3074 new wxGridCellStringRenderer
,
3075 new wxGridCellTextEditor
);
3078 #endif // wxUSE_TEXTCTRL
3080 if ( typeName
== wxGRID_VALUE_BOOL
)
3082 RegisterDataType(wxGRID_VALUE_BOOL
,
3083 new wxGridCellBoolRenderer
,
3084 new wxGridCellBoolEditor
);
3087 #endif // wxUSE_CHECKBOX
3089 if ( typeName
== wxGRID_VALUE_NUMBER
)
3091 RegisterDataType(wxGRID_VALUE_NUMBER
,
3092 new wxGridCellNumberRenderer
,
3093 new wxGridCellNumberEditor
);
3095 else if ( typeName
== wxGRID_VALUE_FLOAT
)
3097 RegisterDataType(wxGRID_VALUE_FLOAT
,
3098 new wxGridCellFloatRenderer
,
3099 new wxGridCellFloatEditor
);
3102 #endif // wxUSE_TEXTCTRL
3104 if ( typeName
== wxGRID_VALUE_CHOICE
)
3106 RegisterDataType(wxGRID_VALUE_CHOICE
,
3107 new wxGridCellStringRenderer
,
3108 new wxGridCellChoiceEditor
);
3111 #endif // wxUSE_COMBOBOX
3116 // we get here only if just added the entry for this type, so return
3118 index
= m_typeinfo
.GetCount() - 1;
3124 int wxGridTypeRegistry::FindOrCloneDataType(const wxString
& typeName
)
3126 int index
= FindDataType(typeName
);
3127 if ( index
== wxNOT_FOUND
)
3129 // the first part of the typename is the "real" type, anything after ':'
3130 // are the parameters for the renderer
3131 index
= FindDataType(typeName
.BeforeFirst(_T(':')));
3132 if ( index
== wxNOT_FOUND
)
3137 wxGridCellRenderer
*renderer
= GetRenderer(index
);
3138 wxGridCellRenderer
*rendererOld
= renderer
;
3139 renderer
= renderer
->Clone();
3140 rendererOld
->DecRef();
3142 wxGridCellEditor
*editor
= GetEditor(index
);
3143 wxGridCellEditor
*editorOld
= editor
;
3144 editor
= editor
->Clone();
3145 editorOld
->DecRef();
3147 // do it even if there are no parameters to reset them to defaults
3148 wxString params
= typeName
.AfterFirst(_T(':'));
3149 renderer
->SetParameters(params
);
3150 editor
->SetParameters(params
);
3152 // register the new typename
3153 RegisterDataType(typeName
, renderer
, editor
);
3155 // we just registered it, it's the last one
3156 index
= m_typeinfo
.GetCount() - 1;
3162 wxGridCellRenderer
* wxGridTypeRegistry::GetRenderer(int index
)
3164 wxGridCellRenderer
* renderer
= m_typeinfo
[index
]->m_renderer
;
3171 wxGridCellEditor
* wxGridTypeRegistry::GetEditor(int index
)
3173 wxGridCellEditor
* editor
= m_typeinfo
[index
]->m_editor
;
3180 // ----------------------------------------------------------------------------
3182 // ----------------------------------------------------------------------------
3184 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase
, wxObject
)
3186 wxGridTableBase::wxGridTableBase()
3188 m_view
= (wxGrid
*) NULL
;
3189 m_attrProvider
= (wxGridCellAttrProvider
*) NULL
;
3192 wxGridTableBase::~wxGridTableBase()
3194 delete m_attrProvider
;
3197 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider
*attrProvider
)
3199 delete m_attrProvider
;
3200 m_attrProvider
= attrProvider
;
3203 bool wxGridTableBase::CanHaveAttributes()
3205 if ( ! GetAttrProvider() )
3207 // use the default attr provider by default
3208 SetAttrProvider(new wxGridCellAttrProvider
);
3214 wxGridCellAttr
*wxGridTableBase::GetAttr(int row
, int col
, wxGridCellAttr::wxAttrKind kind
)
3216 if ( m_attrProvider
)
3217 return m_attrProvider
->GetAttr(row
, col
, kind
);
3219 return (wxGridCellAttr
*)NULL
;
3222 void wxGridTableBase::SetAttr(wxGridCellAttr
* attr
, int row
, int col
)
3224 if ( m_attrProvider
)
3227 attr
->SetKind(wxGridCellAttr::Cell
);
3228 m_attrProvider
->SetAttr(attr
, row
, col
);
3232 // as we take ownership of the pointer and don't store it, we must
3238 void wxGridTableBase::SetRowAttr(wxGridCellAttr
*attr
, int row
)
3240 if ( m_attrProvider
)
3242 attr
->SetKind(wxGridCellAttr::Row
);
3243 m_attrProvider
->SetRowAttr(attr
, row
);
3247 // as we take ownership of the pointer and don't store it, we must
3253 void wxGridTableBase::SetColAttr(wxGridCellAttr
*attr
, int col
)
3255 if ( m_attrProvider
)
3257 attr
->SetKind(wxGridCellAttr::Col
);
3258 m_attrProvider
->SetColAttr(attr
, col
);
3262 // as we take ownership of the pointer and don't store it, we must
3268 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos
),
3269 size_t WXUNUSED(numRows
) )
3271 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
3276 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows
) )
3278 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
3283 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos
),
3284 size_t WXUNUSED(numRows
) )
3286 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
3291 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos
),
3292 size_t WXUNUSED(numCols
) )
3294 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
3299 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols
) )
3301 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
3306 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos
),
3307 size_t WXUNUSED(numCols
) )
3309 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
3314 wxString
wxGridTableBase::GetRowLabelValue( int row
)
3318 // RD: Starting the rows at zero confuses users,
3319 // no matter how much it makes sense to us geeks.
3325 wxString
wxGridTableBase::GetColLabelValue( int col
)
3327 // default col labels are:
3328 // cols 0 to 25 : A-Z
3329 // cols 26 to 675 : AA-ZZ
3334 for ( n
= 1; ; n
++ )
3336 s
+= (wxChar
) (_T('A') + (wxChar
)(col
% 26));
3342 // reverse the string...
3344 for ( i
= 0; i
< n
; i
++ )
3352 wxString
wxGridTableBase::GetTypeName( int WXUNUSED(row
), int WXUNUSED(col
) )
3354 return wxGRID_VALUE_STRING
;
3357 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row
), int WXUNUSED(col
),
3358 const wxString
& typeName
)
3360 return typeName
== wxGRID_VALUE_STRING
;
3363 bool wxGridTableBase::CanSetValueAs( int row
, int col
, const wxString
& typeName
)
3365 return CanGetValueAs(row
, col
, typeName
);
3368 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
) )
3373 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
) )
3378 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
) )
3383 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
),
3384 long WXUNUSED(value
) )
3388 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
),
3389 double WXUNUSED(value
) )
3393 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
),
3394 bool WXUNUSED(value
) )
3398 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3399 const wxString
& WXUNUSED(typeName
) )
3404 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
3405 const wxString
& WXUNUSED(typeName
),
3406 void* WXUNUSED(value
) )
3410 //////////////////////////////////////////////////////////////////////
3412 // Message class for the grid table to send requests and notifications
3416 wxGridTableMessage::wxGridTableMessage()
3418 m_table
= (wxGridTableBase
*) NULL
;
3424 wxGridTableMessage::wxGridTableMessage( wxGridTableBase
*table
, int id
,
3425 int commandInt1
, int commandInt2
)
3429 m_comInt1
= commandInt1
;
3430 m_comInt2
= commandInt2
;
3433 //////////////////////////////////////////////////////////////////////
3435 // A basic grid table for string data. An object of this class will
3436 // created by wxGrid if you don't specify an alternative table class.
3439 WX_DEFINE_OBJARRAY(wxGridStringArray
)
3441 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable
, wxGridTableBase
)
3443 wxGridStringTable::wxGridStringTable()
3448 wxGridStringTable::wxGridStringTable( int numRows
, int numCols
)
3451 m_data
.Alloc( numRows
);
3454 sa
.Alloc( numCols
);
3455 sa
.Add( wxEmptyString
, numCols
);
3457 m_data
.Add( sa
, numRows
);
3460 wxGridStringTable::~wxGridStringTable()
3464 int wxGridStringTable::GetNumberRows()
3466 return m_data
.GetCount();
3469 int wxGridStringTable::GetNumberCols()
3471 if ( m_data
.GetCount() > 0 )
3472 return m_data
[0].GetCount();
3477 wxString
wxGridStringTable::GetValue( int row
, int col
)
3479 wxCHECK_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3481 _T("invalid row or column index in wxGridStringTable") );
3483 return m_data
[row
][col
];
3486 void wxGridStringTable::SetValue( int row
, int col
, const wxString
& value
)
3488 wxCHECK_RET( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3489 _T("invalid row or column index in wxGridStringTable") );
3491 m_data
[row
][col
] = value
;
3494 bool wxGridStringTable::IsEmptyCell( int row
, int col
)
3496 wxCHECK_MSG( (row
< GetNumberRows()) && (col
< GetNumberCols()),
3498 _T("invalid row or column index in wxGridStringTable") );
3500 return (m_data
[row
][col
] == wxEmptyString
);
3503 void wxGridStringTable::Clear()
3506 int numRows
, numCols
;
3508 numRows
= m_data
.GetCount();
3511 numCols
= m_data
[0].GetCount();
3513 for ( row
= 0; row
< numRows
; row
++ )
3515 for ( col
= 0; col
< numCols
; col
++ )
3517 m_data
[row
][col
] = wxEmptyString
;
3523 bool wxGridStringTable::InsertRows( size_t pos
, size_t numRows
)
3525 size_t curNumRows
= m_data
.GetCount();
3526 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3527 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3529 if ( pos
>= curNumRows
)
3531 return AppendRows( numRows
);
3535 sa
.Alloc( curNumCols
);
3536 sa
.Add( wxEmptyString
, curNumCols
);
3537 m_data
.Insert( sa
, pos
, numRows
);
3541 wxGridTableMessage
msg( this,
3542 wxGRIDTABLE_NOTIFY_ROWS_INSERTED
,
3546 GetView()->ProcessTableMessage( msg
);
3552 bool wxGridStringTable::AppendRows( size_t numRows
)
3554 size_t curNumRows
= m_data
.GetCount();
3555 size_t curNumCols
= ( curNumRows
> 0
3556 ? m_data
[0].GetCount()
3557 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3560 if ( curNumCols
> 0 )
3562 sa
.Alloc( curNumCols
);
3563 sa
.Add( wxEmptyString
, curNumCols
);
3566 m_data
.Add( sa
, numRows
);
3570 wxGridTableMessage
msg( this,
3571 wxGRIDTABLE_NOTIFY_ROWS_APPENDED
,
3574 GetView()->ProcessTableMessage( msg
);
3580 bool wxGridStringTable::DeleteRows( size_t pos
, size_t numRows
)
3582 size_t curNumRows
= m_data
.GetCount();
3584 if ( pos
>= curNumRows
)
3586 wxFAIL_MSG( wxString::Format
3588 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
3590 (unsigned long)numRows
,
3591 (unsigned long)curNumRows
3597 if ( numRows
> curNumRows
- pos
)
3599 numRows
= curNumRows
- pos
;
3602 if ( numRows
>= curNumRows
)
3608 m_data
.RemoveAt( pos
, numRows
);
3613 wxGridTableMessage
msg( this,
3614 wxGRIDTABLE_NOTIFY_ROWS_DELETED
,
3618 GetView()->ProcessTableMessage( msg
);
3624 bool wxGridStringTable::InsertCols( size_t pos
, size_t numCols
)
3628 size_t curNumRows
= m_data
.GetCount();
3629 size_t curNumCols
= ( curNumRows
> 0
3630 ? m_data
[0].GetCount()
3631 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3633 if ( pos
>= curNumCols
)
3635 return AppendCols( numCols
);
3638 if ( !m_colLabels
.IsEmpty() )
3640 m_colLabels
.Insert( wxEmptyString
, pos
, numCols
);
3643 for ( i
= pos
; i
< pos
+ numCols
; i
++ )
3644 m_colLabels
[i
] = wxGridTableBase::GetColLabelValue( i
);
3647 for ( row
= 0; row
< curNumRows
; row
++ )
3649 for ( col
= pos
; col
< pos
+ numCols
; col
++ )
3651 m_data
[row
].Insert( wxEmptyString
, col
);
3657 wxGridTableMessage
msg( this,
3658 wxGRIDTABLE_NOTIFY_COLS_INSERTED
,
3662 GetView()->ProcessTableMessage( msg
);
3668 bool wxGridStringTable::AppendCols( size_t numCols
)
3672 size_t curNumRows
= m_data
.GetCount();
3677 // TODO: something better than this ?
3679 wxFAIL_MSG( wxT("Unable to append cols to a grid table with no rows.\nCall AppendRows() first") );
3684 for ( row
= 0; row
< curNumRows
; row
++ )
3686 m_data
[row
].Add( wxEmptyString
, numCols
);
3691 wxGridTableMessage
msg( this,
3692 wxGRIDTABLE_NOTIFY_COLS_APPENDED
,
3695 GetView()->ProcessTableMessage( msg
);
3701 bool wxGridStringTable::DeleteCols( size_t pos
, size_t numCols
)
3705 size_t curNumRows
= m_data
.GetCount();
3706 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
3707 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
3709 if ( pos
>= curNumCols
)
3711 wxFAIL_MSG( wxString::Format
3713 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
3715 (unsigned long)numCols
,
3716 (unsigned long)curNumCols
3723 colID
= GetView()->GetColAt( pos
);
3727 if ( numCols
> curNumCols
- colID
)
3729 numCols
= curNumCols
- colID
;
3732 if ( !m_colLabels
.IsEmpty() )
3734 // m_colLabels stores just as many elements as it needs, e.g. if only
3735 // the label of the first column had been set it would have only one
3736 // element and not numCols, so account for it
3737 int nToRm
= m_colLabels
.size() - colID
;
3739 m_colLabels
.RemoveAt( colID
, nToRm
);
3742 for ( row
= 0; row
< curNumRows
; row
++ )
3744 if ( numCols
>= curNumCols
)
3746 m_data
[row
].Clear();
3750 m_data
[row
].RemoveAt( colID
, numCols
);
3756 wxGridTableMessage
msg( this,
3757 wxGRIDTABLE_NOTIFY_COLS_DELETED
,
3761 GetView()->ProcessTableMessage( msg
);
3767 wxString
wxGridStringTable::GetRowLabelValue( int row
)
3769 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3771 // using default label
3773 return wxGridTableBase::GetRowLabelValue( row
);
3777 return m_rowLabels
[row
];
3781 wxString
wxGridStringTable::GetColLabelValue( int col
)
3783 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3785 // using default label
3787 return wxGridTableBase::GetColLabelValue( col
);
3791 return m_colLabels
[col
];
3795 void wxGridStringTable::SetRowLabelValue( int row
, const wxString
& value
)
3797 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
3799 int n
= m_rowLabels
.GetCount();
3802 for ( i
= n
; i
<= row
; i
++ )
3804 m_rowLabels
.Add( wxGridTableBase::GetRowLabelValue(i
) );
3808 m_rowLabels
[row
] = value
;
3811 void wxGridStringTable::SetColLabelValue( int col
, const wxString
& value
)
3813 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
3815 int n
= m_colLabels
.GetCount();
3818 for ( i
= n
; i
<= col
; i
++ )
3820 m_colLabels
.Add( wxGridTableBase::GetColLabelValue(i
) );
3824 m_colLabels
[col
] = value
;
3828 //////////////////////////////////////////////////////////////////////
3829 //////////////////////////////////////////////////////////////////////
3831 BEGIN_EVENT_TABLE(wxGridSubwindow
, wxWindow
)
3832 EVT_MOUSE_CAPTURE_LOST(wxGridSubwindow::OnMouseCaptureLost
)
3835 void wxGridSubwindow::OnMouseCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
3837 m_owner
->CancelMouseCapture();
3840 IMPLEMENT_DYNAMIC_CLASS( wxGridRowLabelWindow
, wxWindow
)
3842 BEGIN_EVENT_TABLE( wxGridRowLabelWindow
, wxGridSubwindow
)
3843 EVT_PAINT( wxGridRowLabelWindow::OnPaint
)
3844 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel
)
3845 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent
)
3848 wxGridRowLabelWindow::wxGridRowLabelWindow( wxGrid
*parent
,
3850 const wxPoint
&pos
, const wxSize
&size
)
3851 : wxGridSubwindow(parent
, id
, pos
, size
)
3856 void wxGridRowLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3860 // NO - don't do this because it will set both the x and y origin
3861 // coords to match the parent scrolled window and we just want to
3862 // set the y coord - MB
3864 // m_owner->PrepareDC( dc );
3867 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3868 wxPoint pt
= dc
.GetDeviceOrigin();
3869 dc
.SetDeviceOrigin( pt
.x
, pt
.y
-y
);
3871 wxArrayInt rows
= m_owner
->CalcRowLabelsExposed( GetUpdateRegion() );
3872 m_owner
->DrawRowLabels( dc
, rows
);
3875 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3877 m_owner
->ProcessRowLabelMouseEvent( event
);
3880 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3882 m_owner
->GetEventHandler()->ProcessEvent( event
);
3885 //////////////////////////////////////////////////////////////////////
3887 IMPLEMENT_DYNAMIC_CLASS( wxGridColLabelWindow
, wxWindow
)
3889 BEGIN_EVENT_TABLE( wxGridColLabelWindow
, wxGridSubwindow
)
3890 EVT_PAINT( wxGridColLabelWindow::OnPaint
)
3891 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel
)
3892 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent
)
3895 wxGridColLabelWindow::wxGridColLabelWindow( wxGrid
*parent
,
3897 const wxPoint
&pos
, const wxSize
&size
)
3898 : wxGridSubwindow(parent
, id
, pos
, size
)
3903 void wxGridColLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3907 // NO - don't do this because it will set both the x and y origin
3908 // coords to match the parent scrolled window and we just want to
3909 // set the x coord - MB
3911 // m_owner->PrepareDC( dc );
3914 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
3915 wxPoint pt
= dc
.GetDeviceOrigin();
3916 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3917 dc
.SetDeviceOrigin( pt
.x
+x
, pt
.y
);
3919 dc
.SetDeviceOrigin( pt
.x
-x
, pt
.y
);
3921 wxArrayInt cols
= m_owner
->CalcColLabelsExposed( GetUpdateRegion() );
3922 m_owner
->DrawColLabels( dc
, cols
);
3925 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3927 m_owner
->ProcessColLabelMouseEvent( event
);
3930 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3932 m_owner
->GetEventHandler()->ProcessEvent( event
);
3935 //////////////////////////////////////////////////////////////////////
3937 IMPLEMENT_DYNAMIC_CLASS( wxGridCornerLabelWindow
, wxWindow
)
3939 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow
, wxGridSubwindow
)
3940 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel
)
3941 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent
)
3942 EVT_PAINT( wxGridCornerLabelWindow::OnPaint
)
3945 wxGridCornerLabelWindow::wxGridCornerLabelWindow( wxGrid
*parent
,
3947 const wxPoint
&pos
, const wxSize
&size
)
3948 : wxGridSubwindow(parent
, id
, pos
, size
)
3953 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
3957 int client_height
= 0;
3958 int client_width
= 0;
3959 GetClientSize( &client_width
, &client_height
);
3961 // VZ: any reason for this ifdef? (FIXME)
3967 rect
.SetWidth( client_width
- 2 );
3968 rect
.SetHeight( client_height
- 2 );
3970 wxRendererNative::Get().DrawHeaderButton( this, dc
, rect
, 0 );
3972 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
), 1, wxPENSTYLE_SOLID
) );
3973 dc
.DrawLine( client_width
- 1, client_height
- 1, client_width
- 1, 0 );
3974 dc
.DrawLine( client_width
- 1, client_height
- 1, 0, client_height
- 1 );
3975 dc
.DrawLine( 0, 0, client_width
, 0 );
3976 dc
.DrawLine( 0, 0, 0, client_height
);
3978 dc
.SetPen( *wxWHITE_PEN
);
3979 dc
.DrawLine( 1, 1, client_width
- 1, 1 );
3980 dc
.DrawLine( 1, 1, 1, client_height
- 1 );
3984 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
3986 m_owner
->ProcessCornerLabelMouseEvent( event
);
3989 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
3991 m_owner
->GetEventHandler()->ProcessEvent(event
);
3994 //////////////////////////////////////////////////////////////////////
3996 IMPLEMENT_DYNAMIC_CLASS( wxGridWindow
, wxWindow
)
3998 BEGIN_EVENT_TABLE( wxGridWindow
, wxGridSubwindow
)
3999 EVT_PAINT( wxGridWindow::OnPaint
)
4000 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel
)
4001 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent
)
4002 EVT_KEY_DOWN( wxGridWindow::OnKeyDown
)
4003 EVT_KEY_UP( wxGridWindow::OnKeyUp
)
4004 EVT_CHAR( wxGridWindow::OnChar
)
4005 EVT_SET_FOCUS( wxGridWindow::OnFocus
)
4006 EVT_KILL_FOCUS( wxGridWindow::OnFocus
)
4007 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground
)
4010 wxGridWindow::wxGridWindow( wxGrid
*parent
,
4011 wxGridRowLabelWindow
*rowLblWin
,
4012 wxGridColLabelWindow
*colLblWin
,
4015 const wxSize
&size
)
4016 : wxGridSubwindow(parent
, id
, pos
, size
,
4017 wxWANTS_CHARS
| wxCLIP_CHILDREN
,
4018 wxT("grid window") )
4021 m_rowLabelWin
= rowLblWin
;
4022 m_colLabelWin
= colLblWin
;
4025 void wxGridWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
4027 wxPaintDC
dc( this );
4028 m_owner
->PrepareDC( dc
);
4029 wxRegion reg
= GetUpdateRegion();
4030 wxGridCellCoordsArray dirtyCells
= m_owner
->CalcCellsExposed( reg
);
4031 m_owner
->DrawGridCellArea( dc
, dirtyCells
);
4033 #if WXGRID_DRAW_LINES
4034 m_owner
->DrawAllGridLines( dc
, reg
);
4037 m_owner
->DrawGridSpace( dc
);
4038 m_owner
->DrawHighlight( dc
, dirtyCells
);
4041 void wxGridWindow::ScrollWindow( int dx
, int dy
, const wxRect
*rect
)
4043 wxWindow::ScrollWindow( dx
, dy
, rect
);
4044 m_rowLabelWin
->ScrollWindow( 0, dy
, rect
);
4045 m_colLabelWin
->ScrollWindow( dx
, 0, rect
);
4048 void wxGridWindow::OnMouseEvent( wxMouseEvent
& event
)
4050 if (event
.ButtonDown(wxMOUSE_BTN_LEFT
) && FindFocus() != this)
4053 m_owner
->ProcessGridCellMouseEvent( event
);
4056 void wxGridWindow::OnMouseWheel( wxMouseEvent
& event
)
4058 m_owner
->GetEventHandler()->ProcessEvent( event
);
4061 // This seems to be required for wxMotif/wxGTK otherwise the mouse
4062 // cursor must be in the cell edit control to get key events
4064 void wxGridWindow::OnKeyDown( wxKeyEvent
& event
)
4066 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4070 void wxGridWindow::OnKeyUp( wxKeyEvent
& event
)
4072 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4076 void wxGridWindow::OnChar( wxKeyEvent
& event
)
4078 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4082 void wxGridWindow::OnEraseBackground( wxEraseEvent
& WXUNUSED(event
) )
4086 void wxGridWindow::OnFocus(wxFocusEvent
& event
)
4088 // and if we have any selection, it has to be repainted, because it
4089 // uses different colour when the grid is not focused:
4090 if ( m_owner
->IsSelection() )
4096 // NB: Note that this code is in "else" branch only because the other
4097 // branch refreshes everything and so there's no point in calling
4098 // Refresh() again, *not* because it should only be done if
4099 // !IsSelection(). If the above code is ever optimized to refresh
4100 // only selected area, this needs to be moved out of the "else"
4101 // branch so that it's always executed.
4103 // current cell cursor {dis,re}appears on focus change:
4104 const wxGridCellCoords
cursorCoords(m_owner
->GetGridCursorRow(),
4105 m_owner
->GetGridCursorCol());
4106 const wxRect cursor
=
4107 m_owner
->BlockToDeviceRect(cursorCoords
, cursorCoords
);
4108 Refresh(true, &cursor
);
4111 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
4115 //////////////////////////////////////////////////////////////////////
4117 // Internal Helper function for computing row or column from some
4118 // (unscrolled) coordinate value, using either
4119 // m_defaultRowHeight/m_defaultColWidth or binary search on array
4120 // of m_rowBottoms/m_ColRights to speed up the search!
4122 // Internal helper macros for simpler use of that function
4124 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
4125 const wxArrayInt
& BorderArray
, int nMax
,
4128 #define internalXToCol(x) XToCol(x, true)
4129 #define internalYToRow(y) CoordToRowOrCol(y, m_defaultRowHeight, \
4130 m_minAcceptableRowHeight, \
4131 m_rowBottoms, m_numRows, true)
4133 /////////////////////////////////////////////////////////////////////
4135 #if wxUSE_EXTENDED_RTTI
4136 WX_DEFINE_FLAGS( wxGridStyle
)
4138 wxBEGIN_FLAGS( wxGridStyle
)
4139 // new style border flags, we put them first to
4140 // use them for streaming out
4141 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
4142 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
4143 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
4144 wxFLAGS_MEMBER(wxBORDER_RAISED
)
4145 wxFLAGS_MEMBER(wxBORDER_STATIC
)
4146 wxFLAGS_MEMBER(wxBORDER_NONE
)
4148 // old style border flags
4149 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
4150 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
4151 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
4152 wxFLAGS_MEMBER(wxRAISED_BORDER
)
4153 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
4154 wxFLAGS_MEMBER(wxBORDER
)
4156 // standard window styles
4157 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
4158 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
4159 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
4160 wxFLAGS_MEMBER(wxWANTS_CHARS
)
4161 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
4162 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
4163 wxFLAGS_MEMBER(wxVSCROLL
)
4164 wxFLAGS_MEMBER(wxHSCROLL
)
4166 wxEND_FLAGS( wxGridStyle
)
4168 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGrid
, wxScrolledWindow
,"wx/grid.h")
4170 wxBEGIN_PROPERTIES_TABLE(wxGrid
)
4171 wxHIDE_PROPERTY( Children
)
4172 wxPROPERTY_FLAGS( WindowStyle
, wxGridStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
4173 wxEND_PROPERTIES_TABLE()
4175 wxBEGIN_HANDLERS_TABLE(wxGrid
)
4176 wxEND_HANDLERS_TABLE()
4178 wxCONSTRUCTOR_5( wxGrid
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
4181 TODO : Expose more information of a list's layout, etc. via appropriate objects (e.g., NotebookPageInfo)
4184 IMPLEMENT_DYNAMIC_CLASS( wxGrid
, wxScrolledWindow
)
4187 BEGIN_EVENT_TABLE( wxGrid
, wxScrolledWindow
)
4188 EVT_PAINT( wxGrid::OnPaint
)
4189 EVT_SIZE( wxGrid::OnSize
)
4190 EVT_KEY_DOWN( wxGrid::OnKeyDown
)
4191 EVT_KEY_UP( wxGrid::OnKeyUp
)
4192 EVT_CHAR ( wxGrid::OnChar
)
4193 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground
)
4201 wxGrid::wxGrid( wxWindow
*parent
,
4206 const wxString
& name
)
4209 Create(parent
, id
, pos
, size
, style
, name
);
4212 bool wxGrid::Create(wxWindow
*parent
, wxWindowID id
,
4213 const wxPoint
& pos
, const wxSize
& size
,
4214 long style
, const wxString
& name
)
4216 if (!wxScrolledWindow::Create(parent
, id
, pos
, size
,
4217 style
| wxWANTS_CHARS
, name
))
4220 m_colMinWidths
= wxLongToLongHashMap(GRID_HASH_SIZE
);
4221 m_rowMinHeights
= wxLongToLongHashMap(GRID_HASH_SIZE
);
4224 SetInitialSize(size
);
4232 // Must do this or ~wxScrollHelper will pop the wrong event handler
4233 SetTargetWindow(this);
4235 wxSafeDecRef(m_defaultCellAttr
);
4237 #ifdef DEBUG_ATTR_CACHE
4238 size_t total
= gs_nAttrCacheHits
+ gs_nAttrCacheMisses
;
4239 wxPrintf(_T("wxGrid attribute cache statistics: "
4240 "total: %u, hits: %u (%u%%)\n"),
4241 total
, gs_nAttrCacheHits
,
4242 total
? (gs_nAttrCacheHits
*100) / total
: 0);
4245 // if we own the table, just delete it, otherwise at least don't leave it
4246 // with dangling view pointer
4249 else if ( m_table
&& m_table
->GetView() == this )
4250 m_table
->SetView(NULL
);
4252 delete m_typeRegistry
;
4257 // ----- internal init and update functions
4260 // NOTE: If using the default visual attributes works everywhere then this can
4261 // be removed as well as the #else cases below.
4262 #define _USE_VISATTR 0
4264 void wxGrid::Create()
4266 // create the type registry
4267 m_typeRegistry
= new wxGridTypeRegistry
;
4269 m_cellEditCtrlEnabled
= false;
4271 m_defaultCellAttr
= new wxGridCellAttr();
4273 // Set default cell attributes
4274 m_defaultCellAttr
->SetDefAttr(m_defaultCellAttr
);
4275 m_defaultCellAttr
->SetKind(wxGridCellAttr::Default
);
4276 m_defaultCellAttr
->SetFont(GetFont());
4277 m_defaultCellAttr
->SetAlignment(wxALIGN_LEFT
, wxALIGN_TOP
);
4278 m_defaultCellAttr
->SetRenderer(new wxGridCellStringRenderer
);
4279 m_defaultCellAttr
->SetEditor(new wxGridCellTextEditor
);
4282 wxVisualAttributes gva
= wxListBox::GetClassDefaultAttributes();
4283 wxVisualAttributes lva
= wxPanel::GetClassDefaultAttributes();
4285 m_defaultCellAttr
->SetTextColour(gva
.colFg
);
4286 m_defaultCellAttr
->SetBackgroundColour(gva
.colBg
);
4289 m_defaultCellAttr
->SetTextColour(
4290 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
4291 m_defaultCellAttr
->SetBackgroundColour(
4292 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
4297 m_currentCellCoords
= wxGridNoCellCoords
;
4299 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
4300 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
4302 // subwindow components that make up the wxGrid
4303 m_rowLabelWin
= new wxGridRowLabelWindow( this,
4308 m_colLabelWin
= new wxGridColLabelWindow( this,
4313 m_cornerLabelWin
= new wxGridCornerLabelWindow( this,
4318 m_gridWin
= new wxGridWindow( this,
4325 SetTargetWindow( m_gridWin
);
4328 wxColour gfg
= gva
.colFg
;
4329 wxColour gbg
= gva
.colBg
;
4330 wxColour lfg
= lva
.colFg
;
4331 wxColour lbg
= lva
.colBg
;
4333 wxColour gfg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT
);
4334 wxColour gbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW
);
4335 wxColour lfg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT
);
4336 wxColour lbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE
);
4339 m_cornerLabelWin
->SetOwnForegroundColour(lfg
);
4340 m_cornerLabelWin
->SetOwnBackgroundColour(lbg
);
4341 m_rowLabelWin
->SetOwnForegroundColour(lfg
);
4342 m_rowLabelWin
->SetOwnBackgroundColour(lbg
);
4343 m_colLabelWin
->SetOwnForegroundColour(lfg
);
4344 m_colLabelWin
->SetOwnBackgroundColour(lbg
);
4346 m_gridWin
->SetOwnForegroundColour(gfg
);
4347 m_gridWin
->SetOwnBackgroundColour(gbg
);
4352 bool wxGrid::CreateGrid( int numRows
, int numCols
,
4353 wxGrid::wxGridSelectionModes selmode
)
4355 wxCHECK_MSG( !m_created
,
4357 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
4359 m_numRows
= numRows
;
4360 m_numCols
= numCols
;
4362 m_table
= new wxGridStringTable( m_numRows
, m_numCols
);
4363 m_table
->SetView( this );
4365 m_selection
= new wxGridSelection( this, selmode
);
4374 void wxGrid::SetSelectionMode(wxGrid::wxGridSelectionModes selmode
)
4376 wxCHECK_RET( m_created
,
4377 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
4379 m_selection
->SetSelectionMode( selmode
);
4382 wxGrid::wxGridSelectionModes
wxGrid::GetSelectionMode() const
4384 wxCHECK_MSG( m_created
, wxGrid::wxGridSelectCells
,
4385 wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
4387 return m_selection
->GetSelectionMode();
4390 bool wxGrid::SetTable( wxGridTableBase
*table
, bool takeOwnership
,
4391 wxGrid::wxGridSelectionModes selmode
)
4393 bool checkSelection
= false;
4396 // stop all processing
4401 m_table
->SetView(0);
4413 checkSelection
= true;
4415 // kill row and column size arrays
4416 m_colWidths
.Empty();
4417 m_colRights
.Empty();
4418 m_rowHeights
.Empty();
4419 m_rowBottoms
.Empty();
4424 m_numRows
= table
->GetNumberRows();
4425 m_numCols
= table
->GetNumberCols();
4428 m_table
->SetView( this );
4429 m_ownTable
= takeOwnership
;
4430 m_selection
= new wxGridSelection( this, selmode
);
4433 // If the newly set table is smaller than the
4434 // original one current cell and selection regions
4435 // might be invalid,
4436 m_selectingKeyboard
= wxGridNoCellCoords
;
4437 m_currentCellCoords
=
4438 wxGridCellCoords(wxMin(m_numRows
, m_currentCellCoords
.GetRow()),
4439 wxMin(m_numCols
, m_currentCellCoords
.GetCol()));
4440 if (m_selectingTopLeft
.GetRow() >= m_numRows
||
4441 m_selectingTopLeft
.GetCol() >= m_numCols
)
4443 m_selectingTopLeft
= wxGridNoCellCoords
;
4444 m_selectingBottomRight
= wxGridNoCellCoords
;
4447 m_selectingBottomRight
=
4448 wxGridCellCoords(wxMin(m_numRows
,
4449 m_selectingBottomRight
.GetRow()),
4451 m_selectingBottomRight
.GetCol()));
4461 void wxGrid::InitVars()
4465 m_cornerLabelWin
= NULL
;
4466 m_rowLabelWin
= NULL
;
4467 m_colLabelWin
= NULL
;
4474 m_defaultCellAttr
= NULL
;
4475 m_typeRegistry
= NULL
;
4476 m_winCapture
= NULL
;
4481 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
4482 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
4484 if ( m_rowLabelWin
)
4486 m_labelBackgroundColour
= m_rowLabelWin
->GetBackgroundColour();
4490 m_labelBackgroundColour
= *wxWHITE
;
4493 m_labelTextColour
= *wxBLACK
;
4496 m_attrCache
.row
= -1;
4497 m_attrCache
.col
= -1;
4498 m_attrCache
.attr
= NULL
;
4500 // TODO: something better than this ?
4502 m_labelFont
= this->GetFont();
4503 m_labelFont
.SetWeight( wxBOLD
);
4505 m_rowLabelHorizAlign
= wxALIGN_CENTRE
;
4506 m_rowLabelVertAlign
= wxALIGN_CENTRE
;
4508 m_colLabelHorizAlign
= wxALIGN_CENTRE
;
4509 m_colLabelVertAlign
= wxALIGN_CENTRE
;
4510 m_colLabelTextOrientation
= wxHORIZONTAL
;
4512 m_defaultColWidth
= WXGRID_DEFAULT_COL_WIDTH
;
4513 m_defaultRowHeight
= m_gridWin
->GetCharHeight();
4515 m_minAcceptableColWidth
= WXGRID_MIN_COL_WIDTH
;
4516 m_minAcceptableRowHeight
= WXGRID_MIN_ROW_HEIGHT
;
4518 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
4519 m_defaultRowHeight
+= 8;
4521 m_defaultRowHeight
+= 4;
4524 m_gridLineColour
= wxColour( 192,192,192 );
4525 m_gridLinesEnabled
= true;
4526 m_cellHighlightColour
= *wxBLACK
;
4527 m_cellHighlightPenWidth
= 2;
4528 m_cellHighlightROPenWidth
= 1;
4530 m_canDragColMove
= false;
4532 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
4533 m_winCapture
= (wxWindow
*)NULL
;
4534 m_canDragRowSize
= true;
4535 m_canDragColSize
= true;
4536 m_canDragGridSize
= true;
4537 m_canDragCell
= false;
4539 m_dragRowOrCol
= -1;
4540 m_isDragging
= false;
4541 m_startDragPos
= wxDefaultPosition
;
4542 m_nativeColumnLabels
= false;
4544 m_waitForSlowClick
= false;
4546 m_rowResizeCursor
= wxCursor( wxCURSOR_SIZENS
);
4547 m_colResizeCursor
= wxCursor( wxCURSOR_SIZEWE
);
4549 m_currentCellCoords
= wxGridNoCellCoords
;
4553 m_selectionBackground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
4554 m_selectionForeground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
4556 m_editable
= true; // default for whole grid
4558 m_inOnKeyDown
= false;
4564 m_scrollLineX
= GRID_SCROLL_LINE_X
;
4565 m_scrollLineY
= GRID_SCROLL_LINE_Y
;
4568 // ----------------------------------------------------------------------------
4569 // the idea is to call these functions only when necessary because they create
4570 // quite big arrays which eat memory mostly unnecessary - in particular, if
4571 // default widths/heights are used for all rows/columns, we may not use these
4574 // with some extra code, it should be possible to only store the widths/heights
4575 // different from default ones (resulting in space savings for huge grids) but
4576 // this is not done currently
4577 // ----------------------------------------------------------------------------
4579 void wxGrid::InitRowHeights()
4581 m_rowHeights
.Empty();
4582 m_rowBottoms
.Empty();
4584 m_rowHeights
.Alloc( m_numRows
);
4585 m_rowBottoms
.Alloc( m_numRows
);
4587 m_rowHeights
.Add( m_defaultRowHeight
, m_numRows
);
4590 for ( int i
= 0; i
< m_numRows
; i
++ )
4592 rowBottom
+= m_defaultRowHeight
;
4593 m_rowBottoms
.Add( rowBottom
);
4597 void wxGrid::InitColWidths()
4599 m_colWidths
.Empty();
4600 m_colRights
.Empty();
4602 m_colWidths
.Alloc( m_numCols
);
4603 m_colRights
.Alloc( m_numCols
);
4605 m_colWidths
.Add( m_defaultColWidth
, m_numCols
);
4608 for ( int i
= 0; i
< m_numCols
; i
++ )
4610 colRight
= ( GetColPos( i
) + 1 ) * m_defaultColWidth
;
4611 m_colRights
.Add( colRight
);
4615 int wxGrid::GetColWidth(int col
) const
4617 return m_colWidths
.IsEmpty() ? m_defaultColWidth
: m_colWidths
[col
];
4620 int wxGrid::GetColLeft(int col
) const
4622 return m_colRights
.IsEmpty() ? GetColPos( col
) * m_defaultColWidth
4623 : m_colRights
[col
] - m_colWidths
[col
];
4626 int wxGrid::GetColRight(int col
) const
4628 return m_colRights
.IsEmpty() ? (GetColPos( col
) + 1) * m_defaultColWidth
4632 int wxGrid::GetRowHeight(int row
) const
4634 return m_rowHeights
.IsEmpty() ? m_defaultRowHeight
: m_rowHeights
[row
];
4637 int wxGrid::GetRowTop(int row
) const
4639 return m_rowBottoms
.IsEmpty() ? row
* m_defaultRowHeight
4640 : m_rowBottoms
[row
] - m_rowHeights
[row
];
4643 int wxGrid::GetRowBottom(int row
) const
4645 return m_rowBottoms
.IsEmpty() ? (row
+ 1) * m_defaultRowHeight
4646 : m_rowBottoms
[row
];
4649 void wxGrid::CalcDimensions()
4651 // compute the size of the scrollable area
4652 int w
= m_numCols
> 0 ? GetColRight(GetColAt(m_numCols
- 1)) : 0;
4653 int h
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0;
4658 // take into account editor if shown
4659 if ( IsCellEditControlShown() )
4662 int r
= m_currentCellCoords
.GetRow();
4663 int c
= m_currentCellCoords
.GetCol();
4664 int x
= GetColLeft(c
);
4665 int y
= GetRowTop(r
);
4667 // how big is the editor
4668 wxGridCellAttr
* attr
= GetCellAttr(r
, c
);
4669 wxGridCellEditor
* editor
= attr
->GetEditor(this, r
, c
);
4670 editor
->GetControl()->GetSize(&w2
, &h2
);
4681 // preserve (more or less) the previous position
4683 GetViewStart( &x
, &y
);
4685 // ensure the position is valid for the new scroll ranges
4687 x
= wxMax( w
- 1, 0 );
4689 y
= wxMax( h
- 1, 0 );
4691 // do set scrollbar parameters
4692 SetScrollbars( m_scrollLineX
, m_scrollLineY
,
4693 GetScrollX(w
), GetScrollY(h
),
4695 GetBatchCount() != 0);
4697 // if our OnSize() hadn't been called (it would if we have scrollbars), we
4698 // still must reposition the children
4702 void wxGrid::CalcWindowSizes()
4704 // escape if the window is has not been fully created yet
4706 if ( m_cornerLabelWin
== NULL
)
4710 GetClientSize( &cw
, &ch
);
4712 // this block of code tries to work around the following problem: the grid
4713 // could have been just resized to have enough space to show the full grid
4714 // window contents without the scrollbars, but its client size could be
4715 // not big enough because the grid has the scrollbars right now and so the
4716 // scrollbars would remain even though we don't need them any more
4718 // to prevent this from happening, check if we have enough space for
4719 // everything without the scrollbars and explicitly disable them then
4720 wxSize size
= GetSize() - GetWindowBorderSize();
4721 if ( size
!= wxSize(cw
, ch
) )
4723 // check if we have enough space for grid window after accounting for
4724 // the fixed size elements
4725 size
.x
-= m_rowLabelWidth
;
4726 size
.y
-= m_colLabelHeight
;
4728 const wxSize vsize
= m_gridWin
->GetVirtualSize();
4730 if ( size
.x
>= vsize
.x
&& size
.y
>= vsize
.y
)
4732 // yes, we do, so remove the scrollbars and use the new client size
4733 // (which should be the same as full window size - borders now)
4734 SetScrollbars(0, 0, 0, 0);
4735 GetClientSize(&cw
, &ch
);
4739 // the grid may be too small to have enough space for the labels yet, don't
4740 // size the windows to negative sizes in this case
4741 int gw
= cw
- m_rowLabelWidth
;
4742 int gh
= ch
- m_colLabelHeight
;
4748 if ( m_cornerLabelWin
&& m_cornerLabelWin
->IsShown() )
4749 m_cornerLabelWin
->SetSize( 0, 0, m_rowLabelWidth
, m_colLabelHeight
);
4751 if ( m_colLabelWin
&& m_colLabelWin
->IsShown() )
4752 m_colLabelWin
->SetSize( m_rowLabelWidth
, 0, gw
, m_colLabelHeight
);
4754 if ( m_rowLabelWin
&& m_rowLabelWin
->IsShown() )
4755 m_rowLabelWin
->SetSize( 0, m_colLabelHeight
, m_rowLabelWidth
, gh
);
4757 if ( m_gridWin
&& m_gridWin
->IsShown() )
4758 m_gridWin
->SetSize( m_rowLabelWidth
, m_colLabelHeight
, gw
, gh
);
4761 // this is called when the grid table sends a message
4762 // to indicate that it has been redimensioned
4764 bool wxGrid::Redimension( wxGridTableMessage
& msg
)
4767 bool result
= false;
4769 // Clear the attribute cache as the attribute might refer to a different
4770 // cell than stored in the cache after adding/removing rows/columns.
4773 // By the same reasoning, the editor should be dismissed if columns are
4774 // added or removed. And for consistency, it should IMHO always be
4775 // removed, not only if the cell "underneath" it actually changes.
4776 // For now, I intentionally do not save the editor's content as the
4777 // cell it might want to save that stuff to might no longer exist.
4778 HideCellEditControl();
4781 // if we were using the default widths/heights so far, we must change them
4783 if ( m_colWidths
.IsEmpty() )
4788 if ( m_rowHeights
.IsEmpty() )
4794 switch ( msg
.GetId() )
4796 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
4798 size_t pos
= msg
.GetCommandInt();
4799 int numRows
= msg
.GetCommandInt2();
4801 m_numRows
+= numRows
;
4803 if ( !m_rowHeights
.IsEmpty() )
4805 m_rowHeights
.Insert( m_defaultRowHeight
, pos
, numRows
);
4806 m_rowBottoms
.Insert( 0, pos
, numRows
);
4810 bottom
= m_rowBottoms
[pos
- 1];
4812 for ( i
= pos
; i
< m_numRows
; i
++ )
4814 bottom
+= m_rowHeights
[i
];
4815 m_rowBottoms
[i
] = bottom
;
4819 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4821 // if we have just inserted cols into an empty grid the current
4822 // cell will be undefined...
4824 SetCurrentCell( 0, 0 );
4828 m_selection
->UpdateRows( pos
, numRows
);
4829 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4831 attrProvider
->UpdateAttrRows( pos
, numRows
);
4833 if ( !GetBatchCount() )
4836 m_rowLabelWin
->Refresh();
4842 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
4844 int numRows
= msg
.GetCommandInt();
4845 int oldNumRows
= m_numRows
;
4846 m_numRows
+= numRows
;
4848 if ( !m_rowHeights
.IsEmpty() )
4850 m_rowHeights
.Add( m_defaultRowHeight
, numRows
);
4851 m_rowBottoms
.Add( 0, numRows
);
4854 if ( oldNumRows
> 0 )
4855 bottom
= m_rowBottoms
[oldNumRows
- 1];
4857 for ( i
= oldNumRows
; i
< m_numRows
; i
++ )
4859 bottom
+= m_rowHeights
[i
];
4860 m_rowBottoms
[i
] = bottom
;
4864 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4866 // if we have just inserted cols into an empty grid the current
4867 // cell will be undefined...
4869 SetCurrentCell( 0, 0 );
4872 if ( !GetBatchCount() )
4875 m_rowLabelWin
->Refresh();
4881 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
4883 size_t pos
= msg
.GetCommandInt();
4884 int numRows
= msg
.GetCommandInt2();
4885 m_numRows
-= numRows
;
4887 if ( !m_rowHeights
.IsEmpty() )
4889 m_rowHeights
.RemoveAt( pos
, numRows
);
4890 m_rowBottoms
.RemoveAt( pos
, numRows
);
4893 for ( i
= 0; i
< m_numRows
; i
++ )
4895 h
+= m_rowHeights
[i
];
4896 m_rowBottoms
[i
] = h
;
4902 m_currentCellCoords
= wxGridNoCellCoords
;
4906 if ( m_currentCellCoords
.GetRow() >= m_numRows
)
4907 m_currentCellCoords
.Set( 0, 0 );
4911 m_selection
->UpdateRows( pos
, -((int)numRows
) );
4912 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4915 attrProvider
->UpdateAttrRows( pos
, -((int)numRows
) );
4917 // ifdef'd out following patch from Paul Gammans
4919 // No need to touch column attributes, unless we
4920 // removed _all_ rows, in this case, we remove
4921 // all column attributes.
4922 // I hate to do this here, but the
4923 // needed data is not available inside UpdateAttrRows.
4924 if ( !GetNumberRows() )
4925 attrProvider
->UpdateAttrCols( 0, -GetNumberCols() );
4929 if ( !GetBatchCount() )
4932 m_rowLabelWin
->Refresh();
4938 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
4940 size_t pos
= msg
.GetCommandInt();
4941 int numCols
= msg
.GetCommandInt2();
4942 m_numCols
+= numCols
;
4944 if ( !m_colAt
.IsEmpty() )
4946 //Shift the column IDs
4948 for ( i
= 0; i
< m_numCols
- numCols
; i
++ )
4950 if ( m_colAt
[i
] >= (int)pos
)
4951 m_colAt
[i
] += numCols
;
4954 m_colAt
.Insert( pos
, pos
, numCols
);
4956 //Set the new columns' positions
4957 for ( i
= pos
+ 1; i
< (int)pos
+ numCols
; i
++ )
4963 if ( !m_colWidths
.IsEmpty() )
4965 m_colWidths
.Insert( m_defaultColWidth
, pos
, numCols
);
4966 m_colRights
.Insert( 0, pos
, numCols
);
4970 right
= m_colRights
[GetColAt( pos
- 1 )];
4973 for ( colPos
= pos
; colPos
< m_numCols
; colPos
++ )
4975 i
= GetColAt( colPos
);
4977 right
+= m_colWidths
[i
];
4978 m_colRights
[i
] = right
;
4982 if ( m_currentCellCoords
== wxGridNoCellCoords
)
4984 // if we have just inserted cols into an empty grid the current
4985 // cell will be undefined...
4987 SetCurrentCell( 0, 0 );
4991 m_selection
->UpdateCols( pos
, numCols
);
4992 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
4994 attrProvider
->UpdateAttrCols( pos
, numCols
);
4995 if ( !GetBatchCount() )
4998 m_colLabelWin
->Refresh();
5004 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
5006 int numCols
= msg
.GetCommandInt();
5007 int oldNumCols
= m_numCols
;
5008 m_numCols
+= numCols
;
5010 if ( !m_colAt
.IsEmpty() )
5012 m_colAt
.Add( 0, numCols
);
5014 //Set the new columns' positions
5016 for ( i
= oldNumCols
; i
< m_numCols
; i
++ )
5022 if ( !m_colWidths
.IsEmpty() )
5024 m_colWidths
.Add( m_defaultColWidth
, numCols
);
5025 m_colRights
.Add( 0, numCols
);
5028 if ( oldNumCols
> 0 )
5029 right
= m_colRights
[GetColAt( oldNumCols
- 1 )];
5032 for ( colPos
= oldNumCols
; colPos
< m_numCols
; colPos
++ )
5034 i
= GetColAt( colPos
);
5036 right
+= m_colWidths
[i
];
5037 m_colRights
[i
] = right
;
5041 if ( m_currentCellCoords
== wxGridNoCellCoords
)
5043 // if we have just inserted cols into an empty grid the current
5044 // cell will be undefined...
5046 SetCurrentCell( 0, 0 );
5048 if ( !GetBatchCount() )
5051 m_colLabelWin
->Refresh();
5057 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
5059 size_t pos
= msg
.GetCommandInt();
5060 int numCols
= msg
.GetCommandInt2();
5061 m_numCols
-= numCols
;
5063 if ( !m_colAt
.IsEmpty() )
5065 int colID
= GetColAt( pos
);
5067 m_colAt
.RemoveAt( pos
, numCols
);
5069 //Shift the column IDs
5071 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
5073 if ( m_colAt
[colPos
] > colID
)
5074 m_colAt
[colPos
] -= numCols
;
5078 if ( !m_colWidths
.IsEmpty() )
5080 m_colWidths
.RemoveAt( pos
, numCols
);
5081 m_colRights
.RemoveAt( pos
, numCols
);
5085 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
5087 i
= GetColAt( colPos
);
5089 w
+= m_colWidths
[i
];
5096 m_currentCellCoords
= wxGridNoCellCoords
;
5100 if ( m_currentCellCoords
.GetCol() >= m_numCols
)
5101 m_currentCellCoords
.Set( 0, 0 );
5105 m_selection
->UpdateCols( pos
, -((int)numCols
) );
5106 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
5109 attrProvider
->UpdateAttrCols( pos
, -((int)numCols
) );
5111 // ifdef'd out following patch from Paul Gammans
5113 // No need to touch row attributes, unless we
5114 // removed _all_ columns, in this case, we remove
5115 // all row attributes.
5116 // I hate to do this here, but the
5117 // needed data is not available inside UpdateAttrCols.
5118 if ( !GetNumberCols() )
5119 attrProvider
->UpdateAttrRows( 0, -GetNumberRows() );
5123 if ( !GetBatchCount() )
5126 m_colLabelWin
->Refresh();
5133 if (result
&& !GetBatchCount() )
5134 m_gridWin
->Refresh();
5139 wxArrayInt
wxGrid::CalcRowLabelsExposed( const wxRegion
& reg
) const
5141 wxRegionIterator
iter( reg
);
5144 wxArrayInt rowlabels
;
5151 // TODO: remove this when we can...
5152 // There is a bug in wxMotif that gives garbage update
5153 // rectangles if you jump-scroll a long way by clicking the
5154 // scrollbar with middle button. This is a work-around
5156 #if defined(__WXMOTIF__)
5158 m_gridWin
->GetClientSize( &cw
, &ch
);
5159 if ( r
.GetTop() > ch
)
5161 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
5164 // logical bounds of update region
5167 CalcUnscrolledPosition( 0, r
.GetTop(), &dummy
, &top
);
5168 CalcUnscrolledPosition( 0, r
.GetBottom(), &dummy
, &bottom
);
5170 // find the row labels within these bounds
5173 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
5175 if ( GetRowBottom(row
) < top
)
5178 if ( GetRowTop(row
) > bottom
)
5181 rowlabels
.Add( row
);
5190 wxArrayInt
wxGrid::CalcColLabelsExposed( const wxRegion
& reg
) const
5192 wxRegionIterator
iter( reg
);
5195 wxArrayInt colLabels
;
5202 // TODO: remove this when we can...
5203 // There is a bug in wxMotif that gives garbage update
5204 // rectangles if you jump-scroll a long way by clicking the
5205 // scrollbar with middle button. This is a work-around
5207 #if defined(__WXMOTIF__)
5209 m_gridWin
->GetClientSize( &cw
, &ch
);
5210 if ( r
.GetLeft() > cw
)
5212 r
.SetRight( wxMin( r
.GetRight(), cw
) );
5215 // logical bounds of update region
5218 CalcUnscrolledPosition( r
.GetLeft(), 0, &left
, &dummy
);
5219 CalcUnscrolledPosition( r
.GetRight(), 0, &right
, &dummy
);
5221 // find the cells within these bounds
5225 for ( colPos
= GetColPos( internalXToCol(left
) ); colPos
< m_numCols
; colPos
++ )
5227 col
= GetColAt( colPos
);
5229 if ( GetColRight(col
) < left
)
5232 if ( GetColLeft(col
) > right
)
5235 colLabels
.Add( col
);
5244 wxGridCellCoordsArray
wxGrid::CalcCellsExposed( const wxRegion
& reg
) const
5246 wxRegionIterator
iter( reg
);
5249 wxGridCellCoordsArray cellsExposed
;
5251 int left
, top
, right
, bottom
;
5256 // TODO: remove this when we can...
5257 // There is a bug in wxMotif that gives garbage update
5258 // rectangles if you jump-scroll a long way by clicking the
5259 // scrollbar with middle button. This is a work-around
5261 #if defined(__WXMOTIF__)
5263 m_gridWin
->GetClientSize( &cw
, &ch
);
5264 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
5265 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
5266 r
.SetRight( wxMin( r
.GetRight(), cw
) );
5267 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
5270 // logical bounds of update region
5272 CalcUnscrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
5273 CalcUnscrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
5275 // find the cells within these bounds
5278 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
5280 if ( GetRowBottom(row
) <= top
)
5283 if ( GetRowTop(row
) > bottom
)
5287 for ( colPos
= GetColPos( internalXToCol(left
) ); colPos
< m_numCols
; colPos
++ )
5289 col
= GetColAt( colPos
);
5291 if ( GetColRight(col
) <= left
)
5294 if ( GetColLeft(col
) > right
)
5297 cellsExposed
.Add( wxGridCellCoords( row
, col
) );
5304 return cellsExposed
;
5308 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent
& event
)
5311 wxPoint
pos( event
.GetPosition() );
5312 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5314 if ( event
.Dragging() )
5318 m_isDragging
= true;
5319 m_rowLabelWin
->CaptureMouse();
5322 if ( event
.LeftIsDown() )
5324 switch ( m_cursorMode
)
5326 case WXGRID_CURSOR_RESIZE_ROW
:
5328 int cw
, ch
, left
, dummy
;
5329 m_gridWin
->GetClientSize( &cw
, &ch
);
5330 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
5332 wxClientDC
dc( m_gridWin
);
5335 GetRowTop(m_dragRowOrCol
) +
5336 GetRowMinimalHeight(m_dragRowOrCol
) );
5337 dc
.SetLogicalFunction(wxINVERT
);
5338 if ( m_dragLastPos
>= 0 )
5340 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
5342 dc
.DrawLine( left
, y
, left
+cw
, y
);
5347 case WXGRID_CURSOR_SELECT_ROW
:
5349 if ( (row
= YToRow( y
)) >= 0 )
5353 m_selection
->SelectRow( row
,
5354 event
.ControlDown(),
5363 // default label to suppress warnings about "enumeration value
5364 // 'xxx' not handled in switch
5372 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
5377 if (m_rowLabelWin
->HasCapture())
5378 m_rowLabelWin
->ReleaseMouse();
5379 m_isDragging
= false;
5382 // ------------ Entering or leaving the window
5384 if ( event
.Entering() || event
.Leaving() )
5386 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
5389 // ------------ Left button pressed
5391 else if ( event
.LeftDown() )
5393 // don't send a label click event for a hit on the
5394 // edge of the row label - this is probably the user
5395 // wanting to resize the row
5397 if ( YToEdgeOfRow(y
) < 0 )
5401 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, row
, -1, event
) )
5403 if ( !event
.ShiftDown() && !event
.CmdDown() )
5407 if ( event
.ShiftDown() )
5409 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
5412 GetNumberCols() - 1,
5413 event
.ControlDown(),
5420 m_selection
->SelectRow( row
,
5421 event
.ControlDown(),
5428 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW
, m_rowLabelWin
);
5433 // starting to drag-resize a row
5434 if ( CanDragRowSize() )
5435 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
);
5439 // ------------ Left double click
5441 else if (event
.LeftDClick() )
5443 row
= YToEdgeOfRow(y
);
5448 !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, row
, -1, event
) )
5450 // no default action at the moment
5455 // adjust row height depending on label text
5456 AutoSizeRowLabelSize( row
);
5458 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5463 // ------------ Left button released
5465 else if ( event
.LeftUp() )
5467 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
5469 DoEndDragResizeRow();
5471 // Note: we are ending the event *after* doing
5472 // default processing in this case
5474 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
5477 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
5481 // ------------ Right button down
5483 else if ( event
.RightDown() )
5487 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, row
, -1, event
) )
5489 // no default action at the moment
5493 // ------------ Right double click
5495 else if ( event
.RightDClick() )
5499 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, row
, -1, event
) )
5501 // no default action at the moment
5505 // ------------ No buttons down and mouse moving
5507 else if ( event
.Moving() )
5509 m_dragRowOrCol
= YToEdgeOfRow( y
);
5510 if ( m_dragRowOrCol
>= 0 )
5512 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5514 // don't capture the mouse yet
5515 if ( CanDragRowSize() )
5516 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
, false);
5519 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5521 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
, false);
5526 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent
& event
)
5529 wxPoint
pos( event
.GetPosition() );
5530 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5532 if ( event
.Dragging() )
5536 m_isDragging
= true;
5537 m_colLabelWin
->CaptureMouse();
5539 if ( m_cursorMode
== WXGRID_CURSOR_MOVE_COL
)
5540 m_dragRowOrCol
= XToCol( x
);
5543 if ( event
.LeftIsDown() )
5545 switch ( m_cursorMode
)
5547 case WXGRID_CURSOR_RESIZE_COL
:
5549 int cw
, ch
, dummy
, top
;
5550 m_gridWin
->GetClientSize( &cw
, &ch
);
5551 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
5553 wxClientDC
dc( m_gridWin
);
5556 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
5557 GetColMinimalWidth(m_dragRowOrCol
));
5558 dc
.SetLogicalFunction(wxINVERT
);
5559 if ( m_dragLastPos
>= 0 )
5561 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ ch
);
5563 dc
.DrawLine( x
, top
, x
, top
+ ch
);
5568 case WXGRID_CURSOR_SELECT_COL
:
5570 if ( (col
= XToCol( x
)) >= 0 )
5574 m_selection
->SelectCol( col
,
5575 event
.ControlDown(),
5584 case WXGRID_CURSOR_MOVE_COL
:
5587 m_moveToCol
= GetColAt( 0 );
5589 m_moveToCol
= XToCol( x
);
5593 if ( m_moveToCol
< 0 )
5594 markerX
= GetColRight( GetColAt( m_numCols
- 1 ) );
5596 markerX
= GetColLeft( m_moveToCol
);
5598 if ( markerX
!= m_dragLastPos
)
5600 wxClientDC
dc( m_colLabelWin
);
5603 m_colLabelWin
->GetClientSize( &cw
, &ch
);
5607 //Clean up the last indicator
5608 if ( m_dragLastPos
>= 0 )
5610 wxPen
pen( m_colLabelWin
->GetBackgroundColour(), 2 );
5612 dc
.DrawLine( m_dragLastPos
+ 1, 0, m_dragLastPos
+ 1, ch
);
5613 dc
.SetPen(wxNullPen
);
5615 if ( XToCol( m_dragLastPos
) != -1 )
5616 DrawColLabel( dc
, XToCol( m_dragLastPos
) );
5619 //Moving to the same place? Don't draw a marker
5620 if ( (m_moveToCol
== m_dragRowOrCol
)
5621 || (GetColPos( m_moveToCol
) == GetColPos( m_dragRowOrCol
) + 1)
5622 || (m_moveToCol
< 0 && m_dragRowOrCol
== GetColAt( m_numCols
- 1 )))
5629 wxPen
pen( *wxBLUE
, 2 );
5632 dc
.DrawLine( markerX
, 0, markerX
, ch
);
5634 dc
.SetPen(wxNullPen
);
5636 m_dragLastPos
= markerX
- 1;
5641 // default label to suppress warnings about "enumeration value
5642 // 'xxx' not handled in switch
5650 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
5655 if (m_colLabelWin
->HasCapture())
5656 m_colLabelWin
->ReleaseMouse();
5657 m_isDragging
= false;
5660 // ------------ Entering or leaving the window
5662 if ( event
.Entering() || event
.Leaving() )
5664 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5667 // ------------ Left button pressed
5669 else if ( event
.LeftDown() )
5671 // don't send a label click event for a hit on the
5672 // edge of the col label - this is probably the user
5673 // wanting to resize the col
5675 if ( XToEdgeOfCol(x
) < 0 )
5679 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, col
, event
) )
5681 if ( m_canDragColMove
)
5683 //Show button as pressed
5684 wxClientDC
dc( m_colLabelWin
);
5685 int colLeft
= GetColLeft( col
);
5686 int colRight
= GetColRight( col
) - 1;
5687 dc
.SetPen( wxPen( m_colLabelWin
->GetBackgroundColour(), 1 ) );
5688 dc
.DrawLine( colLeft
, 1, colLeft
, m_colLabelHeight
-1 );
5689 dc
.DrawLine( colLeft
, 1, colRight
, 1 );
5691 ChangeCursorMode(WXGRID_CURSOR_MOVE_COL
, m_colLabelWin
);
5695 if ( !event
.ShiftDown() && !event
.CmdDown() )
5699 if ( event
.ShiftDown() )
5701 m_selection
->SelectBlock( 0,
5702 m_currentCellCoords
.GetCol(),
5703 GetNumberRows() - 1, col
,
5704 event
.ControlDown(),
5711 m_selection
->SelectCol( col
,
5712 event
.ControlDown(),
5719 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL
, m_colLabelWin
);
5725 // starting to drag-resize a col
5727 if ( CanDragColSize() )
5728 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
);
5732 // ------------ Left double click
5734 if ( event
.LeftDClick() )
5736 col
= XToEdgeOfCol(x
);
5741 ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, col
, event
) )
5743 // no default action at the moment
5748 // adjust column width depending on label text
5749 AutoSizeColLabelSize( col
);
5751 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5756 // ------------ Left button released
5758 else if ( event
.LeftUp() )
5760 switch ( m_cursorMode
)
5762 case WXGRID_CURSOR_RESIZE_COL
:
5763 DoEndDragResizeCol();
5765 // Note: we are ending the event *after* doing
5766 // default processing in this case
5768 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
5771 case WXGRID_CURSOR_MOVE_COL
:
5774 SendEvent( wxEVT_GRID_COL_MOVE
, -1, m_dragRowOrCol
, event
);
5777 case WXGRID_CURSOR_SELECT_COL
:
5778 case WXGRID_CURSOR_SELECT_CELL
:
5779 case WXGRID_CURSOR_RESIZE_ROW
:
5780 case WXGRID_CURSOR_SELECT_ROW
:
5781 // nothing to do (?)
5785 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
);
5789 // ------------ Right button down
5791 else if ( event
.RightDown() )
5795 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, col
, event
) )
5797 // no default action at the moment
5801 // ------------ Right double click
5803 else if ( event
.RightDClick() )
5807 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, col
, event
) )
5809 // no default action at the moment
5813 // ------------ No buttons down and mouse moving
5815 else if ( event
.Moving() )
5817 m_dragRowOrCol
= XToEdgeOfCol( x
);
5818 if ( m_dragRowOrCol
>= 0 )
5820 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5822 // don't capture the cursor yet
5823 if ( CanDragColSize() )
5824 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, m_colLabelWin
, false);
5827 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
5829 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_colLabelWin
, false);
5834 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent
& event
)
5836 if ( event
.LeftDown() )
5838 // indicate corner label by having both row and
5841 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, -1, event
) )
5846 else if ( event
.LeftDClick() )
5848 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, -1, event
);
5850 else if ( event
.RightDown() )
5852 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, -1, event
) )
5854 // no default action at the moment
5857 else if ( event
.RightDClick() )
5859 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, -1, event
) )
5861 // no default action at the moment
5866 void wxGrid::CancelMouseCapture()
5868 // cancel operation currently in progress, whatever it is
5871 m_isDragging
= false;
5872 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
5873 m_winCapture
->SetCursor( *wxSTANDARD_CURSOR
);
5874 m_winCapture
= NULL
;
5876 // remove traces of whatever we drew on screen
5881 void wxGrid::ChangeCursorMode(CursorMode mode
,
5886 static const wxChar
*cursorModes
[] =
5896 wxLogTrace(_T("grid"),
5897 _T("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
5898 win
== m_colLabelWin
? _T("colLabelWin")
5899 : win
? _T("rowLabelWin")
5901 cursorModes
[m_cursorMode
], cursorModes
[mode
]);
5904 if ( mode
== m_cursorMode
&&
5905 win
== m_winCapture
&&
5906 captureMouse
== (m_winCapture
!= NULL
))
5911 // by default use the grid itself
5917 if (m_winCapture
->HasCapture())
5918 m_winCapture
->ReleaseMouse();
5919 m_winCapture
= (wxWindow
*)NULL
;
5922 m_cursorMode
= mode
;
5924 switch ( m_cursorMode
)
5926 case WXGRID_CURSOR_RESIZE_ROW
:
5927 win
->SetCursor( m_rowResizeCursor
);
5930 case WXGRID_CURSOR_RESIZE_COL
:
5931 win
->SetCursor( m_colResizeCursor
);
5934 case WXGRID_CURSOR_MOVE_COL
:
5935 win
->SetCursor( wxCursor(wxCURSOR_HAND
) );
5939 win
->SetCursor( *wxSTANDARD_CURSOR
);
5943 // we need to capture mouse when resizing
5944 bool resize
= m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
||
5945 m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
;
5947 if ( captureMouse
&& resize
)
5949 win
->CaptureMouse();
5954 void wxGrid::ProcessGridCellMouseEvent( wxMouseEvent
& event
)
5957 wxPoint
pos( event
.GetPosition() );
5958 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
5960 wxGridCellCoords coords
;
5961 XYToCell( x
, y
, coords
);
5963 int cell_rows
, cell_cols
;
5964 bool isFirstDrag
= !m_isDragging
;
5965 GetCellSize( coords
.GetRow(), coords
.GetCol(), &cell_rows
, &cell_cols
);
5966 if ((cell_rows
< 0) || (cell_cols
< 0))
5968 coords
.SetRow(coords
.GetRow() + cell_rows
);
5969 coords
.SetCol(coords
.GetCol() + cell_cols
);
5972 if ( event
.Dragging() )
5974 //wxLogDebug("pos(%d, %d) coords(%d, %d)", pos.x, pos.y, coords.GetRow(), coords.GetCol());
5976 // Don't start doing anything until the mouse has been dragged at
5977 // least 3 pixels in any direction...
5980 if (m_startDragPos
== wxDefaultPosition
)
5982 m_startDragPos
= pos
;
5985 if (abs(m_startDragPos
.x
- pos
.x
) < 4 && abs(m_startDragPos
.y
- pos
.y
) < 4)
5989 m_isDragging
= true;
5990 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
5992 // Hide the edit control, so it
5993 // won't interfere with drag-shrinking.
5994 if ( IsCellEditControlShown() )
5996 HideCellEditControl();
5997 SaveEditControlValue();
6000 if ( coords
!= wxGridNoCellCoords
)
6002 if ( event
.CmdDown() )
6004 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
6005 m_selectingKeyboard
= coords
;
6006 HighlightBlock( m_selectingKeyboard
, coords
);
6008 else if ( CanDragCell() )
6012 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
6013 m_selectingKeyboard
= coords
;
6015 SendEvent( wxEVT_GRID_CELL_BEGIN_DRAG
,
6024 if ( !IsSelection() )
6026 HighlightBlock( coords
, coords
);
6030 HighlightBlock( m_currentCellCoords
, coords
);
6034 if (! IsVisible(coords
))
6036 MakeCellVisible(coords
);
6037 // TODO: need to introduce a delay or something here. The
6038 // scrolling is way to fast, at least on MSW - also on GTK.
6041 // Have we captured the mouse yet?
6044 m_winCapture
= m_gridWin
;
6045 m_winCapture
->CaptureMouse();
6050 else if ( event
.LeftIsDown() &&
6051 m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
6053 int cw
, ch
, left
, dummy
;
6054 m_gridWin
->GetClientSize( &cw
, &ch
);
6055 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
6057 wxClientDC
dc( m_gridWin
);
6059 y
= wxMax( y
, GetRowTop(m_dragRowOrCol
) +
6060 GetRowMinimalHeight(m_dragRowOrCol
) );
6061 dc
.SetLogicalFunction(wxINVERT
);
6062 if ( m_dragLastPos
>= 0 )
6064 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
6066 dc
.DrawLine( left
, y
, left
+cw
, y
);
6069 else if ( event
.LeftIsDown() &&
6070 m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
6072 int cw
, ch
, dummy
, top
;
6073 m_gridWin
->GetClientSize( &cw
, &ch
);
6074 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
6076 wxClientDC
dc( m_gridWin
);
6078 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) +
6079 GetColMinimalWidth(m_dragRowOrCol
) );
6080 dc
.SetLogicalFunction(wxINVERT
);
6081 if ( m_dragLastPos
>= 0 )
6083 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ ch
);
6085 dc
.DrawLine( x
, top
, x
, top
+ ch
);
6092 m_isDragging
= false;
6093 m_startDragPos
= wxDefaultPosition
;
6095 // VZ: if we do this, the mode is reset to WXGRID_CURSOR_SELECT_CELL
6096 // immediately after it becomes WXGRID_CURSOR_RESIZE_ROW/COL under
6099 if ( event
.Entering() || event
.Leaving() )
6101 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6102 m_gridWin
->SetCursor( *wxSTANDARD_CURSOR
);
6107 // ------------ Left button pressed
6109 if ( event
.LeftDown() && coords
!= wxGridNoCellCoords
)
6111 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_CLICK
,
6116 if ( !event
.CmdDown() )
6118 if ( event
.ShiftDown() )
6122 m_selection
->SelectBlock( m_currentCellCoords
.GetRow(),
6123 m_currentCellCoords
.GetCol(),
6126 event
.ControlDown(),
6132 else if ( XToEdgeOfCol(x
) < 0 &&
6133 YToEdgeOfRow(y
) < 0 )
6135 DisableCellEditControl();
6136 MakeCellVisible( coords
);
6138 if ( event
.CmdDown() )
6142 m_selection
->ToggleCellSelection( coords
.GetRow(),
6144 event
.ControlDown(),
6149 m_selectingTopLeft
= wxGridNoCellCoords
;
6150 m_selectingBottomRight
= wxGridNoCellCoords
;
6151 m_selectingKeyboard
= coords
;
6155 m_waitForSlowClick
= m_currentCellCoords
== coords
&& coords
!= wxGridNoCellCoords
;
6156 SetCurrentCell( coords
);
6159 if ( m_selection
->GetSelectionMode() !=
6160 wxGrid::wxGridSelectCells
)
6162 HighlightBlock( coords
, coords
);
6170 // ------------ Left double click
6172 else if ( event
.LeftDClick() && coords
!= wxGridNoCellCoords
)
6174 DisableCellEditControl();
6176 if ( XToEdgeOfCol(x
) < 0 && YToEdgeOfRow(y
) < 0 )
6178 if ( !SendEvent( wxEVT_GRID_CELL_LEFT_DCLICK
,
6183 // we want double click to select a cell and start editing
6184 // (i.e. to behave in same way as sequence of two slow clicks):
6185 m_waitForSlowClick
= true;
6190 // ------------ Left button released
6192 else if ( event
.LeftUp() )
6194 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
6198 if (m_winCapture
->HasCapture())
6199 m_winCapture
->ReleaseMouse();
6200 m_winCapture
= NULL
;
6203 if ( coords
== m_currentCellCoords
&& m_waitForSlowClick
&& CanEnableCellControl() )
6206 EnableCellEditControl();
6208 wxGridCellAttr
*attr
= GetCellAttr(coords
);
6209 wxGridCellEditor
*editor
= attr
->GetEditor(this, coords
.GetRow(), coords
.GetCol());
6210 editor
->StartingClick();
6214 m_waitForSlowClick
= false;
6216 else if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
6217 m_selectingBottomRight
!= wxGridNoCellCoords
)
6221 m_selection
->SelectBlock( m_selectingTopLeft
.GetRow(),
6222 m_selectingTopLeft
.GetCol(),
6223 m_selectingBottomRight
.GetRow(),
6224 m_selectingBottomRight
.GetCol(),
6225 event
.ControlDown(),
6231 m_selectingTopLeft
= wxGridNoCellCoords
;
6232 m_selectingBottomRight
= wxGridNoCellCoords
;
6234 // Show the edit control, if it has been hidden for
6236 ShowCellEditControl();
6239 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
6241 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6242 DoEndDragResizeRow();
6244 // Note: we are ending the event *after* doing
6245 // default processing in this case
6247 SendEvent( wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
6249 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
6251 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6252 DoEndDragResizeCol();
6254 // Note: we are ending the event *after* doing
6255 // default processing in this case
6257 SendEvent( wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
6263 // ------------ Right button down
6265 else if ( event
.RightDown() && coords
!= wxGridNoCellCoords
)
6267 DisableCellEditControl();
6268 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_CLICK
,
6273 // no default action at the moment
6277 // ------------ Right double click
6279 else if ( event
.RightDClick() && coords
!= wxGridNoCellCoords
)
6281 DisableCellEditControl();
6282 if ( !SendEvent( wxEVT_GRID_CELL_RIGHT_DCLICK
,
6287 // no default action at the moment
6291 // ------------ Moving and no button action
6293 else if ( event
.Moving() && !event
.IsButton() )
6295 if ( coords
.GetRow() < 0 || coords
.GetCol() < 0 )
6297 // out of grid cell area
6298 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6302 int dragRow
= YToEdgeOfRow( y
);
6303 int dragCol
= XToEdgeOfCol( x
);
6305 // Dragging on the corner of a cell to resize in both
6306 // directions is not implemented yet...
6308 if ( dragRow
>= 0 && dragCol
>= 0 )
6310 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6316 m_dragRowOrCol
= dragRow
;
6318 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
6320 if ( CanDragRowSize() && CanDragGridSize() )
6321 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, NULL
, false);
6324 else if ( dragCol
>= 0 )
6326 m_dragRowOrCol
= dragCol
;
6328 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
6330 if ( CanDragColSize() && CanDragGridSize() )
6331 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, NULL
, false);
6334 else // Neither on a row or col edge
6336 if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
6338 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
6344 void wxGrid::DoEndDragResizeRow()
6346 if ( m_dragLastPos
>= 0 )
6348 // erase the last line and resize the row
6350 int cw
, ch
, left
, dummy
;
6351 m_gridWin
->GetClientSize( &cw
, &ch
);
6352 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
6354 wxClientDC
dc( m_gridWin
);
6356 dc
.SetLogicalFunction( wxINVERT
);
6357 dc
.DrawLine( left
, m_dragLastPos
, left
+ cw
, m_dragLastPos
);
6358 HideCellEditControl();
6359 SaveEditControlValue();
6361 int rowTop
= GetRowTop(m_dragRowOrCol
);
6362 SetRowSize( m_dragRowOrCol
,
6363 wxMax( m_dragLastPos
- rowTop
, m_minAcceptableRowHeight
) );
6365 if ( !GetBatchCount() )
6367 // Only needed to get the correct rect.y:
6368 wxRect
rect ( CellToRect( m_dragRowOrCol
, 0 ) );
6370 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
6371 rect
.width
= m_rowLabelWidth
;
6372 rect
.height
= ch
- rect
.y
;
6373 m_rowLabelWin
->Refresh( true, &rect
);
6376 // if there is a multicell block, paint all of it
6379 int i
, cell_rows
, cell_cols
, subtract_rows
= 0;
6380 int leftCol
= XToCol(left
);
6381 int rightCol
= internalXToCol(left
+ cw
);
6384 for (i
=leftCol
; i
<rightCol
; i
++)
6386 GetCellSize(m_dragRowOrCol
, i
, &cell_rows
, &cell_cols
);
6387 if (cell_rows
< subtract_rows
)
6388 subtract_rows
= cell_rows
;
6390 rect
.y
= GetRowTop(m_dragRowOrCol
+ subtract_rows
);
6391 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
6392 rect
.height
= ch
- rect
.y
;
6395 m_gridWin
->Refresh( false, &rect
);
6398 ShowCellEditControl();
6403 void wxGrid::DoEndDragResizeCol()
6405 if ( m_dragLastPos
>= 0 )
6407 // erase the last line and resize the col
6409 int cw
, ch
, dummy
, top
;
6410 m_gridWin
->GetClientSize( &cw
, &ch
);
6411 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
6413 wxClientDC
dc( m_gridWin
);
6415 dc
.SetLogicalFunction( wxINVERT
);
6416 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ ch
);
6417 HideCellEditControl();
6418 SaveEditControlValue();
6420 int colLeft
= GetColLeft(m_dragRowOrCol
);
6421 SetColSize( m_dragRowOrCol
,
6422 wxMax( m_dragLastPos
- colLeft
,
6423 GetColMinimalWidth(m_dragRowOrCol
) ) );
6425 if ( !GetBatchCount() )
6427 // Only needed to get the correct rect.x:
6428 wxRect
rect ( CellToRect( 0, m_dragRowOrCol
) );
6430 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
6431 rect
.width
= cw
- rect
.x
;
6432 rect
.height
= m_colLabelHeight
;
6433 m_colLabelWin
->Refresh( true, &rect
);
6436 // if there is a multicell block, paint all of it
6439 int i
, cell_rows
, cell_cols
, subtract_cols
= 0;
6440 int topRow
= YToRow(top
);
6441 int bottomRow
= internalYToRow(top
+ cw
);
6444 for (i
=topRow
; i
<bottomRow
; i
++)
6446 GetCellSize(i
, m_dragRowOrCol
, &cell_rows
, &cell_cols
);
6447 if (cell_cols
< subtract_cols
)
6448 subtract_cols
= cell_cols
;
6451 rect
.x
= GetColLeft(m_dragRowOrCol
+ subtract_cols
);
6452 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
6453 rect
.width
= cw
- rect
.x
;
6457 m_gridWin
->Refresh( false, &rect
);
6460 ShowCellEditControl();
6464 void wxGrid::DoEndDragMoveCol()
6466 //The user clicked on the column but didn't actually drag
6467 if ( m_dragLastPos
< 0 )
6469 m_colLabelWin
->Refresh(); //Do this to "unpress" the column
6474 if ( m_moveToCol
== -1 )
6475 newPos
= m_numCols
- 1;
6478 newPos
= GetColPos( m_moveToCol
);
6479 if ( newPos
> GetColPos( m_dragRowOrCol
) )
6483 SetColPos( m_dragRowOrCol
, newPos
);
6486 void wxGrid::SetColPos( int colID
, int newPos
)
6488 if ( m_colAt
.IsEmpty() )
6490 m_colAt
.Alloc( m_numCols
);
6493 for ( i
= 0; i
< m_numCols
; i
++ )
6499 int oldPos
= GetColPos( colID
);
6501 //Reshuffle the m_colAt array
6502 if ( newPos
> oldPos
)
6505 for ( i
= oldPos
; i
< newPos
; i
++ )
6507 m_colAt
[i
] = m_colAt
[i
+1];
6513 for ( i
= oldPos
; i
> newPos
; i
-- )
6515 m_colAt
[i
] = m_colAt
[i
-1];
6519 m_colAt
[newPos
] = colID
;
6521 //Recalculate the column rights
6522 if ( !m_colWidths
.IsEmpty() )
6526 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
6528 int colID
= GetColAt( colPos
);
6530 colRight
+= m_colWidths
[colID
];
6531 m_colRights
[colID
] = colRight
;
6535 m_colLabelWin
->Refresh();
6536 m_gridWin
->Refresh();
6541 void wxGrid::EnableDragColMove( bool enable
)
6543 if ( m_canDragColMove
== enable
)
6546 m_canDragColMove
= enable
;
6548 if ( !m_canDragColMove
)
6552 //Recalculate the column rights
6553 if ( !m_colWidths
.IsEmpty() )
6557 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
6559 colRight
+= m_colWidths
[colPos
];
6560 m_colRights
[colPos
] = colRight
;
6564 m_colLabelWin
->Refresh();
6565 m_gridWin
->Refresh();
6571 // ------ interaction with data model
6573 bool wxGrid::ProcessTableMessage( wxGridTableMessage
& msg
)
6575 switch ( msg
.GetId() )
6577 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES
:
6578 return GetModelValues();
6580 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES
:
6581 return SetModelValues();
6583 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
6584 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
6585 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
6586 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
6587 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
6588 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
6589 return Redimension( msg
);
6596 // The behaviour of this function depends on the grid table class
6597 // Clear() function. For the default wxGridStringTable class the
6598 // behavious is to replace all cell contents with wxEmptyString but
6599 // not to change the number of rows or cols.
6601 void wxGrid::ClearGrid()
6605 if (IsCellEditControlEnabled())
6606 DisableCellEditControl();
6609 if (!GetBatchCount())
6610 m_gridWin
->Refresh();
6614 bool wxGrid::InsertRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
6616 // TODO: something with updateLabels flag
6620 wxFAIL_MSG( wxT("Called wxGrid::InsertRows() before calling CreateGrid()") );
6626 if (IsCellEditControlEnabled())
6627 DisableCellEditControl();
6629 bool done
= m_table
->InsertRows( pos
, numRows
);
6632 // the table will have sent the results of the insert row
6633 // operation to this view object as a grid table message
6639 bool wxGrid::AppendRows( int numRows
, bool WXUNUSED(updateLabels
) )
6641 // TODO: something with updateLabels flag
6645 wxFAIL_MSG( wxT("Called wxGrid::AppendRows() before calling CreateGrid()") );
6651 bool done
= m_table
&& m_table
->AppendRows( numRows
);
6654 // the table will have sent the results of the append row
6655 // operation to this view object as a grid table message
6661 bool wxGrid::DeleteRows( int pos
, int numRows
, bool WXUNUSED(updateLabels
) )
6663 // TODO: something with updateLabels flag
6667 wxFAIL_MSG( wxT("Called wxGrid::DeleteRows() before calling CreateGrid()") );
6673 if (IsCellEditControlEnabled())
6674 DisableCellEditControl();
6676 bool done
= m_table
->DeleteRows( pos
, numRows
);
6678 // the table will have sent the results of the delete row
6679 // operation to this view object as a grid table message
6685 bool wxGrid::InsertCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
6687 // TODO: something with updateLabels flag
6691 wxFAIL_MSG( wxT("Called wxGrid::InsertCols() before calling CreateGrid()") );
6697 if (IsCellEditControlEnabled())
6698 DisableCellEditControl();
6700 bool done
= m_table
->InsertCols( pos
, numCols
);
6702 // the table will have sent the results of the insert col
6703 // operation to this view object as a grid table message
6709 bool wxGrid::AppendCols( int numCols
, bool WXUNUSED(updateLabels
) )
6711 // TODO: something with updateLabels flag
6715 wxFAIL_MSG( wxT("Called wxGrid::AppendCols() before calling CreateGrid()") );
6721 bool done
= m_table
->AppendCols( numCols
);
6723 // the table will have sent the results of the append col
6724 // operation to this view object as a grid table message
6730 bool wxGrid::DeleteCols( int pos
, int numCols
, bool WXUNUSED(updateLabels
) )
6732 // TODO: something with updateLabels flag
6736 wxFAIL_MSG( wxT("Called wxGrid::DeleteCols() before calling CreateGrid()") );
6742 if (IsCellEditControlEnabled())
6743 DisableCellEditControl();
6745 bool done
= m_table
->DeleteCols( pos
, numCols
);
6747 // the table will have sent the results of the delete col
6748 // operation to this view object as a grid table message
6755 // ----- event handlers
6758 // Generate a grid event based on a mouse event and
6759 // return the result of ProcessEvent()
6761 int wxGrid::SendEvent( const wxEventType type
,
6763 wxMouseEvent
& mouseEv
)
6765 bool claimed
, vetoed
;
6767 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
6769 int rowOrCol
= (row
== -1 ? col
: row
);
6771 wxGridSizeEvent
gridEvt( GetId(),
6775 mouseEv
.GetX() + GetRowLabelSize(),
6776 mouseEv
.GetY() + GetColLabelSize(),
6777 mouseEv
.ControlDown(),
6778 mouseEv
.ShiftDown(),
6780 mouseEv
.MetaDown() );
6782 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6783 vetoed
= !gridEvt
.IsAllowed();
6785 else if ( type
== wxEVT_GRID_RANGE_SELECT
)
6787 // Right now, it should _never_ end up here!
6788 wxGridRangeSelectEvent
gridEvt( GetId(),
6792 m_selectingBottomRight
,
6794 mouseEv
.ControlDown(),
6795 mouseEv
.ShiftDown(),
6797 mouseEv
.MetaDown() );
6799 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6800 vetoed
= !gridEvt
.IsAllowed();
6802 else if ( type
== wxEVT_GRID_LABEL_LEFT_CLICK
||
6803 type
== wxEVT_GRID_LABEL_LEFT_DCLICK
||
6804 type
== wxEVT_GRID_LABEL_RIGHT_CLICK
||
6805 type
== wxEVT_GRID_LABEL_RIGHT_DCLICK
)
6807 wxPoint pos
= mouseEv
.GetPosition();
6809 if ( mouseEv
.GetEventObject() == GetGridRowLabelWindow() )
6810 pos
.y
+= GetColLabelSize();
6811 if ( mouseEv
.GetEventObject() == GetGridColLabelWindow() )
6812 pos
.x
+= GetRowLabelSize();
6814 wxGridEvent
gridEvt( GetId(),
6821 mouseEv
.ControlDown(),
6822 mouseEv
.ShiftDown(),
6824 mouseEv
.MetaDown() );
6825 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6826 vetoed
= !gridEvt
.IsAllowed();
6830 wxGridEvent
gridEvt( GetId(),
6834 mouseEv
.GetX() + GetRowLabelSize(),
6835 mouseEv
.GetY() + GetColLabelSize(),
6837 mouseEv
.ControlDown(),
6838 mouseEv
.ShiftDown(),
6840 mouseEv
.MetaDown() );
6841 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6842 vetoed
= !gridEvt
.IsAllowed();
6845 // A Veto'd event may not be `claimed' so test this first
6849 return claimed
? 1 : 0;
6852 // Generate a grid event of specified type and return the result
6853 // of ProcessEvent().
6855 int wxGrid::SendEvent( const wxEventType type
,
6858 bool claimed
, vetoed
;
6860 if ( type
== wxEVT_GRID_ROW_SIZE
|| type
== wxEVT_GRID_COL_SIZE
)
6862 int rowOrCol
= (row
== -1 ? col
: row
);
6864 wxGridSizeEvent
gridEvt( GetId(), type
, this, rowOrCol
);
6866 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6867 vetoed
= !gridEvt
.IsAllowed();
6871 wxGridEvent
gridEvt( GetId(), type
, this, row
, col
);
6873 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
6874 vetoed
= !gridEvt
.IsAllowed();
6877 // A Veto'd event may not be `claimed' so test this first
6881 return claimed
? 1 : 0;
6884 void wxGrid::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
6886 // needed to prevent zillions of paint events on MSW
6890 void wxGrid::Refresh(bool eraseb
, const wxRect
* rect
)
6892 // Don't do anything if between Begin/EndBatch...
6893 // EndBatch() will do all this on the last nested one anyway.
6894 if ( m_created
&& !GetBatchCount() )
6896 // Refresh to get correct scrolled position:
6897 wxScrolledWindow::Refresh(eraseb
, rect
);
6901 int rect_x
, rect_y
, rectWidth
, rectHeight
;
6902 int width_label
, width_cell
, height_label
, height_cell
;
6905 // Copy rectangle can get scroll offsets..
6906 rect_x
= rect
->GetX();
6907 rect_y
= rect
->GetY();
6908 rectWidth
= rect
->GetWidth();
6909 rectHeight
= rect
->GetHeight();
6911 width_label
= m_rowLabelWidth
- rect_x
;
6912 if (width_label
> rectWidth
)
6913 width_label
= rectWidth
;
6915 height_label
= m_colLabelHeight
- rect_y
;
6916 if (height_label
> rectHeight
)
6917 height_label
= rectHeight
;
6919 if (rect_x
> m_rowLabelWidth
)
6921 x
= rect_x
- m_rowLabelWidth
;
6922 width_cell
= rectWidth
;
6927 width_cell
= rectWidth
- (m_rowLabelWidth
- rect_x
);
6930 if (rect_y
> m_colLabelHeight
)
6932 y
= rect_y
- m_colLabelHeight
;
6933 height_cell
= rectHeight
;
6938 height_cell
= rectHeight
- (m_colLabelHeight
- rect_y
);
6941 // Paint corner label part intersecting rect.
6942 if ( width_label
> 0 && height_label
> 0 )
6944 wxRect
anotherrect(rect_x
, rect_y
, width_label
, height_label
);
6945 m_cornerLabelWin
->Refresh(eraseb
, &anotherrect
);
6948 // Paint col labels part intersecting rect.
6949 if ( width_cell
> 0 && height_label
> 0 )
6951 wxRect
anotherrect(x
, rect_y
, width_cell
, height_label
);
6952 m_colLabelWin
->Refresh(eraseb
, &anotherrect
);
6955 // Paint row labels part intersecting rect.
6956 if ( width_label
> 0 && height_cell
> 0 )
6958 wxRect
anotherrect(rect_x
, y
, width_label
, height_cell
);
6959 m_rowLabelWin
->Refresh(eraseb
, &anotherrect
);
6962 // Paint cell area part intersecting rect.
6963 if ( width_cell
> 0 && height_cell
> 0 )
6965 wxRect
anotherrect(x
, y
, width_cell
, height_cell
);
6966 m_gridWin
->Refresh(eraseb
, &anotherrect
);
6971 m_cornerLabelWin
->Refresh(eraseb
, NULL
);
6972 m_colLabelWin
->Refresh(eraseb
, NULL
);
6973 m_rowLabelWin
->Refresh(eraseb
, NULL
);
6974 m_gridWin
->Refresh(eraseb
, NULL
);
6979 void wxGrid::OnSize(wxSizeEvent
& WXUNUSED(event
))
6981 if (m_targetWindow
!= this) // check whether initialisation has been done
6983 // update our children window positions and scrollbars
6988 void wxGrid::OnKeyDown( wxKeyEvent
& event
)
6990 if ( m_inOnKeyDown
)
6992 // shouldn't be here - we are going round in circles...
6994 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
6997 m_inOnKeyDown
= true;
6999 // propagate the event up and see if it gets processed
7000 wxWindow
*parent
= GetParent();
7001 wxKeyEvent
keyEvt( event
);
7002 keyEvt
.SetEventObject( parent
);
7004 if ( !parent
->GetEventHandler()->ProcessEvent( keyEvt
) )
7006 if (GetLayoutDirection() == wxLayout_RightToLeft
)
7008 if (event
.GetKeyCode() == WXK_RIGHT
)
7009 event
.m_keyCode
= WXK_LEFT
;
7010 else if (event
.GetKeyCode() == WXK_LEFT
)
7011 event
.m_keyCode
= WXK_RIGHT
;
7014 // try local handlers
7015 switch ( event
.GetKeyCode() )
7018 if ( event
.ControlDown() )
7019 MoveCursorUpBlock( event
.ShiftDown() );
7021 MoveCursorUp( event
.ShiftDown() );
7025 if ( event
.ControlDown() )
7026 MoveCursorDownBlock( event
.ShiftDown() );
7028 MoveCursorDown( event
.ShiftDown() );
7032 if ( event
.ControlDown() )
7033 MoveCursorLeftBlock( event
.ShiftDown() );
7035 MoveCursorLeft( event
.ShiftDown() );
7039 if ( event
.ControlDown() )
7040 MoveCursorRightBlock( event
.ShiftDown() );
7042 MoveCursorRight( event
.ShiftDown() );
7046 case WXK_NUMPAD_ENTER
:
7047 if ( event
.ControlDown() )
7049 event
.Skip(); // to let the edit control have the return
7053 if ( GetGridCursorRow() < GetNumberRows()-1 )
7055 MoveCursorDown( event
.ShiftDown() );
7059 // at the bottom of a column
7060 DisableCellEditControl();
7070 if (event
.ShiftDown())
7072 if ( GetGridCursorCol() > 0 )
7074 MoveCursorLeft( false );
7079 DisableCellEditControl();
7084 if ( GetGridCursorCol() < GetNumberCols() - 1 )
7086 MoveCursorRight( false );
7091 DisableCellEditControl();
7097 if ( event
.ControlDown() )
7099 MakeCellVisible( 0, 0 );
7100 SetCurrentCell( 0, 0 );
7109 if ( event
.ControlDown() )
7111 MakeCellVisible( m_numRows
- 1, m_numCols
- 1 );
7112 SetCurrentCell( m_numRows
- 1, m_numCols
- 1 );
7129 if ( event
.ControlDown() )
7133 m_selection
->ToggleCellSelection(
7134 m_currentCellCoords
.GetRow(),
7135 m_currentCellCoords
.GetCol(),
7136 event
.ControlDown(),
7144 if ( !IsEditable() )
7145 MoveCursorRight( false );
7156 m_inOnKeyDown
= false;
7159 void wxGrid::OnKeyUp( wxKeyEvent
& event
)
7161 // try local handlers
7163 if ( event
.GetKeyCode() == WXK_SHIFT
)
7165 if ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
7166 m_selectingBottomRight
!= wxGridNoCellCoords
)
7170 m_selection
->SelectBlock(
7171 m_selectingTopLeft
.GetRow(),
7172 m_selectingTopLeft
.GetCol(),
7173 m_selectingBottomRight
.GetRow(),
7174 m_selectingBottomRight
.GetCol(),
7175 event
.ControlDown(),
7182 m_selectingTopLeft
= wxGridNoCellCoords
;
7183 m_selectingBottomRight
= wxGridNoCellCoords
;
7184 m_selectingKeyboard
= wxGridNoCellCoords
;
7188 void wxGrid::OnChar( wxKeyEvent
& event
)
7190 // is it possible to edit the current cell at all?
7191 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
7193 // yes, now check whether the cells editor accepts the key
7194 int row
= m_currentCellCoords
.GetRow();
7195 int col
= m_currentCellCoords
.GetCol();
7196 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7197 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
7199 // <F2> is special and will always start editing, for
7200 // other keys - ask the editor itself
7201 if ( (event
.GetKeyCode() == WXK_F2
&& !event
.HasModifiers())
7202 || editor
->IsAcceptedKey(event
) )
7204 // ensure cell is visble
7205 MakeCellVisible(row
, col
);
7206 EnableCellEditControl();
7208 // a problem can arise if the cell is not completely
7209 // visible (even after calling MakeCellVisible the
7210 // control is not created and calling StartingKey will
7212 if ( event
.GetKeyCode() != WXK_F2
&& editor
->IsCreated() && m_cellEditCtrlEnabled
)
7213 editor
->StartingKey(event
);
7229 void wxGrid::OnEraseBackground(wxEraseEvent
&)
7233 void wxGrid::SetCurrentCell( const wxGridCellCoords
& coords
)
7235 if ( SendEvent( wxEVT_GRID_SELECT_CELL
, coords
.GetRow(), coords
.GetCol() ) )
7237 // the event has been intercepted - do nothing
7241 #if !defined(__WXMAC__)
7242 wxClientDC
dc( m_gridWin
);
7246 if ( m_currentCellCoords
!= wxGridNoCellCoords
)
7248 DisableCellEditControl();
7250 if ( IsVisible( m_currentCellCoords
, false ) )
7253 r
= BlockToDeviceRect( m_currentCellCoords
, m_currentCellCoords
);
7254 if ( !m_gridLinesEnabled
)
7262 wxGridCellCoordsArray cells
= CalcCellsExposed( r
);
7264 // Otherwise refresh redraws the highlight!
7265 m_currentCellCoords
= coords
;
7267 #if defined(__WXMAC__)
7268 m_gridWin
->Refresh(true /*, & r */);
7270 DrawGridCellArea( dc
, cells
);
7271 DrawAllGridLines( dc
, r
);
7276 m_currentCellCoords
= coords
;
7278 wxGridCellAttr
*attr
= GetCellAttr( coords
);
7279 #if !defined(__WXMAC__)
7280 DrawCellHighlight( dc
, attr
);
7285 void wxGrid::HighlightBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
)
7288 wxGridCellCoords updateTopLeft
, updateBottomRight
;
7292 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
7295 rightCol
= GetNumberCols() - 1;
7297 else if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
7300 bottomRow
= GetNumberRows() - 1;
7304 if ( topRow
> bottomRow
)
7311 if ( leftCol
> rightCol
)
7318 updateTopLeft
= wxGridCellCoords( topRow
, leftCol
);
7319 updateBottomRight
= wxGridCellCoords( bottomRow
, rightCol
);
7321 // First the case that we selected a completely new area
7322 if ( m_selectingTopLeft
== wxGridNoCellCoords
||
7323 m_selectingBottomRight
== wxGridNoCellCoords
)
7326 rect
= BlockToDeviceRect( wxGridCellCoords ( topRow
, leftCol
),
7327 wxGridCellCoords ( bottomRow
, rightCol
) );
7328 m_gridWin
->Refresh( false, &rect
);
7331 // Now handle changing an existing selection area.
7332 else if ( m_selectingTopLeft
!= updateTopLeft
||
7333 m_selectingBottomRight
!= updateBottomRight
)
7335 // Compute two optimal update rectangles:
7336 // Either one rectangle is a real subset of the
7337 // other, or they are (almost) disjoint!
7339 bool need_refresh
[4];
7343 need_refresh
[3] = false;
7346 // Store intermediate values
7347 wxCoord oldLeft
= m_selectingTopLeft
.GetCol();
7348 wxCoord oldTop
= m_selectingTopLeft
.GetRow();
7349 wxCoord oldRight
= m_selectingBottomRight
.GetCol();
7350 wxCoord oldBottom
= m_selectingBottomRight
.GetRow();
7352 // Determine the outer/inner coordinates.
7353 if (oldLeft
> leftCol
)
7359 if (oldTop
> topRow
)
7365 if (oldRight
< rightCol
)
7368 oldRight
= rightCol
;
7371 if (oldBottom
< bottomRow
)
7374 oldBottom
= bottomRow
;
7378 // Now, either the stuff marked old is the outer
7379 // rectangle or we don't have a situation where one
7380 // is contained in the other.
7382 if ( oldLeft
< leftCol
)
7384 // Refresh the newly selected or deselected
7385 // area to the left of the old or new selection.
7386 need_refresh
[0] = true;
7387 rect
[0] = BlockToDeviceRect(
7388 wxGridCellCoords( oldTop
, oldLeft
),
7389 wxGridCellCoords( oldBottom
, leftCol
- 1 ) );
7392 if ( oldTop
< topRow
)
7394 // Refresh the newly selected or deselected
7395 // area above the old or new selection.
7396 need_refresh
[1] = true;
7397 rect
[1] = BlockToDeviceRect(
7398 wxGridCellCoords( oldTop
, leftCol
),
7399 wxGridCellCoords( topRow
- 1, rightCol
) );
7402 if ( oldRight
> rightCol
)
7404 // Refresh the newly selected or deselected
7405 // area to the right of the old or new selection.
7406 need_refresh
[2] = true;
7407 rect
[2] = BlockToDeviceRect(
7408 wxGridCellCoords( oldTop
, rightCol
+ 1 ),
7409 wxGridCellCoords( oldBottom
, oldRight
) );
7412 if ( oldBottom
> bottomRow
)
7414 // Refresh the newly selected or deselected
7415 // area below the old or new selection.
7416 need_refresh
[3] = true;
7417 rect
[3] = BlockToDeviceRect(
7418 wxGridCellCoords( bottomRow
+ 1, leftCol
),
7419 wxGridCellCoords( oldBottom
, rightCol
) );
7422 // various Refresh() calls
7423 for (i
= 0; i
< 4; i
++ )
7424 if ( need_refresh
[i
] && rect
[i
] != wxGridNoCellRect
)
7425 m_gridWin
->Refresh( false, &(rect
[i
]) );
7429 m_selectingTopLeft
= updateTopLeft
;
7430 m_selectingBottomRight
= updateBottomRight
;
7434 // ------ functions to get/send data (see also public functions)
7437 bool wxGrid::GetModelValues()
7439 // Hide the editor, so it won't hide a changed value.
7440 HideCellEditControl();
7444 // all we need to do is repaint the grid
7446 m_gridWin
->Refresh();
7453 bool wxGrid::SetModelValues()
7457 // Disable the editor, so it won't hide a changed value.
7458 // Do we also want to save the current value of the editor first?
7460 DisableCellEditControl();
7464 for ( row
= 0; row
< m_numRows
; row
++ )
7466 for ( col
= 0; col
< m_numCols
; col
++ )
7468 m_table
->SetValue( row
, col
, GetCellValue(row
, col
) );
7478 // Note - this function only draws cells that are in the list of
7479 // exposed cells (usually set from the update region by
7480 // CalcExposedCells)
7482 void wxGrid::DrawGridCellArea( wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
7484 if ( !m_numRows
|| !m_numCols
)
7487 int i
, numCells
= cells
.GetCount();
7488 int row
, col
, cell_rows
, cell_cols
;
7489 wxGridCellCoordsArray redrawCells
;
7491 for ( i
= numCells
- 1; i
>= 0; i
-- )
7493 row
= cells
[i
].GetRow();
7494 col
= cells
[i
].GetCol();
7495 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
7497 // If this cell is part of a multicell block, find owner for repaint
7498 if ( cell_rows
<= 0 || cell_cols
<= 0 )
7500 wxGridCellCoords
cell( row
+ cell_rows
, col
+ cell_cols
);
7501 bool marked
= false;
7502 for ( int j
= 0; j
< numCells
; j
++ )
7504 if ( cell
== cells
[j
] )
7513 int count
= redrawCells
.GetCount();
7514 for (int j
= 0; j
< count
; j
++)
7516 if ( cell
== redrawCells
[j
] )
7524 redrawCells
.Add( cell
);
7527 // don't bother drawing this cell
7531 // If this cell is empty, find cell to left that might want to overflow
7532 if (m_table
&& m_table
->IsEmptyCell(row
, col
))
7534 for ( int l
= 0; l
< cell_rows
; l
++ )
7536 // find a cell in this row to leave already marked for repaint
7538 for (int k
= 0; k
< int(redrawCells
.GetCount()); k
++)
7539 if ((redrawCells
[k
].GetCol() < left
) &&
7540 (redrawCells
[k
].GetRow() == row
))
7542 left
= redrawCells
[k
].GetCol();
7546 left
= 0; // oh well
7548 for (int j
= col
- 1; j
>= left
; j
--)
7550 if (!m_table
->IsEmptyCell(row
+ l
, j
))
7552 if (GetCellOverflow(row
+ l
, j
))
7554 wxGridCellCoords
cell(row
+ l
, j
);
7555 bool marked
= false;
7557 for (int k
= 0; k
< numCells
; k
++)
7559 if ( cell
== cells
[k
] )
7568 int count
= redrawCells
.GetCount();
7569 for (int k
= 0; k
< count
; k
++)
7571 if ( cell
== redrawCells
[k
] )
7578 redrawCells
.Add( cell
);
7587 DrawCell( dc
, cells
[i
] );
7590 numCells
= redrawCells
.GetCount();
7592 for ( i
= numCells
- 1; i
>= 0; i
-- )
7594 DrawCell( dc
, redrawCells
[i
] );
7598 void wxGrid::DrawGridSpace( wxDC
& dc
)
7601 m_gridWin
->GetClientSize( &cw
, &ch
);
7604 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
7606 int rightCol
= m_numCols
> 0 ? GetColRight(GetColAt( m_numCols
- 1 )) : 0;
7607 int bottomRow
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0;
7609 if ( right
> rightCol
|| bottom
> bottomRow
)
7612 CalcUnscrolledPosition( 0, 0, &left
, &top
);
7614 dc
.SetBrush( wxBrush(GetDefaultCellBackgroundColour(), wxBRUSHSTYLE_SOLID
) );
7615 dc
.SetPen( *wxTRANSPARENT_PEN
);
7617 if ( right
> rightCol
)
7619 dc
.DrawRectangle( rightCol
, top
, right
- rightCol
, ch
);
7622 if ( bottom
> bottomRow
)
7624 dc
.DrawRectangle( left
, bottomRow
, cw
, bottom
- bottomRow
);
7629 void wxGrid::DrawCell( wxDC
& dc
, const wxGridCellCoords
& coords
)
7631 int row
= coords
.GetRow();
7632 int col
= coords
.GetCol();
7634 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7637 // we draw the cell border ourselves
7638 #if !WXGRID_DRAW_LINES
7639 if ( m_gridLinesEnabled
)
7640 DrawCellBorder( dc
, coords
);
7643 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7645 bool isCurrent
= coords
== m_currentCellCoords
;
7647 wxRect rect
= CellToRect( row
, col
);
7649 // if the editor is shown, we should use it and not the renderer
7650 // Note: However, only if it is really _shown_, i.e. not hidden!
7651 if ( isCurrent
&& IsCellEditControlShown() )
7653 // NB: this "#if..." is temporary and fixes a problem where the
7654 // edit control is erased by this code after being rendered.
7655 // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
7656 // implicitly, causing this out-of order render.
7657 #if !defined(__WXMAC__)
7658 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
7659 editor
->PaintBackground(rect
, attr
);
7665 // but all the rest is drawn by the cell renderer and hence may be customized
7666 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
7667 renderer
->Draw(*this, *attr
, dc
, rect
, row
, col
, IsInSelection(coords
));
7674 void wxGrid::DrawCellHighlight( wxDC
& dc
, const wxGridCellAttr
*attr
)
7676 // don't show highlight when the grid doesn't have focus
7680 int row
= m_currentCellCoords
.GetRow();
7681 int col
= m_currentCellCoords
.GetCol();
7683 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7686 wxRect rect
= CellToRect(row
, col
);
7688 // hmmm... what could we do here to show that the cell is disabled?
7689 // for now, I just draw a thinner border than for the other ones, but
7690 // it doesn't look really good
7692 int penWidth
= attr
->IsReadOnly() ? m_cellHighlightROPenWidth
: m_cellHighlightPenWidth
;
7696 // The center of the drawn line is where the position/width/height of
7697 // the rectangle is actually at (on wxMSW at least), so the
7698 // size of the rectangle is reduced to compensate for the thickness of
7699 // the line. If this is too strange on non-wxMSW platforms then
7700 // please #ifdef this appropriately.
7701 rect
.x
+= penWidth
/ 2;
7702 rect
.y
+= penWidth
/ 2;
7703 rect
.width
-= penWidth
- 1;
7704 rect
.height
-= penWidth
- 1;
7706 // Now draw the rectangle
7707 // use the cellHighlightColour if the cell is inside a selection, this
7708 // will ensure the cell is always visible.
7709 dc
.SetPen(wxPen(IsInSelection(row
,col
) ? m_selectionForeground
: m_cellHighlightColour
, penWidth
, wxPENSTYLE_SOLID
));
7710 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
7711 dc
.DrawRectangle(rect
);
7715 // VZ: my experiments with 3D borders...
7717 // how to properly set colours for arbitrary bg?
7718 wxCoord x1
= rect
.x
,
7720 x2
= rect
.x
+ rect
.width
- 1,
7721 y2
= rect
.y
+ rect
.height
- 1;
7723 dc
.SetPen(*wxWHITE_PEN
);
7724 dc
.DrawLine(x1
, y1
, x2
, y1
);
7725 dc
.DrawLine(x1
, y1
, x1
, y2
);
7727 dc
.DrawLine(x1
+ 1, y2
- 1, x2
- 1, y2
- 1);
7728 dc
.DrawLine(x2
- 1, y1
+ 1, x2
- 1, y2
);
7730 dc
.SetPen(*wxBLACK_PEN
);
7731 dc
.DrawLine(x1
, y2
, x2
, y2
);
7732 dc
.DrawLine(x2
, y1
, x2
, y2
+ 1);
7736 wxPen
wxGrid::GetDefaultGridLinePen()
7738 return wxPen(GetGridLineColour(), 1, wxPENSTYLE_SOLID
);
7741 wxPen
wxGrid::GetRowGridLinePen(int WXUNUSED(row
))
7743 return GetDefaultGridLinePen();
7746 wxPen
wxGrid::GetColGridLinePen(int WXUNUSED(col
))
7748 return GetDefaultGridLinePen();
7751 void wxGrid::DrawCellBorder( wxDC
& dc
, const wxGridCellCoords
& coords
)
7753 int row
= coords
.GetRow();
7754 int col
= coords
.GetCol();
7755 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7759 wxRect rect
= CellToRect( row
, col
);
7761 // right hand border
7762 dc
.SetPen( GetColGridLinePen(col
) );
7763 dc
.DrawLine( rect
.x
+ rect
.width
, rect
.y
,
7764 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
+ 1 );
7767 dc
.SetPen( GetRowGridLinePen(row
) );
7768 dc
.DrawLine( rect
.x
, rect
.y
+ rect
.height
,
7769 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
7772 void wxGrid::DrawHighlight(wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
7774 // This if block was previously in wxGrid::OnPaint but that doesn't
7775 // seem to get called under wxGTK - MB
7777 if ( m_currentCellCoords
== wxGridNoCellCoords
&&
7778 m_numRows
&& m_numCols
)
7780 m_currentCellCoords
.Set(0, 0);
7783 if ( IsCellEditControlShown() )
7785 // don't show highlight when the edit control is shown
7789 // if the active cell was repainted, repaint its highlight too because it
7790 // might have been damaged by the grid lines
7791 size_t count
= cells
.GetCount();
7792 for ( size_t n
= 0; n
< count
; n
++ )
7794 if ( cells
[n
] == m_currentCellCoords
)
7796 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
7797 DrawCellHighlight(dc
, attr
);
7805 // TODO: remove this ???
7806 // This is used to redraw all grid lines e.g. when the grid line colour
7809 void wxGrid::DrawAllGridLines( wxDC
& dc
, const wxRegion
& WXUNUSED(reg
) )
7811 #if !WXGRID_DRAW_LINES
7815 if ( !m_gridLinesEnabled
|| !m_numRows
|| !m_numCols
)
7818 int top
, bottom
, left
, right
;
7820 #if 0 //#ifndef __WXGTK__
7824 m_gridWin
->GetClientSize(&cw
, &ch
);
7826 // virtual coords of visible area
7828 CalcUnscrolledPosition( 0, 0, &left
, &top
);
7829 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
7834 reg
.GetBox(x
, y
, w
, h
);
7835 CalcUnscrolledPosition( x
, y
, &left
, &top
);
7836 CalcUnscrolledPosition( x
+ w
, y
+ h
, &right
, &bottom
);
7840 m_gridWin
->GetClientSize(&cw
, &ch
);
7841 CalcUnscrolledPosition( 0, 0, &left
, &top
);
7842 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
7845 // avoid drawing grid lines past the last row and col
7847 right
= wxMin( right
, GetColRight(GetColAt( m_numCols
- 1 )) );
7848 bottom
= wxMin( bottom
, GetRowBottom(m_numRows
- 1) );
7850 // no gridlines inside multicells, clip them out
7851 int leftCol
= GetColPos( internalXToCol(left
) );
7852 int topRow
= internalYToRow(top
);
7853 int rightCol
= GetColPos( internalXToCol(right
) );
7854 int bottomRow
= internalYToRow(bottom
);
7856 wxRegion
clippedcells(0, 0, cw
, ch
);
7858 int i
, j
, cell_rows
, cell_cols
;
7861 for (j
=topRow
; j
<=bottomRow
; j
++)
7864 for (colPos
=leftCol
; colPos
<=rightCol
; colPos
++)
7866 i
= GetColAt( colPos
);
7868 GetCellSize( j
, i
, &cell_rows
, &cell_cols
);
7869 if ((cell_rows
> 1) || (cell_cols
> 1))
7871 rect
= CellToRect(j
,i
);
7872 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7873 clippedcells
.Subtract(rect
);
7875 else if ((cell_rows
< 0) || (cell_cols
< 0))
7877 rect
= CellToRect(j
+ cell_rows
, i
+ cell_cols
);
7878 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
7879 clippedcells
.Subtract(rect
);
7884 dc
.SetDeviceClippingRegion( clippedcells
);
7887 // horizontal grid lines
7889 // already declared above - int i;
7890 for ( i
= internalYToRow(top
); i
< m_numRows
; i
++ )
7892 int bot
= GetRowBottom(i
) - 1;
7901 dc
.SetPen( GetRowGridLinePen(i
) );
7902 dc
.DrawLine( left
, bot
, right
, bot
);
7906 // vertical grid lines
7909 for ( colPos
= leftCol
; colPos
< m_numCols
; colPos
++ )
7911 i
= GetColAt( colPos
);
7913 int colRight
= GetColRight(i
);
7915 if (GetLayoutDirection() != wxLayout_RightToLeft
)
7919 if ( colRight
> right
)
7924 if ( colRight
>= left
)
7926 dc
.SetPen( GetColGridLinePen(i
) );
7927 dc
.DrawLine( colRight
, top
, colRight
, bottom
);
7931 dc
.DestroyClippingRegion();
7934 void wxGrid::DrawRowLabels( wxDC
& dc
, const wxArrayInt
& rows
)
7940 size_t numLabels
= rows
.GetCount();
7942 for ( i
= 0; i
< numLabels
; i
++ )
7944 DrawRowLabel( dc
, rows
[i
] );
7948 void wxGrid::DrawRowLabel( wxDC
& dc
, int row
)
7950 if ( GetRowHeight(row
) <= 0 || m_rowLabelWidth
<= 0 )
7955 int rowTop
= GetRowTop(row
),
7956 rowBottom
= GetRowBottom(row
) - 1;
7958 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
), 1, wxPENSTYLE_SOLID
) );
7959 dc
.DrawLine( m_rowLabelWidth
- 1, rowTop
, m_rowLabelWidth
- 1, rowBottom
);
7960 dc
.DrawLine( 0, rowTop
, 0, rowBottom
);
7961 dc
.DrawLine( 0, rowBottom
, m_rowLabelWidth
, rowBottom
);
7963 dc
.SetPen( *wxWHITE_PEN
);
7964 dc
.DrawLine( 1, rowTop
, 1, rowBottom
);
7965 dc
.DrawLine( 1, rowTop
, m_rowLabelWidth
- 1, rowTop
);
7967 dc
.SetBackgroundMode( wxBRUSHSTYLE_TRANSPARENT
);
7968 dc
.SetTextForeground( GetLabelTextColour() );
7969 dc
.SetFont( GetLabelFont() );
7972 GetRowLabelAlignment( &hAlign
, &vAlign
);
7975 rect
.SetY( GetRowTop(row
) + 2 );
7976 rect
.SetWidth( m_rowLabelWidth
- 4 );
7977 rect
.SetHeight( GetRowHeight(row
) - 4 );
7978 DrawTextRectangle( dc
, GetRowLabelValue( row
), rect
, hAlign
, vAlign
);
7981 void wxGrid::SetUseNativeColLabels( bool native
)
7983 m_nativeColumnLabels
= native
;
7986 int height
= wxRendererNative::Get().GetHeaderButtonHeight( this );
7987 SetColLabelSize( height
);
7990 m_colLabelWin
->Refresh();
7993 void wxGrid::DrawColLabels( wxDC
& dc
,const wxArrayInt
& cols
)
7999 size_t numLabels
= cols
.GetCount();
8001 for ( i
= 0; i
< numLabels
; i
++ )
8003 DrawColLabel( dc
, cols
[i
] );
8007 void wxGrid::DrawColLabel( wxDC
& dc
, int col
)
8009 if ( GetColWidth(col
) <= 0 || m_colLabelHeight
<= 0 )
8012 int colLeft
= GetColLeft(col
);
8016 if (m_nativeColumnLabels
)
8018 rect
.SetX( colLeft
);
8020 rect
.SetWidth( GetColWidth(col
));
8021 rect
.SetHeight( m_colLabelHeight
);
8023 wxWindowDC
*win_dc
= (wxWindowDC
*) &dc
;
8024 wxRendererNative::Get().DrawHeaderButton( win_dc
->GetWindow(), dc
, rect
, 0 );
8028 int colRight
= GetColRight(col
) - 1;
8030 dc
.SetPen( wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
), 1, wxPENSTYLE_SOLID
) );
8031 dc
.DrawLine( colRight
, 0, colRight
, m_colLabelHeight
- 1 );
8032 dc
.DrawLine( colLeft
, 0, colRight
, 0 );
8033 dc
.DrawLine( colLeft
, m_colLabelHeight
- 1,
8034 colRight
+ 1, m_colLabelHeight
- 1 );
8036 dc
.SetPen( *wxWHITE_PEN
);
8037 dc
.DrawLine( colLeft
, 1, colLeft
, m_colLabelHeight
- 1 );
8038 dc
.DrawLine( colLeft
, 1, colRight
, 1 );
8041 dc
.SetBackgroundMode( wxBRUSHSTYLE_TRANSPARENT
);
8042 dc
.SetTextForeground( GetLabelTextColour() );
8043 dc
.SetFont( GetLabelFont() );
8045 int hAlign
, vAlign
, orient
;
8046 GetColLabelAlignment( &hAlign
, &vAlign
);
8047 orient
= GetColLabelTextOrientation();
8049 rect
.SetX( colLeft
+ 2 );
8051 rect
.SetWidth( GetColWidth(col
) - 4 );
8052 rect
.SetHeight( m_colLabelHeight
- 4 );
8053 DrawTextRectangle( dc
, GetColLabelValue( col
), rect
, hAlign
, vAlign
, orient
);
8056 void wxGrid::DrawTextRectangle( wxDC
& dc
,
8057 const wxString
& value
,
8061 int textOrientation
)
8063 wxArrayString lines
;
8065 StringToLines( value
, lines
);
8067 // Forward to new API.
8068 DrawTextRectangle( dc
,
8076 // VZ: this should be replaced with wxDC::DrawLabel() to which we just have to
8077 // add textOrientation support
8078 void wxGrid::DrawTextRectangle(wxDC
& dc
,
8079 const wxArrayString
& lines
,
8083 int textOrientation
)
8085 if ( lines
.empty() )
8088 wxDCClipper
clip(dc
, rect
);
8093 if ( textOrientation
== wxHORIZONTAL
)
8094 GetTextBoxSize( dc
, lines
, &textWidth
, &textHeight
);
8096 GetTextBoxSize( dc
, lines
, &textHeight
, &textWidth
);
8100 switch ( vertAlign
)
8102 case wxALIGN_BOTTOM
:
8103 if ( textOrientation
== wxHORIZONTAL
)
8104 y
= rect
.y
+ (rect
.height
- textHeight
- 1);
8106 x
= rect
.x
+ rect
.width
- textWidth
;
8109 case wxALIGN_CENTRE
:
8110 if ( textOrientation
== wxHORIZONTAL
)
8111 y
= rect
.y
+ ((rect
.height
- textHeight
) / 2);
8113 x
= rect
.x
+ ((rect
.width
- textWidth
) / 2);
8118 if ( textOrientation
== wxHORIZONTAL
)
8125 // Align each line of a multi-line label
8126 size_t nLines
= lines
.GetCount();
8127 for ( size_t l
= 0; l
< nLines
; l
++ )
8129 const wxString
& line
= lines
[l
];
8133 *(textOrientation
== wxHORIZONTAL
? &y
: &x
) += dc
.GetCharHeight();
8137 wxCoord lineWidth
= 0,
8139 dc
.GetTextExtent(line
, &lineWidth
, &lineHeight
);
8141 switch ( horizAlign
)
8144 if ( textOrientation
== wxHORIZONTAL
)
8145 x
= rect
.x
+ (rect
.width
- lineWidth
- 1);
8147 y
= rect
.y
+ lineWidth
+ 1;
8150 case wxALIGN_CENTRE
:
8151 if ( textOrientation
== wxHORIZONTAL
)
8152 x
= rect
.x
+ ((rect
.width
- lineWidth
) / 2);
8154 y
= rect
.y
+ rect
.height
- ((rect
.height
- lineWidth
) / 2);
8159 if ( textOrientation
== wxHORIZONTAL
)
8162 y
= rect
.y
+ rect
.height
- 1;
8166 if ( textOrientation
== wxHORIZONTAL
)
8168 dc
.DrawText( line
, x
, y
);
8173 dc
.DrawRotatedText( line
, x
, y
, 90.0 );
8179 // Split multi-line text up into an array of strings.
8180 // Any existing contents of the string array are preserved.
8182 // TODO: refactor wxTextFile::Read() and reuse the same code from here
8183 void wxGrid::StringToLines( const wxString
& value
, wxArrayString
& lines
) const
8187 wxString eol
= wxTextFile::GetEOL( wxTextFileType_Unix
);
8188 wxString tVal
= wxTextFile::Translate( value
, wxTextFileType_Unix
);
8190 while ( startPos
< (int)tVal
.length() )
8192 pos
= tVal
.Mid(startPos
).Find( eol
);
8197 else if ( pos
== 0 )
8199 lines
.Add( wxEmptyString
);
8203 lines
.Add( tVal
.Mid(startPos
, pos
) );
8206 startPos
+= pos
+ 1;
8209 if ( startPos
< (int)tVal
.length() )
8211 lines
.Add( tVal
.Mid( startPos
) );
8215 void wxGrid::GetTextBoxSize( const wxDC
& dc
,
8216 const wxArrayString
& lines
,
8217 long *width
, long *height
) const
8221 wxCoord lineW
= 0, lineH
= 0;
8224 for ( i
= 0; i
< lines
.GetCount(); i
++ )
8226 dc
.GetTextExtent( lines
[i
], &lineW
, &lineH
);
8227 w
= wxMax( w
, lineW
);
8236 // ------ Batch processing.
8238 void wxGrid::EndBatch()
8240 if ( m_batchCount
> 0 )
8243 if ( !m_batchCount
)
8246 m_rowLabelWin
->Refresh();
8247 m_colLabelWin
->Refresh();
8248 m_cornerLabelWin
->Refresh();
8249 m_gridWin
->Refresh();
8254 // Use this, rather than wxWindow::Refresh(), to force an immediate
8255 // repainting of the grid. Has no effect if you are already inside a
8256 // BeginBatch / EndBatch block.
8258 void wxGrid::ForceRefresh()
8264 bool wxGrid::Enable(bool enable
)
8266 if ( !wxScrolledWindow::Enable(enable
) )
8269 // redraw in the new state
8270 m_gridWin
->Refresh();
8276 // ------ Edit control functions
8279 void wxGrid::EnableEditing( bool edit
)
8281 // TODO: improve this ?
8283 if ( edit
!= m_editable
)
8286 EnableCellEditControl(edit
);
8291 void wxGrid::EnableCellEditControl( bool enable
)
8296 if ( enable
!= m_cellEditCtrlEnabled
)
8300 if (SendEvent( wxEVT_GRID_EDITOR_SHOWN
) <0)
8303 // this should be checked by the caller!
8304 wxASSERT_MSG( CanEnableCellControl(), _T("can't enable editing for this cell!") );
8306 // do it before ShowCellEditControl()
8307 m_cellEditCtrlEnabled
= enable
;
8309 ShowCellEditControl();
8313 //FIXME:add veto support
8314 SendEvent( wxEVT_GRID_EDITOR_HIDDEN
);
8316 HideCellEditControl();
8317 SaveEditControlValue();
8319 // do it after HideCellEditControl()
8320 m_cellEditCtrlEnabled
= enable
;
8325 bool wxGrid::IsCurrentCellReadOnly() const
8328 wxGridCellAttr
* attr
= ((wxGrid
*)this)->GetCellAttr(m_currentCellCoords
);
8329 bool readonly
= attr
->IsReadOnly();
8335 bool wxGrid::CanEnableCellControl() const
8337 return m_editable
&& (m_currentCellCoords
!= wxGridNoCellCoords
) &&
8338 !IsCurrentCellReadOnly();
8341 bool wxGrid::IsCellEditControlEnabled() const
8343 // the cell edit control might be disable for all cells or just for the
8344 // current one if it's read only
8345 return m_cellEditCtrlEnabled
? !IsCurrentCellReadOnly() : false;
8348 bool wxGrid::IsCellEditControlShown() const
8350 bool isShown
= false;
8352 if ( m_cellEditCtrlEnabled
)
8354 int row
= m_currentCellCoords
.GetRow();
8355 int col
= m_currentCellCoords
.GetCol();
8356 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8357 wxGridCellEditor
* editor
= attr
->GetEditor((wxGrid
*) this, row
, col
);
8362 if ( editor
->IsCreated() )
8364 isShown
= editor
->GetControl()->IsShown();
8374 void wxGrid::ShowCellEditControl()
8376 if ( IsCellEditControlEnabled() )
8378 if ( !IsVisible( m_currentCellCoords
, false ) )
8380 m_cellEditCtrlEnabled
= false;
8385 wxRect rect
= CellToRect( m_currentCellCoords
);
8386 int row
= m_currentCellCoords
.GetRow();
8387 int col
= m_currentCellCoords
.GetCol();
8389 // if this is part of a multicell, find owner (topleft)
8390 int cell_rows
, cell_cols
;
8391 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8392 if ( cell_rows
<= 0 || cell_cols
<= 0 )
8396 m_currentCellCoords
.SetRow( row
);
8397 m_currentCellCoords
.SetCol( col
);
8400 // erase the highlight and the cell contents because the editor
8401 // might not cover the entire cell
8402 wxClientDC
dc( m_gridWin
);
8404 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8405 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour(), wxBRUSHSTYLE_SOLID
));
8406 dc
.SetPen(*wxTRANSPARENT_PEN
);
8407 dc
.DrawRectangle(rect
);
8409 // convert to scrolled coords
8410 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
8416 // cell is shifted by one pixel
8417 // However, don't allow x or y to become negative
8418 // since the SetSize() method interprets that as
8425 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
8426 if ( !editor
->IsCreated() )
8428 editor
->Create(m_gridWin
, wxID_ANY
,
8429 new wxGridCellEditorEvtHandler(this, editor
));
8431 wxGridEditorCreatedEvent
evt(GetId(),
8432 wxEVT_GRID_EDITOR_CREATED
,
8436 editor
->GetControl());
8437 GetEventHandler()->ProcessEvent(evt
);
8440 // resize editor to overflow into righthand cells if allowed
8441 int maxWidth
= rect
.width
;
8442 wxString value
= GetCellValue(row
, col
);
8443 if ( (value
!= wxEmptyString
) && (attr
->GetOverflow()) )
8446 GetTextExtent(value
, &maxWidth
, &y
, NULL
, NULL
, &attr
->GetFont());
8447 if (maxWidth
< rect
.width
)
8448 maxWidth
= rect
.width
;
8451 int client_right
= m_gridWin
->GetClientSize().GetWidth();
8452 if (rect
.x
+ maxWidth
> client_right
)
8453 maxWidth
= client_right
- rect
.x
;
8455 if ((maxWidth
> rect
.width
) && (col
< m_numCols
) && m_table
)
8457 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8458 // may have changed earlier
8459 for (int i
= col
+ cell_cols
; i
< m_numCols
; i
++)
8462 GetCellSize( row
, i
, &c_rows
, &c_cols
);
8464 // looks weird going over a multicell
8465 if (m_table
->IsEmptyCell( row
, i
) &&
8466 (rect
.width
< maxWidth
) && (c_rows
== 1))
8468 rect
.width
+= GetColWidth( i
);
8474 if (rect
.GetRight() > client_right
)
8475 rect
.SetRight( client_right
- 1 );
8478 editor
->SetCellAttr( attr
);
8479 editor
->SetSize( rect
);
8481 editor
->GetControl()->Move(
8482 editor
->GetControl()->GetPosition().x
+ nXMove
,
8483 editor
->GetControl()->GetPosition().y
);
8484 editor
->Show( true, attr
);
8486 // recalc dimensions in case we need to
8487 // expand the scrolled window to account for editor
8490 editor
->BeginEdit(row
, col
, this);
8491 editor
->SetCellAttr(NULL
);
8499 void wxGrid::HideCellEditControl()
8501 if ( IsCellEditControlEnabled() )
8503 int row
= m_currentCellCoords
.GetRow();
8504 int col
= m_currentCellCoords
.GetCol();
8506 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8507 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
8508 editor
->Show( false );
8512 m_gridWin
->SetFocus();
8514 // refresh whole row to the right
8515 wxRect
rect( CellToRect(row
, col
) );
8516 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
8517 rect
.width
= m_gridWin
->GetClientSize().GetWidth() - rect
.x
;
8520 // ensure that the pixels under the focus ring get refreshed as well
8521 rect
.Inflate(10, 10);
8524 m_gridWin
->Refresh( false, &rect
);
8528 void wxGrid::SaveEditControlValue()
8530 if ( IsCellEditControlEnabled() )
8532 int row
= m_currentCellCoords
.GetRow();
8533 int col
= m_currentCellCoords
.GetCol();
8535 wxString oldval
= GetCellValue(row
, col
);
8537 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
8538 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
8539 bool changed
= editor
->EndEdit(row
, col
, this);
8546 if ( SendEvent( wxEVT_GRID_CELL_CHANGE
,
8547 m_currentCellCoords
.GetRow(),
8548 m_currentCellCoords
.GetCol() ) < 0 )
8550 // Event has been vetoed, set the data back.
8551 SetCellValue(row
, col
, oldval
);
8558 // ------ Grid location functions
8559 // Note that all of these functions work with the logical coordinates of
8560 // grid cells and labels so you will need to convert from device
8561 // coordinates for mouse events etc.
8564 void wxGrid::XYToCell( int x
, int y
, wxGridCellCoords
& coords
) const
8566 int row
= YToRow(y
);
8567 int col
= XToCol(x
);
8569 if ( row
== -1 || col
== -1 )
8571 coords
= wxGridNoCellCoords
;
8575 coords
.Set( row
, col
);
8579 // Internal Helper function for computing row or column from some
8580 // (unscrolled) coordinate value, using either
8581 // m_defaultRowHeight/m_defaultColWidth or binary search on array
8582 // of m_rowBottoms/m_ColRights to speed up the search!
8584 static int CoordToRowOrCol(int coord
, int defaultDist
, int minDist
,
8585 const wxArrayInt
& BorderArray
, int nMax
,
8589 return clipToMinMax
&& (nMax
> 0) ? 0 : -1;
8594 size_t i_max
= coord
/ defaultDist
,
8597 if (BorderArray
.IsEmpty())
8599 if ((int) i_max
< nMax
)
8601 return clipToMinMax
? nMax
- 1 : -1;
8604 if ( i_max
>= BorderArray
.GetCount())
8606 i_max
= BorderArray
.GetCount() - 1;
8610 if ( coord
>= BorderArray
[i_max
])
8614 i_max
= coord
/ minDist
;
8616 i_max
= BorderArray
.GetCount() - 1;
8619 if ( i_max
>= BorderArray
.GetCount())
8620 i_max
= BorderArray
.GetCount() - 1;
8623 if ( coord
>= BorderArray
[i_max
])
8624 return clipToMinMax
? (int)i_max
: -1;
8625 if ( coord
< BorderArray
[0] )
8628 while ( i_max
- i_min
> 0 )
8630 wxCHECK_MSG(BorderArray
[i_min
] <= coord
&& coord
< BorderArray
[i_max
],
8631 0, _T("wxGrid: internal error in CoordToRowOrCol"));
8632 if (coord
>= BorderArray
[ i_max
- 1])
8636 int median
= i_min
+ (i_max
- i_min
+ 1) / 2;
8637 if (coord
< BorderArray
[median
])
8646 int wxGrid::YToRow( int y
) const
8648 return CoordToRowOrCol(y
, m_defaultRowHeight
,
8649 m_minAcceptableRowHeight
, m_rowBottoms
, m_numRows
, false);
8652 int wxGrid::XToCol( int x
, bool clipToMinMax
) const
8655 return clipToMinMax
&& (m_numCols
> 0) ? GetColAt( 0 ) : -1;
8657 wxASSERT_MSG(m_defaultColWidth
> 0, wxT("Default column width can not be zero"));
8659 int maxPos
= x
/ m_defaultColWidth
;
8662 if (m_colRights
.IsEmpty())
8664 if(maxPos
< m_numCols
)
8665 return GetColAt( maxPos
);
8666 return clipToMinMax
? GetColAt( m_numCols
- 1 ) : -1;
8669 if ( maxPos
>= m_numCols
)
8670 maxPos
= m_numCols
- 1;
8673 if ( x
>= m_colRights
[GetColAt( maxPos
)])
8676 if (m_minAcceptableColWidth
)
8677 maxPos
= x
/ m_minAcceptableColWidth
;
8679 maxPos
= m_numCols
- 1;
8681 if ( maxPos
>= m_numCols
)
8682 maxPos
= m_numCols
- 1;
8685 //X is beyond the last column
8686 if ( x
>= m_colRights
[GetColAt( maxPos
)])
8687 return clipToMinMax
? GetColAt( maxPos
) : -1;
8689 //X is before the first column
8690 if ( x
< m_colRights
[GetColAt( 0 )] )
8691 return GetColAt( 0 );
8693 //Perform a binary search
8694 while ( maxPos
- minPos
> 0 )
8696 wxCHECK_MSG(m_colRights
[GetColAt( minPos
)] <= x
&& x
< m_colRights
[GetColAt( maxPos
)],
8697 0, _T("wxGrid: internal error in XToCol"));
8699 if (x
>= m_colRights
[GetColAt( maxPos
- 1 )])
8700 return GetColAt( maxPos
);
8703 int median
= minPos
+ (maxPos
- minPos
+ 1) / 2;
8704 if (x
< m_colRights
[GetColAt( median
)])
8709 return GetColAt( maxPos
);
8712 // return the row number that that the y coord is near
8713 // the edge of, or -1 if not near an edge.
8714 // coords can only possibly be near an edge if
8715 // (a) the row/column is large enough to still allow for an "inner" area
8716 // that is _not_ nead the edge (i.e., if the height/width is smaller
8717 // than WXGRID_LABEL_EDGE_ZONE, coords are _never_ considered to be
8720 // (b) resizing rows/columns (the thing for which edge detection is
8721 // relevant at all) is enabled.
8723 int wxGrid::YToEdgeOfRow( int y
) const
8726 i
= internalYToRow(y
);
8728 if ( GetRowHeight(i
) > WXGRID_LABEL_EDGE_ZONE
&& CanDragRowSize() )
8730 // We know that we are in row i, test whether we are
8731 // close enough to lower or upper border, respectively.
8732 if ( abs(GetRowBottom(i
) - y
) < WXGRID_LABEL_EDGE_ZONE
)
8734 else if ( i
> 0 && y
- GetRowTop(i
) < WXGRID_LABEL_EDGE_ZONE
)
8741 // return the col number that that the x coord is near the edge of, or
8742 // -1 if not near an edge
8743 // See comment at YToEdgeOfRow for conditions on edge detection.
8745 int wxGrid::XToEdgeOfCol( int x
) const
8748 i
= internalXToCol(x
);
8750 if ( GetColWidth(i
) > WXGRID_LABEL_EDGE_ZONE
&& CanDragColSize() )
8752 // We know that we are in column i; test whether we are
8753 // close enough to right or left border, respectively.
8754 if ( abs(GetColRight(i
) - x
) < WXGRID_LABEL_EDGE_ZONE
)
8756 else if ( i
> 0 && x
- GetColLeft(i
) < WXGRID_LABEL_EDGE_ZONE
)
8763 wxRect
wxGrid::CellToRect( int row
, int col
) const
8765 wxRect
rect( -1, -1, -1, -1 );
8767 if ( row
>= 0 && row
< m_numRows
&&
8768 col
>= 0 && col
< m_numCols
)
8770 int i
, cell_rows
, cell_cols
;
8771 rect
.width
= rect
.height
= 0;
8772 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8773 // if negative then find multicell owner
8778 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
8780 rect
.x
= GetColLeft(col
);
8781 rect
.y
= GetRowTop(row
);
8782 for (i
=col
; i
< col
+ cell_cols
; i
++)
8783 rect
.width
+= GetColWidth(i
);
8784 for (i
=row
; i
< row
+ cell_rows
; i
++)
8785 rect
.height
+= GetRowHeight(i
);
8788 // if grid lines are enabled, then the area of the cell is a bit smaller
8789 if (m_gridLinesEnabled
)
8798 bool wxGrid::IsVisible( int row
, int col
, bool wholeCellVisible
) const
8800 // get the cell rectangle in logical coords
8802 wxRect
r( CellToRect( row
, col
) );
8804 // convert to device coords
8806 int left
, top
, right
, bottom
;
8807 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
8808 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
8810 // check against the client area of the grid window
8812 m_gridWin
->GetClientSize( &cw
, &ch
);
8814 if ( wholeCellVisible
)
8816 // is the cell wholly visible ?
8817 return ( left
>= 0 && right
<= cw
&&
8818 top
>= 0 && bottom
<= ch
);
8822 // is the cell partly visible ?
8824 return ( ((left
>= 0 && left
< cw
) || (right
> 0 && right
<= cw
)) &&
8825 ((top
>= 0 && top
< ch
) || (bottom
> 0 && bottom
<= ch
)) );
8829 // make the specified cell location visible by doing a minimal amount
8832 void wxGrid::MakeCellVisible( int row
, int col
)
8835 int xpos
= -1, ypos
= -1;
8837 if ( row
>= 0 && row
< m_numRows
&&
8838 col
>= 0 && col
< m_numCols
)
8840 // get the cell rectangle in logical coords
8841 wxRect
r( CellToRect( row
, col
) );
8843 // convert to device coords
8844 int left
, top
, right
, bottom
;
8845 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
8846 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
8849 m_gridWin
->GetClientSize( &cw
, &ch
);
8855 else if ( bottom
> ch
)
8857 int h
= r
.GetHeight();
8859 for ( i
= row
- 1; i
>= 0; i
-- )
8861 int rowHeight
= GetRowHeight(i
);
8862 if ( h
+ rowHeight
> ch
)
8869 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
8870 // have rounding errors (this is important, because if we do,
8871 // we might not scroll at all and some cells won't be redrawn)
8873 // Sometimes GRID_SCROLL_LINE / 2 is not enough,
8874 // so just add a full scroll unit...
8875 ypos
+= m_scrollLineY
;
8878 // special handling for wide cells - show always left part of the cell!
8879 // Otherwise, e.g. when stepping from row to row, it would jump between
8880 // left and right part of the cell on every step!
8882 if ( left
< 0 || (right
- left
) >= cw
)
8886 else if ( right
> cw
)
8888 // position the view so that the cell is on the right
8890 CalcUnscrolledPosition(0, 0, &x0
, &y0
);
8891 xpos
= x0
+ (right
- cw
);
8893 // see comment for ypos above
8894 xpos
+= m_scrollLineX
;
8897 if ( xpos
!= -1 || ypos
!= -1 )
8900 xpos
/= m_scrollLineX
;
8902 ypos
/= m_scrollLineY
;
8903 Scroll( xpos
, ypos
);
8910 // ------ Grid cursor movement functions
8913 bool wxGrid::MoveCursorUp( bool expandSelection
)
8915 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
8916 m_currentCellCoords
.GetRow() >= 0 )
8918 if ( expandSelection
)
8920 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
8921 m_selectingKeyboard
= m_currentCellCoords
;
8922 if ( m_selectingKeyboard
.GetRow() > 0 )
8924 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() - 1 );
8925 MakeCellVisible( m_selectingKeyboard
.GetRow(),
8926 m_selectingKeyboard
.GetCol() );
8927 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8930 else if ( m_currentCellCoords
.GetRow() > 0 )
8932 int row
= m_currentCellCoords
.GetRow() - 1;
8933 int col
= m_currentCellCoords
.GetCol();
8935 MakeCellVisible( row
, col
);
8936 SetCurrentCell( row
, col
);
8947 bool wxGrid::MoveCursorDown( bool expandSelection
)
8949 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
8950 m_currentCellCoords
.GetRow() < m_numRows
)
8952 if ( expandSelection
)
8954 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
8955 m_selectingKeyboard
= m_currentCellCoords
;
8956 if ( m_selectingKeyboard
.GetRow() < m_numRows
- 1 )
8958 m_selectingKeyboard
.SetRow( m_selectingKeyboard
.GetRow() + 1 );
8959 MakeCellVisible( m_selectingKeyboard
.GetRow(),
8960 m_selectingKeyboard
.GetCol() );
8961 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8964 else if ( m_currentCellCoords
.GetRow() < m_numRows
- 1 )
8966 int row
= m_currentCellCoords
.GetRow() + 1;
8967 int col
= m_currentCellCoords
.GetCol();
8969 MakeCellVisible( row
, col
);
8970 SetCurrentCell( row
, col
);
8981 bool wxGrid::MoveCursorLeft( bool expandSelection
)
8983 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
8984 m_currentCellCoords
.GetCol() >= 0 )
8986 if ( expandSelection
)
8988 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
8989 m_selectingKeyboard
= m_currentCellCoords
;
8990 if ( m_selectingKeyboard
.GetCol() > 0 )
8992 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() - 1 );
8993 MakeCellVisible( m_selectingKeyboard
.GetRow(),
8994 m_selectingKeyboard
.GetCol() );
8995 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
8998 else if ( GetColPos( m_currentCellCoords
.GetCol() ) > 0 )
9000 int row
= m_currentCellCoords
.GetRow();
9001 int col
= GetColAt( GetColPos( m_currentCellCoords
.GetCol() ) - 1 );
9004 MakeCellVisible( row
, col
);
9005 SetCurrentCell( row
, col
);
9016 bool wxGrid::MoveCursorRight( bool expandSelection
)
9018 if ( m_currentCellCoords
!= wxGridNoCellCoords
&&
9019 m_currentCellCoords
.GetCol() < m_numCols
)
9021 if ( expandSelection
)
9023 if ( m_selectingKeyboard
== wxGridNoCellCoords
)
9024 m_selectingKeyboard
= m_currentCellCoords
;
9025 if ( m_selectingKeyboard
.GetCol() < m_numCols
- 1 )
9027 m_selectingKeyboard
.SetCol( m_selectingKeyboard
.GetCol() + 1 );
9028 MakeCellVisible( m_selectingKeyboard
.GetRow(),
9029 m_selectingKeyboard
.GetCol() );
9030 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9033 else if ( GetColPos( m_currentCellCoords
.GetCol() ) < m_numCols
- 1 )
9035 int row
= m_currentCellCoords
.GetRow();
9036 int col
= GetColAt( GetColPos( m_currentCellCoords
.GetCol() ) + 1 );
9039 MakeCellVisible( row
, col
);
9040 SetCurrentCell( row
, col
);
9051 bool wxGrid::MovePageUp()
9053 if ( m_currentCellCoords
== wxGridNoCellCoords
)
9056 int row
= m_currentCellCoords
.GetRow();
9060 m_gridWin
->GetClientSize( &cw
, &ch
);
9062 int y
= GetRowTop(row
);
9063 int newRow
= internalYToRow( y
- ch
+ 1 );
9065 if ( newRow
== row
)
9067 // row > 0, so newRow can never be less than 0 here.
9071 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
9072 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
9080 bool wxGrid::MovePageDown()
9082 if ( m_currentCellCoords
== wxGridNoCellCoords
)
9085 int row
= m_currentCellCoords
.GetRow();
9086 if ( (row
+ 1) < m_numRows
)
9089 m_gridWin
->GetClientSize( &cw
, &ch
);
9091 int y
= GetRowTop(row
);
9092 int newRow
= internalYToRow( y
+ ch
);
9093 if ( newRow
== row
)
9095 // row < m_numRows, so newRow can't overflow here.
9099 MakeCellVisible( newRow
, m_currentCellCoords
.GetCol() );
9100 SetCurrentCell( newRow
, m_currentCellCoords
.GetCol() );
9108 bool wxGrid::MoveCursorUpBlock( bool expandSelection
)
9111 m_currentCellCoords
!= wxGridNoCellCoords
&&
9112 m_currentCellCoords
.GetRow() > 0 )
9114 int row
= m_currentCellCoords
.GetRow();
9115 int col
= m_currentCellCoords
.GetCol();
9117 if ( m_table
->IsEmptyCell(row
, col
) )
9119 // starting in an empty cell: find the next block of
9125 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9129 else if ( m_table
->IsEmptyCell(row
- 1, col
) )
9131 // starting at the top of a block: find the next block
9137 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9143 // starting within a block: find the top of the block
9148 if ( m_table
->IsEmptyCell(row
, col
) )
9156 MakeCellVisible( row
, col
);
9157 if ( expandSelection
)
9159 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9160 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9165 SetCurrentCell( row
, col
);
9174 bool wxGrid::MoveCursorDownBlock( bool expandSelection
)
9177 m_currentCellCoords
!= wxGridNoCellCoords
&&
9178 m_currentCellCoords
.GetRow() < m_numRows
- 1 )
9180 int row
= m_currentCellCoords
.GetRow();
9181 int col
= m_currentCellCoords
.GetCol();
9183 if ( m_table
->IsEmptyCell(row
, col
) )
9185 // starting in an empty cell: find the next block of
9188 while ( row
< m_numRows
- 1 )
9191 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9195 else if ( m_table
->IsEmptyCell(row
+ 1, col
) )
9197 // starting at the bottom of a block: find the next block
9200 while ( row
< m_numRows
- 1 )
9203 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9209 // starting within a block: find the bottom of the block
9211 while ( row
< m_numRows
- 1 )
9214 if ( m_table
->IsEmptyCell(row
, col
) )
9222 MakeCellVisible( row
, col
);
9223 if ( expandSelection
)
9225 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9226 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9231 SetCurrentCell( row
, col
);
9240 bool wxGrid::MoveCursorLeftBlock( bool expandSelection
)
9243 m_currentCellCoords
!= wxGridNoCellCoords
&&
9244 m_currentCellCoords
.GetCol() > 0 )
9246 int row
= m_currentCellCoords
.GetRow();
9247 int col
= m_currentCellCoords
.GetCol();
9249 if ( m_table
->IsEmptyCell(row
, col
) )
9251 // starting in an empty cell: find the next block of
9257 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9261 else if ( m_table
->IsEmptyCell(row
, col
- 1) )
9263 // starting at the left of a block: find the next block
9269 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9275 // starting within a block: find the left of the block
9280 if ( m_table
->IsEmptyCell(row
, col
) )
9288 MakeCellVisible( row
, col
);
9289 if ( expandSelection
)
9291 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9292 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9297 SetCurrentCell( row
, col
);
9306 bool wxGrid::MoveCursorRightBlock( bool expandSelection
)
9309 m_currentCellCoords
!= wxGridNoCellCoords
&&
9310 m_currentCellCoords
.GetCol() < m_numCols
- 1 )
9312 int row
= m_currentCellCoords
.GetRow();
9313 int col
= m_currentCellCoords
.GetCol();
9315 if ( m_table
->IsEmptyCell(row
, col
) )
9317 // starting in an empty cell: find the next block of
9320 while ( col
< m_numCols
- 1 )
9323 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9327 else if ( m_table
->IsEmptyCell(row
, col
+ 1) )
9329 // starting at the right of a block: find the next block
9332 while ( col
< m_numCols
- 1 )
9335 if ( !(m_table
->IsEmptyCell(row
, col
)) )
9341 // starting within a block: find the right of the block
9343 while ( col
< m_numCols
- 1 )
9346 if ( m_table
->IsEmptyCell(row
, col
) )
9354 MakeCellVisible( row
, col
);
9355 if ( expandSelection
)
9357 m_selectingKeyboard
= wxGridCellCoords( row
, col
);
9358 HighlightBlock( m_currentCellCoords
, m_selectingKeyboard
);
9363 SetCurrentCell( row
, col
);
9373 // ------ Label values and formatting
9376 void wxGrid::GetRowLabelAlignment( int *horiz
, int *vert
) const
9379 *horiz
= m_rowLabelHorizAlign
;
9381 *vert
= m_rowLabelVertAlign
;
9384 void wxGrid::GetColLabelAlignment( int *horiz
, int *vert
) const
9387 *horiz
= m_colLabelHorizAlign
;
9389 *vert
= m_colLabelVertAlign
;
9392 int wxGrid::GetColLabelTextOrientation() const
9394 return m_colLabelTextOrientation
;
9397 wxString
wxGrid::GetRowLabelValue( int row
) const
9401 return m_table
->GetRowLabelValue( row
);
9411 wxString
wxGrid::GetColLabelValue( int col
) const
9415 return m_table
->GetColLabelValue( col
);
9425 void wxGrid::SetRowLabelSize( int width
)
9427 wxASSERT( width
>= 0 || width
== wxGRID_AUTOSIZE
);
9429 if ( width
== wxGRID_AUTOSIZE
)
9431 width
= CalcColOrRowLabelAreaMinSize(wxGRID_ROW
);
9434 if ( width
!= m_rowLabelWidth
)
9438 m_rowLabelWin
->Show( false );
9439 m_cornerLabelWin
->Show( false );
9441 else if ( m_rowLabelWidth
== 0 )
9443 m_rowLabelWin
->Show( true );
9444 if ( m_colLabelHeight
> 0 )
9445 m_cornerLabelWin
->Show( true );
9448 m_rowLabelWidth
= width
;
9450 wxScrolledWindow::Refresh( true );
9454 void wxGrid::SetColLabelSize( int height
)
9456 wxASSERT( height
>=0 || height
== wxGRID_AUTOSIZE
);
9458 if ( height
== wxGRID_AUTOSIZE
)
9460 height
= CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN
);
9463 if ( height
!= m_colLabelHeight
)
9467 m_colLabelWin
->Show( false );
9468 m_cornerLabelWin
->Show( false );
9470 else if ( m_colLabelHeight
== 0 )
9472 m_colLabelWin
->Show( true );
9473 if ( m_rowLabelWidth
> 0 )
9474 m_cornerLabelWin
->Show( true );
9477 m_colLabelHeight
= height
;
9479 wxScrolledWindow::Refresh( true );
9483 void wxGrid::SetLabelBackgroundColour( const wxColour
& colour
)
9485 if ( m_labelBackgroundColour
!= colour
)
9487 m_labelBackgroundColour
= colour
;
9488 m_rowLabelWin
->SetBackgroundColour( colour
);
9489 m_colLabelWin
->SetBackgroundColour( colour
);
9490 m_cornerLabelWin
->SetBackgroundColour( colour
);
9492 if ( !GetBatchCount() )
9494 m_rowLabelWin
->Refresh();
9495 m_colLabelWin
->Refresh();
9496 m_cornerLabelWin
->Refresh();
9501 void wxGrid::SetLabelTextColour( const wxColour
& colour
)
9503 if ( m_labelTextColour
!= colour
)
9505 m_labelTextColour
= colour
;
9506 if ( !GetBatchCount() )
9508 m_rowLabelWin
->Refresh();
9509 m_colLabelWin
->Refresh();
9514 void wxGrid::SetLabelFont( const wxFont
& font
)
9517 if ( !GetBatchCount() )
9519 m_rowLabelWin
->Refresh();
9520 m_colLabelWin
->Refresh();
9524 void wxGrid::SetRowLabelAlignment( int horiz
, int vert
)
9526 // allow old (incorrect) defs to be used
9529 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
9530 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
9531 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
9536 case wxTOP
: vert
= wxALIGN_TOP
; break;
9537 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
9538 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
9541 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
9543 m_rowLabelHorizAlign
= horiz
;
9546 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
9548 m_rowLabelVertAlign
= vert
;
9551 if ( !GetBatchCount() )
9553 m_rowLabelWin
->Refresh();
9557 void wxGrid::SetColLabelAlignment( int horiz
, int vert
)
9559 // allow old (incorrect) defs to be used
9562 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
9563 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
9564 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
9569 case wxTOP
: vert
= wxALIGN_TOP
; break;
9570 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
9571 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
9574 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
9576 m_colLabelHorizAlign
= horiz
;
9579 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
9581 m_colLabelVertAlign
= vert
;
9584 if ( !GetBatchCount() )
9586 m_colLabelWin
->Refresh();
9590 // Note: under MSW, the default column label font must be changed because it
9591 // does not support vertical printing
9593 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
9594 // pGrid->SetLabelFont(font);
9595 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
9597 void wxGrid::SetColLabelTextOrientation( int textOrientation
)
9599 if ( textOrientation
== wxHORIZONTAL
|| textOrientation
== wxVERTICAL
)
9600 m_colLabelTextOrientation
= textOrientation
;
9602 if ( !GetBatchCount() )
9603 m_colLabelWin
->Refresh();
9606 void wxGrid::SetRowLabelValue( int row
, const wxString
& s
)
9610 m_table
->SetRowLabelValue( row
, s
);
9611 if ( !GetBatchCount() )
9613 wxRect rect
= CellToRect( row
, 0 );
9614 if ( rect
.height
> 0 )
9616 CalcScrolledPosition(0, rect
.y
, &rect
.x
, &rect
.y
);
9618 rect
.width
= m_rowLabelWidth
;
9619 m_rowLabelWin
->Refresh( true, &rect
);
9625 void wxGrid::SetColLabelValue( int col
, const wxString
& s
)
9629 m_table
->SetColLabelValue( col
, s
);
9630 if ( !GetBatchCount() )
9632 wxRect rect
= CellToRect( 0, col
);
9633 if ( rect
.width
> 0 )
9635 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &rect
.y
);
9637 rect
.height
= m_colLabelHeight
;
9638 m_colLabelWin
->Refresh( true, &rect
);
9644 void wxGrid::SetGridLineColour( const wxColour
& colour
)
9646 if ( m_gridLineColour
!= colour
)
9648 m_gridLineColour
= colour
;
9650 wxClientDC
dc( m_gridWin
);
9652 DrawAllGridLines( dc
, wxRegion() );
9656 void wxGrid::SetCellHighlightColour( const wxColour
& colour
)
9658 if ( m_cellHighlightColour
!= colour
)
9660 m_cellHighlightColour
= colour
;
9662 wxClientDC
dc( m_gridWin
);
9664 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
9665 DrawCellHighlight(dc
, attr
);
9670 void wxGrid::SetCellHighlightPenWidth(int width
)
9672 if (m_cellHighlightPenWidth
!= width
)
9674 m_cellHighlightPenWidth
= width
;
9676 // Just redrawing the cell highlight is not enough since that won't
9677 // make any visible change if the the thickness is getting smaller.
9678 int row
= m_currentCellCoords
.GetRow();
9679 int col
= m_currentCellCoords
.GetCol();
9680 if ( row
== -1 || col
== -1 || GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
9683 wxRect rect
= CellToRect(row
, col
);
9684 m_gridWin
->Refresh(true, &rect
);
9688 void wxGrid::SetCellHighlightROPenWidth(int width
)
9690 if (m_cellHighlightROPenWidth
!= width
)
9692 m_cellHighlightROPenWidth
= width
;
9694 // Just redrawing the cell highlight is not enough since that won't
9695 // make any visible change if the the thickness is getting smaller.
9696 int row
= m_currentCellCoords
.GetRow();
9697 int col
= m_currentCellCoords
.GetCol();
9698 if ( row
== -1 || col
== -1 ||
9699 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
);
10071 wxGridCellEditor
*editor
= GetDefaultEditorForType(typeName
);
10072 attr
->SetEditor(editor
);
10074 SetColAttr(col
, attr
);
10078 // ----------------------------------------------------------------------------
10079 // setting cell attributes: this is forwarded to the table
10080 // ----------------------------------------------------------------------------
10082 void wxGrid::SetAttr(int row
, int col
, wxGridCellAttr
*attr
)
10084 if ( CanHaveAttributes() )
10086 m_table
->SetAttr(attr
, row
, col
);
10091 wxSafeDecRef(attr
);
10095 void wxGrid::SetRowAttr(int row
, wxGridCellAttr
*attr
)
10097 if ( CanHaveAttributes() )
10099 m_table
->SetRowAttr(attr
, row
);
10104 wxSafeDecRef(attr
);
10108 void wxGrid::SetColAttr(int col
, wxGridCellAttr
*attr
)
10110 if ( CanHaveAttributes() )
10112 m_table
->SetColAttr(attr
, col
);
10117 wxSafeDecRef(attr
);
10121 void wxGrid::SetCellBackgroundColour( int row
, int col
, const wxColour
& colour
)
10123 if ( CanHaveAttributes() )
10125 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10126 attr
->SetBackgroundColour(colour
);
10131 void wxGrid::SetCellTextColour( int row
, int col
, const wxColour
& colour
)
10133 if ( CanHaveAttributes() )
10135 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10136 attr
->SetTextColour(colour
);
10141 void wxGrid::SetCellFont( int row
, int col
, const wxFont
& font
)
10143 if ( CanHaveAttributes() )
10145 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10146 attr
->SetFont(font
);
10151 void wxGrid::SetCellAlignment( int row
, int col
, int horiz
, int vert
)
10153 if ( CanHaveAttributes() )
10155 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10156 attr
->SetAlignment(horiz
, vert
);
10161 void wxGrid::SetCellOverflow( int row
, int col
, bool allow
)
10163 if ( CanHaveAttributes() )
10165 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10166 attr
->SetOverflow(allow
);
10171 void wxGrid::SetCellSize( int row
, int col
, int num_rows
, int num_cols
)
10173 if ( CanHaveAttributes() )
10175 int cell_rows
, cell_cols
;
10177 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10178 attr
->GetSize(&cell_rows
, &cell_cols
);
10179 attr
->SetSize(num_rows
, num_cols
);
10182 // Cannot set the size of a cell to 0 or negative values
10183 // While it is perfectly legal to do that, this function cannot
10184 // handle all the possibilies, do it by hand by getting the CellAttr.
10185 // You can only set the size of a cell to 1,1 or greater with this fn
10186 wxASSERT_MSG( !((cell_rows
< 1) || (cell_cols
< 1)),
10187 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
10188 wxASSERT_MSG( !((num_rows
< 1) || (num_cols
< 1)),
10189 wxT("wxGrid::SetCellSize setting cell size to < 1"));
10191 // if this was already a multicell then "turn off" the other cells first
10192 if ((cell_rows
> 1) || (cell_rows
> 1))
10195 for (j
=row
; j
< row
+ cell_rows
; j
++)
10197 for (i
=col
; i
< col
+ cell_cols
; i
++)
10199 if ((i
!= col
) || (j
!= row
))
10201 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
10202 attr_stub
->SetSize( 1, 1 );
10203 attr_stub
->DecRef();
10209 // mark the cells that will be covered by this cell to
10210 // negative or zero values to point back at this cell
10211 if (((num_rows
> 1) || (num_cols
> 1)) && (num_rows
>= 1) && (num_cols
>= 1))
10214 for (j
=row
; j
< row
+ num_rows
; j
++)
10216 for (i
=col
; i
< col
+ num_cols
; i
++)
10218 if ((i
!= col
) || (j
!= row
))
10220 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
10221 attr_stub
->SetSize( row
- j
, col
- i
);
10222 attr_stub
->DecRef();
10230 void wxGrid::SetCellRenderer(int row
, int col
, wxGridCellRenderer
*renderer
)
10232 if ( CanHaveAttributes() )
10234 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10235 attr
->SetRenderer(renderer
);
10240 void wxGrid::SetCellEditor(int row
, int col
, wxGridCellEditor
* editor
)
10242 if ( CanHaveAttributes() )
10244 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10245 attr
->SetEditor(editor
);
10250 void wxGrid::SetReadOnly(int row
, int col
, bool isReadOnly
)
10252 if ( CanHaveAttributes() )
10254 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
10255 attr
->SetReadOnly(isReadOnly
);
10260 // ----------------------------------------------------------------------------
10261 // Data type registration
10262 // ----------------------------------------------------------------------------
10264 void wxGrid::RegisterDataType(const wxString
& typeName
,
10265 wxGridCellRenderer
* renderer
,
10266 wxGridCellEditor
* editor
)
10268 m_typeRegistry
->RegisterDataType(typeName
, renderer
, editor
);
10272 wxGridCellEditor
* wxGrid::GetDefaultEditorForCell(int row
, int col
) const
10274 wxString typeName
= m_table
->GetTypeName(row
, col
);
10275 return GetDefaultEditorForType(typeName
);
10278 wxGridCellRenderer
* wxGrid::GetDefaultRendererForCell(int row
, int col
) const
10280 wxString typeName
= m_table
->GetTypeName(row
, col
);
10281 return GetDefaultRendererForType(typeName
);
10284 wxGridCellEditor
* wxGrid::GetDefaultEditorForType(const wxString
& typeName
) const
10286 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
10287 if ( index
== wxNOT_FOUND
)
10289 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName
.c_str()));
10294 return m_typeRegistry
->GetEditor(index
);
10297 wxGridCellRenderer
* wxGrid::GetDefaultRendererForType(const wxString
& typeName
) const
10299 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
10300 if ( index
== wxNOT_FOUND
)
10302 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName
.c_str()));
10307 return m_typeRegistry
->GetRenderer(index
);
10310 // ----------------------------------------------------------------------------
10312 // ----------------------------------------------------------------------------
10314 void wxGrid::EnableDragRowSize( bool enable
)
10316 m_canDragRowSize
= enable
;
10319 void wxGrid::EnableDragColSize( bool enable
)
10321 m_canDragColSize
= enable
;
10324 void wxGrid::EnableDragGridSize( bool enable
)
10326 m_canDragGridSize
= enable
;
10329 void wxGrid::EnableDragCell( bool enable
)
10331 m_canDragCell
= enable
;
10334 void wxGrid::SetDefaultRowSize( int height
, bool resizeExistingRows
)
10336 m_defaultRowHeight
= wxMax( height
, m_minAcceptableRowHeight
);
10338 if ( resizeExistingRows
)
10340 // since we are resizing all rows to the default row size,
10341 // we can simply clear the row heights and row bottoms
10342 // arrays (which also allows us to take advantage of
10343 // some speed optimisations)
10344 m_rowHeights
.Empty();
10345 m_rowBottoms
.Empty();
10346 if ( !GetBatchCount() )
10351 void wxGrid::SetRowSize( int row
, int height
)
10353 wxCHECK_RET( row
>= 0 && row
< m_numRows
, _T("invalid row index") );
10355 // if < 0 then calculate new height from label
10359 wxArrayString lines
;
10360 wxClientDC
dc(m_rowLabelWin
);
10361 dc
.SetFont(GetLabelFont());
10362 StringToLines(GetRowLabelValue( row
), lines
);
10363 GetTextBoxSize( dc
, lines
, &w
, &h
);
10364 //check that it is not less than the minimal height
10365 height
= wxMax(h
, GetRowMinimalAcceptableHeight());
10368 // See comment in SetColSize
10369 if ( height
< GetRowMinimalAcceptableHeight())
10372 if ( m_rowHeights
.IsEmpty() )
10374 // need to really create the array
10378 int h
= wxMax( 0, height
);
10379 int diff
= h
- m_rowHeights
[row
];
10381 m_rowHeights
[row
] = h
;
10382 for ( int i
= row
; i
< m_numRows
; i
++ )
10384 m_rowBottoms
[i
] += diff
;
10387 if ( !GetBatchCount() )
10391 void wxGrid::SetDefaultColSize( int width
, bool resizeExistingCols
)
10393 // we dont allow zero default column width
10394 m_defaultColWidth
= wxMax( wxMax( width
, m_minAcceptableColWidth
), 1 );
10396 if ( resizeExistingCols
)
10398 // since we are resizing all columns to the default column size,
10399 // we can simply clear the col widths and col rights
10400 // arrays (which also allows us to take advantage of
10401 // some speed optimisations)
10402 m_colWidths
.Empty();
10403 m_colRights
.Empty();
10404 if ( !GetBatchCount() )
10409 void wxGrid::SetColSize( int col
, int width
)
10411 wxCHECK_RET( col
>= 0 && col
< m_numCols
, _T("invalid column index") );
10413 // if < 0 then calculate new width from label
10417 wxArrayString lines
;
10418 wxClientDC
dc(m_colLabelWin
);
10419 dc
.SetFont(GetLabelFont());
10420 StringToLines(GetColLabelValue(col
), lines
);
10421 if ( GetColLabelTextOrientation() == wxHORIZONTAL
)
10422 GetTextBoxSize( dc
, lines
, &w
, &h
);
10424 GetTextBoxSize( dc
, lines
, &h
, &w
);
10426 //check that it is not less than the minimal width
10427 width
= wxMax(width
, GetColMinimalAcceptableWidth());
10430 // should we check that it's bigger than GetColMinimalWidth(col) here?
10432 // No, because it is reasonable to assume the library user know's
10433 // what he is doing. However we should test against the weaker
10434 // constraint of minimalAcceptableWidth, as this breaks rendering
10436 // This test then fixes sf.net bug #645734
10438 if ( width
< GetColMinimalAcceptableWidth() )
10441 if ( m_colWidths
.IsEmpty() )
10443 // need to really create the array
10447 int w
= wxMax( 0, width
);
10448 int diff
= w
- m_colWidths
[col
];
10449 m_colWidths
[col
] = w
;
10451 for ( int colPos
= GetColPos(col
); colPos
< m_numCols
; colPos
++ )
10453 m_colRights
[GetColAt(colPos
)] += diff
;
10456 if ( !GetBatchCount() )
10460 void wxGrid::SetColMinimalWidth( int col
, int width
)
10462 if (width
> GetColMinimalAcceptableWidth())
10464 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)col
;
10465 m_colMinWidths
[key
] = width
;
10469 void wxGrid::SetRowMinimalHeight( int row
, int width
)
10471 if (width
> GetRowMinimalAcceptableHeight())
10473 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)row
;
10474 m_rowMinHeights
[key
] = width
;
10478 int wxGrid::GetColMinimalWidth(int col
) const
10480 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)col
;
10481 wxLongToLongHashMap::const_iterator it
= m_colMinWidths
.find(key
);
10483 return it
!= m_colMinWidths
.end() ? (int)it
->second
: m_minAcceptableColWidth
;
10486 int wxGrid::GetRowMinimalHeight(int row
) const
10488 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)row
;
10489 wxLongToLongHashMap::const_iterator it
= m_rowMinHeights
.find(key
);
10491 return it
!= m_rowMinHeights
.end() ? (int)it
->second
: m_minAcceptableRowHeight
;
10494 void wxGrid::SetColMinimalAcceptableWidth( int width
)
10496 // We do allow a width of 0 since this gives us
10497 // an easy way to temporarily hiding columns.
10499 m_minAcceptableColWidth
= width
;
10502 void wxGrid::SetRowMinimalAcceptableHeight( int height
)
10504 // We do allow a height of 0 since this gives us
10505 // an easy way to temporarily hiding rows.
10507 m_minAcceptableRowHeight
= height
;
10510 int wxGrid::GetColMinimalAcceptableWidth() const
10512 return m_minAcceptableColWidth
;
10515 int wxGrid::GetRowMinimalAcceptableHeight() const
10517 return m_minAcceptableRowHeight
;
10520 // ----------------------------------------------------------------------------
10522 // ----------------------------------------------------------------------------
10525 wxGrid::AutoSizeColOrRow(int colOrRow
, bool setAsMin
, wxGridDirection direction
)
10527 const bool column
= direction
== wxGRID_COLUMN
;
10529 wxClientDC
dc(m_gridWin
);
10531 // cancel editing of cell
10532 HideCellEditControl();
10533 SaveEditControlValue();
10535 // init both of them to avoid compiler warnings, even if we only need one
10543 wxCoord extent
, extentMax
= 0;
10544 int max
= column
? m_numRows
: m_numCols
;
10545 for ( int rowOrCol
= 0; rowOrCol
< max
; rowOrCol
++ )
10552 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
10553 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
10556 wxSize size
= renderer
->GetBestSize(*this, *attr
, dc
, row
, col
);
10557 extent
= column
? size
.x
: size
.y
;
10558 if ( extent
> extentMax
)
10559 extentMax
= extent
;
10561 renderer
->DecRef();
10567 // now also compare with the column label extent
10569 dc
.SetFont( GetLabelFont() );
10573 dc
.GetMultiLineTextExtent( GetColLabelValue(col
), &w
, &h
);
10574 if ( GetColLabelTextOrientation() == wxVERTICAL
)
10578 dc
.GetMultiLineTextExtent( GetRowLabelValue(row
), &w
, &h
);
10580 extent
= column
? w
: h
;
10581 if ( extent
> extentMax
)
10582 extentMax
= extent
;
10586 // empty column - give default extent (notice that if extentMax is less
10587 // than default extent but != 0, it's OK)
10588 extentMax
= column
? m_defaultColWidth
: m_defaultRowHeight
;
10593 // leave some space around text
10601 // Ensure automatic width is not less than minimal width. See the
10602 // comment in SetColSize() for explanation of why this isn't done
10603 // in SetColSize().
10605 extentMax
= wxMax(extentMax
, GetColMinimalWidth(col
));
10607 SetColSize( col
, extentMax
);
10608 if ( !GetBatchCount() )
10611 m_gridWin
->GetClientSize( &cw
, &ch
);
10612 wxRect
rect ( CellToRect( 0, col
) );
10614 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
10615 rect
.width
= cw
- rect
.x
;
10616 rect
.height
= m_colLabelHeight
;
10617 m_colLabelWin
->Refresh( true, &rect
);
10622 // Ensure automatic width is not less than minimal height. See the
10623 // comment in SetColSize() for explanation of why this isn't done
10624 // in SetRowSize().
10626 extentMax
= wxMax(extentMax
, GetRowMinimalHeight(row
));
10628 SetRowSize(row
, extentMax
);
10629 if ( !GetBatchCount() )
10632 m_gridWin
->GetClientSize( &cw
, &ch
);
10633 wxRect
rect( CellToRect( row
, 0 ) );
10635 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
10636 rect
.width
= m_rowLabelWidth
;
10637 rect
.height
= ch
- rect
.y
;
10638 m_rowLabelWin
->Refresh( true, &rect
);
10645 SetColMinimalWidth(col
, extentMax
);
10647 SetRowMinimalHeight(row
, extentMax
);
10651 wxCoord
wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction
)
10653 // calculate size for the rows or columns?
10654 const bool calcRows
= direction
== wxGRID_ROW
;
10656 wxClientDC
dc(calcRows
? GetGridRowLabelWindow()
10657 : GetGridColLabelWindow());
10658 dc
.SetFont(GetLabelFont());
10660 // which dimension should we take into account for calculations?
10662 // for columns, the text can be only horizontal so it's easy but for rows
10663 // we also have to take into account the text orientation
10665 useWidth
= calcRows
|| (GetColLabelTextOrientation() == wxVERTICAL
);
10667 wxArrayString lines
;
10668 wxCoord extentMax
= 0;
10670 const int numRowsOrCols
= calcRows
? m_numRows
: m_numCols
;
10671 for ( int rowOrCol
= 0; rowOrCol
< numRowsOrCols
; rowOrCol
++ )
10675 wxString label
= calcRows
? GetRowLabelValue(rowOrCol
)
10676 : GetColLabelValue(rowOrCol
);
10677 StringToLines(label
, lines
);
10680 GetTextBoxSize(dc
, lines
, &w
, &h
);
10682 const wxCoord extent
= useWidth
? w
: h
;
10683 if ( extent
> extentMax
)
10684 extentMax
= extent
;
10689 // empty column - give default extent (notice that if extentMax is less
10690 // than default extent but != 0, it's OK)
10691 extentMax
= calcRows
? GetDefaultRowLabelSize()
10692 : GetDefaultColLabelSize();
10695 // leave some space around text (taken from AutoSizeColOrRow)
10704 int wxGrid::SetOrCalcColumnSizes(bool calcOnly
, bool setAsMin
)
10706 int width
= m_rowLabelWidth
;
10708 wxGridUpdateLocker locker
;
10710 locker
.Create(this);
10712 for ( int col
= 0; col
< m_numCols
; col
++ )
10715 AutoSizeColumn(col
, setAsMin
);
10717 width
+= GetColWidth(col
);
10723 int wxGrid::SetOrCalcRowSizes(bool calcOnly
, bool setAsMin
)
10725 int height
= m_colLabelHeight
;
10727 wxGridUpdateLocker locker
;
10729 locker
.Create(this);
10731 for ( int row
= 0; row
< m_numRows
; row
++ )
10734 AutoSizeRow(row
, setAsMin
);
10736 height
+= GetRowHeight(row
);
10742 void wxGrid::AutoSize()
10744 wxGridUpdateLocker
locker(this);
10746 // we need to round up the size of the scrollable area to a multiple of
10747 // scroll step to ensure that we don't get the scrollbars when we're sized
10748 // exactly to fit our contents
10749 wxSize
size(SetOrCalcColumnSizes(false) - m_rowLabelWidth
+ m_extraWidth
,
10750 SetOrCalcRowSizes(false) - m_colLabelHeight
+ m_extraHeight
);
10751 wxSize
sizeFit(GetScrollX(size
.x
) * GetScrollLineX(),
10752 GetScrollY(size
.y
) * GetScrollLineY());
10754 // distribute the extra space between the columns/rows to avoid having
10755 // extra white space
10756 wxCoord diff
= sizeFit
.x
- size
.x
;
10757 if ( diff
&& m_numCols
)
10759 // try to resize the columns uniformly
10760 wxCoord diffPerCol
= diff
/ m_numCols
;
10763 for ( int col
= 0; col
< m_numCols
; col
++ )
10765 SetColSize(col
, GetColWidth(col
) + diffPerCol
);
10769 // add remaining amount to the last columns
10770 diff
-= diffPerCol
* m_numCols
;
10773 for ( int col
= m_numCols
- 1; col
>= m_numCols
- diff
; col
-- )
10775 SetColSize(col
, GetColWidth(col
) + 1);
10781 diff
= sizeFit
.y
- size
.y
;
10782 if ( diff
&& m_numRows
)
10784 // try to resize the columns uniformly
10785 wxCoord diffPerRow
= diff
/ m_numRows
;
10788 for ( int row
= 0; row
< m_numRows
; row
++ )
10790 SetRowSize(row
, GetRowHeight(row
) + diffPerRow
);
10794 // add remaining amount to the last rows
10795 diff
-= diffPerRow
* m_numRows
;
10798 for ( int row
= m_numRows
- 1; row
>= m_numRows
- diff
; row
-- )
10800 SetRowSize(row
, GetRowHeight(row
) + 1);
10805 // we know that we're not going to have scrollbars so disable them now to
10806 // avoid trouble in SetClientSize() which can otherwise set the correct
10807 // client size but also leave space for (not needed any more) scrollbars
10808 SetScrollbars(0, 0, 0, 0, 0, 0, true);
10809 SetClientSize(sizeFit
.x
+ m_rowLabelWidth
, sizeFit
.y
+ m_colLabelHeight
);
10812 void wxGrid::AutoSizeRowLabelSize( int row
)
10814 // Hide the edit control, so it
10815 // won't interfere with drag-shrinking.
10816 if ( IsCellEditControlShown() )
10818 HideCellEditControl();
10819 SaveEditControlValue();
10822 // autosize row height depending on label text
10823 SetRowSize(row
, -1);
10827 void wxGrid::AutoSizeColLabelSize( int col
)
10829 // Hide the edit control, so it
10830 // won't interfere with drag-shrinking.
10831 if ( IsCellEditControlShown() )
10833 HideCellEditControl();
10834 SaveEditControlValue();
10837 // autosize column width depending on label text
10838 SetColSize(col
, -1);
10842 wxSize
wxGrid::DoGetBestSize() const
10844 wxGrid
*self
= (wxGrid
*)this; // const_cast
10846 // we do the same as in AutoSize() here with the exception that we don't
10847 // change the column/row sizes, only calculate them
10848 wxSize
size(self
->SetOrCalcColumnSizes(true) - m_rowLabelWidth
+ m_extraWidth
,
10849 self
->SetOrCalcRowSizes(true) - m_colLabelHeight
+ m_extraHeight
);
10850 wxSize
sizeFit(GetScrollX(size
.x
) * GetScrollLineX(),
10851 GetScrollY(size
.y
) * GetScrollLineY());
10853 // NOTE: This size should be cached, but first we need to add calls to
10854 // InvalidateBestSize everywhere that could change the results of this
10856 // CacheBestSize(size);
10858 return wxSize(sizeFit
.x
+ m_rowLabelWidth
, sizeFit
.y
+ m_colLabelHeight
)
10859 + GetWindowBorderSize();
10867 wxPen
& wxGrid::GetDividerPen() const
10872 // ----------------------------------------------------------------------------
10873 // cell value accessor functions
10874 // ----------------------------------------------------------------------------
10876 void wxGrid::SetCellValue( int row
, int col
, const wxString
& s
)
10880 m_table
->SetValue( row
, col
, s
);
10881 if ( !GetBatchCount() )
10884 wxRect
rect( CellToRect( row
, col
) );
10886 rect
.width
= m_gridWin
->GetClientSize().GetWidth();
10887 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
10888 m_gridWin
->Refresh( false, &rect
);
10891 if ( m_currentCellCoords
.GetRow() == row
&&
10892 m_currentCellCoords
.GetCol() == col
&&
10893 IsCellEditControlShown())
10894 // Note: If we are using IsCellEditControlEnabled,
10895 // this interacts badly with calling SetCellValue from
10896 // an EVT_GRID_CELL_CHANGE handler.
10898 HideCellEditControl();
10899 ShowCellEditControl(); // will reread data from table
10904 // ----------------------------------------------------------------------------
10905 // block, row and column selection
10906 // ----------------------------------------------------------------------------
10908 void wxGrid::SelectRow( int row
, bool addToSelected
)
10910 if ( IsSelection() && !addToSelected
)
10914 m_selection
->SelectRow( row
, false, addToSelected
);
10917 void wxGrid::SelectCol( int col
, bool addToSelected
)
10919 if ( IsSelection() && !addToSelected
)
10923 m_selection
->SelectCol( col
, false, addToSelected
);
10926 void wxGrid::SelectBlock( int topRow
, int leftCol
, int bottomRow
, int rightCol
,
10927 bool addToSelected
)
10929 if ( IsSelection() && !addToSelected
)
10933 m_selection
->SelectBlock( topRow
, leftCol
, bottomRow
, rightCol
,
10934 false, addToSelected
);
10937 void wxGrid::SelectAll()
10939 if ( m_numRows
> 0 && m_numCols
> 0 )
10942 m_selection
->SelectBlock( 0, 0, m_numRows
- 1, m_numCols
- 1 );
10946 // ----------------------------------------------------------------------------
10947 // cell, row and col deselection
10948 // ----------------------------------------------------------------------------
10950 void wxGrid::DeselectRow( int row
)
10952 if ( !m_selection
)
10955 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectRows
)
10957 if ( m_selection
->IsInSelection(row
, 0 ) )
10958 m_selection
->ToggleCellSelection(row
, 0);
10962 int nCols
= GetNumberCols();
10963 for ( int i
= 0; i
< nCols
; i
++ )
10965 if ( m_selection
->IsInSelection(row
, i
) )
10966 m_selection
->ToggleCellSelection(row
, i
);
10971 void wxGrid::DeselectCol( int col
)
10973 if ( !m_selection
)
10976 if ( m_selection
->GetSelectionMode() == wxGrid::wxGridSelectColumns
)
10978 if ( m_selection
->IsInSelection(0, col
) )
10979 m_selection
->ToggleCellSelection(0, col
);
10983 int nRows
= GetNumberRows();
10984 for ( int i
= 0; i
< nRows
; i
++ )
10986 if ( m_selection
->IsInSelection(i
, col
) )
10987 m_selection
->ToggleCellSelection(i
, col
);
10992 void wxGrid::DeselectCell( int row
, int col
)
10994 if ( m_selection
&& m_selection
->IsInSelection(row
, col
) )
10995 m_selection
->ToggleCellSelection(row
, col
);
10998 bool wxGrid::IsSelection() const
11000 return ( m_selection
&& (m_selection
->IsSelection() ||
11001 ( m_selectingTopLeft
!= wxGridNoCellCoords
&&
11002 m_selectingBottomRight
!= wxGridNoCellCoords
) ) );
11005 bool wxGrid::IsInSelection( int row
, int col
) const
11007 return ( m_selection
&& (m_selection
->IsInSelection( row
, col
) ||
11008 ( row
>= m_selectingTopLeft
.GetRow() &&
11009 col
>= m_selectingTopLeft
.GetCol() &&
11010 row
<= m_selectingBottomRight
.GetRow() &&
11011 col
<= m_selectingBottomRight
.GetCol() )) );
11014 wxGridCellCoordsArray
wxGrid::GetSelectedCells() const
11018 wxGridCellCoordsArray a
;
11022 return m_selection
->m_cellSelection
;
11025 wxGridCellCoordsArray
wxGrid::GetSelectionBlockTopLeft() const
11029 wxGridCellCoordsArray a
;
11033 return m_selection
->m_blockSelectionTopLeft
;
11036 wxGridCellCoordsArray
wxGrid::GetSelectionBlockBottomRight() const
11040 wxGridCellCoordsArray a
;
11044 return m_selection
->m_blockSelectionBottomRight
;
11047 wxArrayInt
wxGrid::GetSelectedRows() const
11055 return m_selection
->m_rowSelection
;
11058 wxArrayInt
wxGrid::GetSelectedCols() const
11066 return m_selection
->m_colSelection
;
11069 void wxGrid::ClearSelection()
11071 wxRect r1
= BlockToDeviceRect( m_selectingTopLeft
, m_selectingBottomRight
);
11072 wxRect r2
= BlockToDeviceRect( m_currentCellCoords
, m_selectingKeyboard
);
11073 m_selectingTopLeft
=
11074 m_selectingBottomRight
=
11075 m_selectingKeyboard
= wxGridNoCellCoords
;
11076 Refresh( false, &r1
);
11077 Refresh( false, &r2
);
11079 m_selection
->ClearSelection();
11082 // This function returns the rectangle that encloses the given block
11083 // in device coords clipped to the client size of the grid window.
11085 wxRect
wxGrid::BlockToDeviceRect( const wxGridCellCoords
& topLeft
,
11086 const wxGridCellCoords
& bottomRight
) const
11089 wxRect tempCellRect
= CellToRect(topLeft
);
11090 if ( tempCellRect
!= wxGridNoCellRect
)
11092 resultRect
= tempCellRect
;
11096 resultRect
= wxRect(0, 0, 0, 0);
11099 tempCellRect
= CellToRect(bottomRight
);
11100 if ( tempCellRect
!= wxGridNoCellRect
)
11102 resultRect
+= tempCellRect
;
11106 // If both inputs were "wxGridNoCellRect," then there's nothing to do.
11107 return wxGridNoCellRect
;
11110 // Ensure that left/right and top/bottom pairs are in order.
11111 int left
= resultRect
.GetLeft();
11112 int top
= resultRect
.GetTop();
11113 int right
= resultRect
.GetRight();
11114 int bottom
= resultRect
.GetBottom();
11116 int leftCol
= topLeft
.GetCol();
11117 int topRow
= topLeft
.GetRow();
11118 int rightCol
= bottomRight
.GetCol();
11119 int bottomRow
= bottomRight
.GetRow();
11128 leftCol
= rightCol
;
11139 topRow
= bottomRow
;
11143 // The following loop is ONLY necessary to detect and handle merged cells.
11145 m_gridWin
->GetClientSize( &cw
, &ch
);
11147 // Get the origin coordinates: notice that they will be negative if the
11148 // grid is scrolled downwards/to the right.
11149 int gridOriginX
= 0;
11150 int gridOriginY
= 0;
11151 CalcScrolledPosition(gridOriginX
, gridOriginY
, &gridOriginX
, &gridOriginY
);
11153 int onScreenLeftmostCol
= internalXToCol(-gridOriginX
);
11154 int onScreenUppermostRow
= internalYToRow(-gridOriginY
);
11156 int onScreenRightmostCol
= internalXToCol(-gridOriginX
+ cw
);
11157 int onScreenBottommostRow
= internalYToRow(-gridOriginY
+ ch
);
11159 // Bound our loop so that we only examine the portion of the selected block
11160 // that is shown on screen. Therefore, we compare the Top-Left block values
11161 // to the Top-Left screen values, and the Bottom-Right block values to the
11162 // Bottom-Right screen values, choosing appropriately.
11163 const int visibleTopRow
= wxMax(topRow
, onScreenUppermostRow
);
11164 const int visibleBottomRow
= wxMin(bottomRow
, onScreenBottommostRow
);
11165 const int visibleLeftCol
= wxMax(leftCol
, onScreenLeftmostCol
);
11166 const int visibleRightCol
= wxMin(rightCol
, onScreenRightmostCol
);
11168 for ( int j
= visibleTopRow
; j
<= visibleBottomRow
; j
++ )
11170 for ( int i
= visibleLeftCol
; i
<= visibleRightCol
; i
++ )
11172 if ( (j
== visibleTopRow
) || (j
== visibleBottomRow
) ||
11173 (i
== visibleLeftCol
) || (i
== visibleRightCol
) )
11175 tempCellRect
= CellToRect( j
, i
);
11177 if (tempCellRect
.x
< left
)
11178 left
= tempCellRect
.x
;
11179 if (tempCellRect
.y
< top
)
11180 top
= tempCellRect
.y
;
11181 if (tempCellRect
.x
+ tempCellRect
.width
> right
)
11182 right
= tempCellRect
.x
+ tempCellRect
.width
;
11183 if (tempCellRect
.y
+ tempCellRect
.height
> bottom
)
11184 bottom
= tempCellRect
.y
+ tempCellRect
.height
;
11188 i
= visibleRightCol
; // jump over inner cells.
11193 // Convert to scrolled coords
11194 CalcScrolledPosition( left
, top
, &left
, &top
);
11195 CalcScrolledPosition( right
, bottom
, &right
, &bottom
);
11197 if (right
< 0 || bottom
< 0 || left
> cw
|| top
> ch
)
11198 return wxRect(0,0,0,0);
11200 resultRect
.SetLeft( wxMax(0, left
) );
11201 resultRect
.SetTop( wxMax(0, top
) );
11202 resultRect
.SetRight( wxMin(cw
, right
) );
11203 resultRect
.SetBottom( wxMin(ch
, bottom
) );
11208 // ----------------------------------------------------------------------------
11210 // ----------------------------------------------------------------------------
11212 #if wxUSE_DRAG_AND_DROP
11214 // this allow setting drop target directly on wxGrid
11215 void wxGrid::SetDropTarget(wxDropTarget
*dropTarget
)
11217 GetGridWindow()->SetDropTarget(dropTarget
);
11220 #endif // wxUSE_DRAG_AND_DROP
11222 // ----------------------------------------------------------------------------
11223 // grid event classes
11224 // ----------------------------------------------------------------------------
11226 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent
, wxNotifyEvent
)
11228 wxGridEvent::wxGridEvent( int id
, wxEventType type
, wxObject
* obj
,
11229 int row
, int col
, int x
, int y
, bool sel
,
11230 bool control
, bool shift
, bool alt
, bool meta
)
11231 : wxNotifyEvent( type
, id
)
11238 m_control
= control
;
11243 SetEventObject(obj
);
11247 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent
, wxNotifyEvent
)
11249 wxGridSizeEvent::wxGridSizeEvent( int id
, wxEventType type
, wxObject
* obj
,
11250 int rowOrCol
, int x
, int y
,
11251 bool control
, bool shift
, bool alt
, bool meta
)
11252 : wxNotifyEvent( type
, id
)
11254 m_rowOrCol
= rowOrCol
;
11257 m_control
= control
;
11262 SetEventObject(obj
);
11266 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent
, wxNotifyEvent
)
11268 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id
, wxEventType type
, wxObject
* obj
,
11269 const wxGridCellCoords
& topLeft
,
11270 const wxGridCellCoords
& bottomRight
,
11271 bool sel
, bool control
,
11272 bool shift
, bool alt
, bool meta
)
11273 : wxNotifyEvent( type
, id
)
11275 m_topLeft
= topLeft
;
11276 m_bottomRight
= bottomRight
;
11278 m_control
= control
;
11283 SetEventObject(obj
);
11287 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent
, wxCommandEvent
)
11289 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id
, wxEventType type
,
11290 wxObject
* obj
, int row
,
11291 int col
, wxControl
* ctrl
)
11292 : wxCommandEvent(type
, id
)
11294 SetEventObject(obj
);
11300 #endif // wxUSE_GRID