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 /////////////////////////////////////////////////////////////////////////////
15 - Replace use of wxINVERT with wxOverlay
16 - Make Begin/EndBatch() the same as the generic Freeze/Thaw()
17 - Review the column reordering code, it's a mess.
18 - Implement row reordering after dealing with the columns.
21 // For compilers that support precompilation, includes "wx/wx.h".
22 #include "wx/wxprec.h"
34 #include "wx/dcclient.h"
35 #include "wx/settings.h"
37 #include "wx/textctrl.h"
38 #include "wx/checkbox.h"
39 #include "wx/combobox.h"
40 #include "wx/valtext.h"
43 #include "wx/listbox.h"
46 #include "wx/textfile.h"
47 #include "wx/spinctrl.h"
48 #include "wx/tokenzr.h"
49 #include "wx/renderer.h"
50 #include "wx/headerctrl.h"
51 #include "wx/hashset.h"
53 #include "wx/generic/gridsel.h"
54 #include "wx/generic/gridctrl.h"
55 #include "wx/generic/grideditors.h"
56 #include "wx/generic/private/grid.h"
58 const char wxGridNameStr
[] = "grid";
60 #if defined(__WXMOTIF__)
61 #define WXUNUSED_MOTIF(identifier) WXUNUSED(identifier)
63 #define WXUNUSED_MOTIF(identifier) identifier
66 #if defined(__WXGTK__)
67 #define WXUNUSED_GTK(identifier) WXUNUSED(identifier)
69 #define WXUNUSED_GTK(identifier) identifier
72 // Required for wxIs... functions
75 WX_DECLARE_HASH_SET_WITH_DECL_PTR(int, wxIntegerHash
, wxIntegerEqual
,
76 wxGridFixedIndicesSet
, class WXDLLIMPEXP_ADV
);
79 // ----------------------------------------------------------------------------
81 // ----------------------------------------------------------------------------
86 //#define DEBUG_ATTR_CACHE
87 #ifdef DEBUG_ATTR_CACHE
88 static size_t gs_nAttrCacheHits
= 0;
89 static size_t gs_nAttrCacheMisses
= 0;
92 // this struct simply combines together the default header renderers
94 // as the renderers ctors are trivial, there is no problem with making them
96 struct DefaultHeaderRenderers
98 wxGridColumnHeaderRendererDefault colRenderer
;
99 wxGridRowHeaderRendererDefault rowRenderer
;
100 wxGridCornerHeaderRendererDefault cornerRenderer
;
101 } gs_defaultHeaderRenderers
;
103 } // anonymous namespace
105 // ----------------------------------------------------------------------------
107 // ----------------------------------------------------------------------------
109 wxGridCellCoords
wxGridNoCellCoords( -1, -1 );
110 wxRect
wxGridNoCellRect( -1, -1, -1, -1 );
116 const size_t GRID_SCROLL_LINE_X
= 15;
117 const size_t GRID_SCROLL_LINE_Y
= GRID_SCROLL_LINE_X
;
119 // the size of hash tables used a bit everywhere (the max number of elements
120 // in these hash tables is the number of rows/columns)
121 const int GRID_HASH_SIZE
= 100;
123 // the minimal distance in pixels the mouse needs to move to start a drag
125 const int DRAG_SENSITIVITY
= 3;
127 } // anonymous namespace
129 #include "wx/arrimpl.cpp"
131 WX_DEFINE_OBJARRAY(wxGridCellCoordsArray
)
132 WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray
)
134 // ----------------------------------------------------------------------------
136 // ----------------------------------------------------------------------------
138 wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_CLICK
, wxGridEvent
);
139 wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_CLICK
, wxGridEvent
);
140 wxDEFINE_EVENT( wxEVT_GRID_CELL_LEFT_DCLICK
, wxGridEvent
);
141 wxDEFINE_EVENT( wxEVT_GRID_CELL_RIGHT_DCLICK
, wxGridEvent
);
142 wxDEFINE_EVENT( wxEVT_GRID_CELL_BEGIN_DRAG
, wxGridEvent
);
143 wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_CLICK
, wxGridEvent
);
144 wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_CLICK
, wxGridEvent
);
145 wxDEFINE_EVENT( wxEVT_GRID_LABEL_LEFT_DCLICK
, wxGridEvent
);
146 wxDEFINE_EVENT( wxEVT_GRID_LABEL_RIGHT_DCLICK
, wxGridEvent
);
147 wxDEFINE_EVENT( wxEVT_GRID_ROW_SIZE
, wxGridSizeEvent
);
148 wxDEFINE_EVENT( wxEVT_GRID_COL_SIZE
, wxGridSizeEvent
);
149 wxDEFINE_EVENT( wxEVT_GRID_COL_MOVE
, wxGridEvent
);
150 wxDEFINE_EVENT( wxEVT_GRID_COL_SORT
, wxGridEvent
);
151 wxDEFINE_EVENT( wxEVT_GRID_RANGE_SELECT
, wxGridRangeSelectEvent
);
152 wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGING
, wxGridEvent
);
153 wxDEFINE_EVENT( wxEVT_GRID_CELL_CHANGED
, wxGridEvent
);
154 wxDEFINE_EVENT( wxEVT_GRID_SELECT_CELL
, wxGridEvent
);
155 wxDEFINE_EVENT( wxEVT_GRID_EDITOR_SHOWN
, wxGridEvent
);
156 wxDEFINE_EVENT( wxEVT_GRID_EDITOR_HIDDEN
, wxGridEvent
);
157 wxDEFINE_EVENT( wxEVT_GRID_EDITOR_CREATED
, wxGridEditorCreatedEvent
);
158 wxDEFINE_EVENT( wxEVT_GRID_TABBING
, wxGridEvent
);
160 // ----------------------------------------------------------------------------
162 // ----------------------------------------------------------------------------
167 // ensure that first is less or equal to second, swapping the values if
169 void EnsureFirstLessThanSecond(int& first
, int& second
)
171 if ( first
> second
)
172 wxSwap(first
, second
);
175 } // anonymous namespace
177 // ============================================================================
179 // ============================================================================
181 IMPLEMENT_ABSTRACT_CLASS(wxGridCellEditorEvtHandler
, wxEvtHandler
)
183 BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler
, wxEvtHandler
)
184 EVT_KILL_FOCUS( wxGridCellEditorEvtHandler::OnKillFocus
)
185 EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown
)
186 EVT_CHAR( wxGridCellEditorEvtHandler::OnChar
)
189 BEGIN_EVENT_TABLE(wxGridHeaderCtrl
, wxHeaderCtrl
)
190 EVT_HEADER_CLICK(wxID_ANY
, wxGridHeaderCtrl::OnClick
)
191 EVT_HEADER_DCLICK(wxID_ANY
, wxGridHeaderCtrl::OnDoubleClick
)
192 EVT_HEADER_RIGHT_CLICK(wxID_ANY
, wxGridHeaderCtrl::OnRightClick
)
194 EVT_HEADER_BEGIN_RESIZE(wxID_ANY
, wxGridHeaderCtrl::OnBeginResize
)
195 EVT_HEADER_RESIZING(wxID_ANY
, wxGridHeaderCtrl::OnResizing
)
196 EVT_HEADER_END_RESIZE(wxID_ANY
, wxGridHeaderCtrl::OnEndResize
)
198 EVT_HEADER_BEGIN_REORDER(wxID_ANY
, wxGridHeaderCtrl::OnBeginReorder
)
199 EVT_HEADER_END_REORDER(wxID_ANY
, wxGridHeaderCtrl::OnEndReorder
)
202 wxGridOperations
& wxGridRowOperations::Dual() const
204 static wxGridColumnOperations s_colOper
;
209 wxGridOperations
& wxGridColumnOperations::Dual() const
211 static wxGridRowOperations s_rowOper
;
216 // ----------------------------------------------------------------------------
217 // wxGridCellWorker is an (almost) empty common base class for
218 // wxGridCellRenderer and wxGridCellEditor managing ref counting
219 // ----------------------------------------------------------------------------
221 void wxGridCellWorker::SetParameters(const wxString
& WXUNUSED(params
))
226 wxGridCellWorker::~wxGridCellWorker()
230 // ----------------------------------------------------------------------------
231 // wxGridHeaderLabelsRenderer and related classes
232 // ----------------------------------------------------------------------------
234 void wxGridHeaderLabelsRenderer::DrawLabel(const wxGrid
& grid
,
236 const wxString
& value
,
240 int textOrientation
) const
242 dc
.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT
);
243 dc
.SetTextForeground(grid
.GetLabelTextColour());
244 dc
.SetFont(grid
.GetLabelFont());
245 grid
.DrawTextRectangle(dc
, value
, rect
, horizAlign
, vertAlign
, textOrientation
);
249 void wxGridRowHeaderRendererDefault::DrawBorder(const wxGrid
& WXUNUSED(grid
),
253 dc
.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
)));
254 dc
.DrawLine(rect
.GetRight(), rect
.GetTop(),
255 rect
.GetRight(), rect
.GetBottom());
256 dc
.DrawLine(rect
.GetLeft(), rect
.GetTop(),
257 rect
.GetLeft(), rect
.GetBottom());
258 dc
.DrawLine(rect
.GetLeft(), rect
.GetBottom(),
259 rect
.GetRight() + 1, rect
.GetBottom());
261 dc
.SetPen(*wxWHITE_PEN
);
262 dc
.DrawLine(rect
.GetLeft() + 1, rect
.GetTop(),
263 rect
.GetLeft() + 1, rect
.GetBottom());
264 dc
.DrawLine(rect
.GetLeft() + 1, rect
.GetTop(),
265 rect
.GetRight(), rect
.GetTop());
270 void wxGridColumnHeaderRendererDefault::DrawBorder(const wxGrid
& WXUNUSED(grid
),
274 dc
.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
)));
275 dc
.DrawLine(rect
.GetRight(), rect
.GetTop(),
276 rect
.GetRight(), rect
.GetBottom());
277 dc
.DrawLine(rect
.GetLeft(), rect
.GetTop(),
278 rect
.GetRight(), rect
.GetTop());
279 dc
.DrawLine(rect
.GetLeft(), rect
.GetBottom(),
280 rect
.GetRight() + 1, rect
.GetBottom());
282 dc
.SetPen(*wxWHITE_PEN
);
283 dc
.DrawLine(rect
.GetLeft(), rect
.GetTop() + 1,
284 rect
.GetLeft(), rect
.GetBottom());
285 dc
.DrawLine(rect
.GetLeft(), rect
.GetTop() + 1,
286 rect
.GetRight(), rect
.GetTop() + 1);
291 void wxGridCornerHeaderRendererDefault::DrawBorder(const wxGrid
& WXUNUSED(grid
),
295 dc
.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW
)));
296 dc
.DrawLine(rect
.GetRight() - 1, rect
.GetBottom() - 1,
297 rect
.GetRight() - 1, rect
.GetTop());
298 dc
.DrawLine(rect
.GetRight() - 1, rect
.GetBottom() - 1,
299 rect
.GetLeft(), rect
.GetBottom() - 1);
300 dc
.DrawLine(rect
.GetLeft(), rect
.GetTop(),
301 rect
.GetRight(), rect
.GetTop());
302 dc
.DrawLine(rect
.GetLeft(), rect
.GetTop(),
303 rect
.GetLeft(), rect
.GetBottom());
305 dc
.SetPen(*wxWHITE_PEN
);
306 dc
.DrawLine(rect
.GetLeft() + 1, rect
.GetTop() + 1,
307 rect
.GetRight() - 1, rect
.GetTop() + 1);
308 dc
.DrawLine(rect
.GetLeft() + 1, rect
.GetTop() + 1,
309 rect
.GetLeft() + 1, rect
.GetBottom() - 1);
314 // ----------------------------------------------------------------------------
316 // ----------------------------------------------------------------------------
318 void wxGridCellAttr::Init(wxGridCellAttr
*attrDefault
)
320 m_isReadOnly
= Unset
;
325 m_attrkind
= wxGridCellAttr::Cell
;
327 m_sizeRows
= m_sizeCols
= 1;
328 m_overflow
= UnsetOverflow
;
330 SetDefAttr(attrDefault
);
333 wxGridCellAttr
*wxGridCellAttr::Clone() const
335 wxGridCellAttr
*attr
= new wxGridCellAttr(m_defGridAttr
);
337 if ( HasTextColour() )
338 attr
->SetTextColour(GetTextColour());
339 if ( HasBackgroundColour() )
340 attr
->SetBackgroundColour(GetBackgroundColour());
342 attr
->SetFont(GetFont());
343 if ( HasAlignment() )
344 attr
->SetAlignment(m_hAlign
, m_vAlign
);
346 attr
->SetSize( m_sizeRows
, m_sizeCols
);
350 attr
->SetRenderer(m_renderer
);
351 m_renderer
->IncRef();
355 attr
->SetEditor(m_editor
);
362 attr
->SetOverflow( m_overflow
== Overflow
);
363 attr
->SetKind( m_attrkind
);
368 void wxGridCellAttr::MergeWith(wxGridCellAttr
*mergefrom
)
370 if ( !HasTextColour() && mergefrom
->HasTextColour() )
371 SetTextColour(mergefrom
->GetTextColour());
372 if ( !HasBackgroundColour() && mergefrom
->HasBackgroundColour() )
373 SetBackgroundColour(mergefrom
->GetBackgroundColour());
374 if ( !HasFont() && mergefrom
->HasFont() )
375 SetFont(mergefrom
->GetFont());
376 if ( !HasAlignment() && mergefrom
->HasAlignment() )
379 mergefrom
->GetAlignment( &hAlign
, &vAlign
);
380 SetAlignment(hAlign
, vAlign
);
382 if ( !HasSize() && mergefrom
->HasSize() )
383 mergefrom
->GetSize( &m_sizeRows
, &m_sizeCols
);
385 // Directly access member functions as GetRender/Editor don't just return
386 // m_renderer/m_editor
388 // Maybe add support for merge of Render and Editor?
389 if (!HasRenderer() && mergefrom
->HasRenderer() )
391 m_renderer
= mergefrom
->m_renderer
;
392 m_renderer
->IncRef();
394 if ( !HasEditor() && mergefrom
->HasEditor() )
396 m_editor
= mergefrom
->m_editor
;
399 if ( !HasReadWriteMode() && mergefrom
->HasReadWriteMode() )
400 SetReadOnly(mergefrom
->IsReadOnly());
402 if (!HasOverflowMode() && mergefrom
->HasOverflowMode() )
403 SetOverflow(mergefrom
->GetOverflow());
405 SetDefAttr(mergefrom
->m_defGridAttr
);
408 void wxGridCellAttr::SetSize(int num_rows
, int num_cols
)
410 // The size of a cell is normally 1,1
412 // If this cell is larger (2,2) then this is the top left cell
413 // the other cells that will be covered (lower right cells) must be
414 // set to negative or zero values such that
415 // row + num_rows of the covered cell points to the larger cell (this cell)
416 // same goes for the col + num_cols.
418 // Size of 0,0 is NOT valid, neither is <=0 and any positive value
420 wxASSERT_MSG( (!((num_rows
> 0) && (num_cols
<= 0)) ||
421 !((num_rows
<= 0) && (num_cols
> 0)) ||
422 !((num_rows
== 0) && (num_cols
== 0))),
423 wxT("wxGridCellAttr::SetSize only takes two positive values or negative/zero values"));
425 m_sizeRows
= num_rows
;
426 m_sizeCols
= num_cols
;
429 const wxColour
& wxGridCellAttr::GetTextColour() const
435 else if (m_defGridAttr
&& m_defGridAttr
!= this)
437 return m_defGridAttr
->GetTextColour();
441 wxFAIL_MSG(wxT("Missing default cell attribute"));
446 const wxColour
& wxGridCellAttr::GetBackgroundColour() const
448 if (HasBackgroundColour())
452 else if (m_defGridAttr
&& m_defGridAttr
!= this)
454 return m_defGridAttr
->GetBackgroundColour();
458 wxFAIL_MSG(wxT("Missing default cell attribute"));
463 const wxFont
& wxGridCellAttr::GetFont() const
469 else if (m_defGridAttr
&& m_defGridAttr
!= this)
471 return m_defGridAttr
->GetFont();
475 wxFAIL_MSG(wxT("Missing default cell attribute"));
480 void wxGridCellAttr::GetAlignment(int *hAlign
, int *vAlign
) const
489 else if (m_defGridAttr
&& m_defGridAttr
!= this)
491 m_defGridAttr
->GetAlignment(hAlign
, vAlign
);
495 wxFAIL_MSG(wxT("Missing default cell attribute"));
499 void wxGridCellAttr::GetNonDefaultAlignment(int *hAlign
, int *vAlign
) const
501 if ( hAlign
&& m_hAlign
!= wxALIGN_INVALID
)
504 if ( vAlign
&& m_vAlign
!= wxALIGN_INVALID
)
508 void wxGridCellAttr::GetSize( int *num_rows
, int *num_cols
) const
511 *num_rows
= m_sizeRows
;
513 *num_cols
= m_sizeCols
;
516 // GetRenderer and GetEditor use a slightly different decision path about
517 // which attribute to use. If a non-default attr object has one then it is
518 // used, otherwise the default editor or renderer is fetched from the grid and
519 // used. It should be the default for the data type of the cell. If it is
520 // NULL (because the table has a type that the grid does not have in its
521 // registry), then the grid's default editor or renderer is used.
523 wxGridCellRenderer
* wxGridCellAttr::GetRenderer(const wxGrid
* grid
, int row
, int col
) const
525 wxGridCellRenderer
*renderer
= NULL
;
527 if ( m_renderer
&& this != m_defGridAttr
)
529 // use the cells renderer if it has one
530 renderer
= m_renderer
;
533 else // no non-default cell renderer
535 // get default renderer for the data type
538 // GetDefaultRendererForCell() will do IncRef() for us
539 renderer
= grid
->GetDefaultRendererForCell(row
, col
);
542 if ( renderer
== NULL
)
544 if ( (m_defGridAttr
!= NULL
) && (m_defGridAttr
!= this) )
546 // if we still don't have one then use the grid default
547 // (no need for IncRef() here neither)
548 renderer
= m_defGridAttr
->GetRenderer(NULL
, 0, 0);
550 else // default grid attr
552 // use m_renderer which we had decided not to use initially
553 renderer
= m_renderer
;
560 // we're supposed to always find something
561 wxASSERT_MSG(renderer
, wxT("Missing default cell renderer"));
566 // same as above, except for s/renderer/editor/g
567 wxGridCellEditor
* wxGridCellAttr::GetEditor(const wxGrid
* grid
, int row
, int col
) const
569 wxGridCellEditor
*editor
= NULL
;
571 if ( m_editor
&& this != m_defGridAttr
)
573 // use the cells editor if it has one
577 else // no non default cell editor
579 // get default editor for the data type
582 // GetDefaultEditorForCell() will do IncRef() for us
583 editor
= grid
->GetDefaultEditorForCell(row
, col
);
586 if ( editor
== NULL
)
588 if ( (m_defGridAttr
!= NULL
) && (m_defGridAttr
!= this) )
590 // if we still don't have one then use the grid default
591 // (no need for IncRef() here neither)
592 editor
= m_defGridAttr
->GetEditor(NULL
, 0, 0);
594 else // default grid attr
596 // use m_editor which we had decided not to use initially
604 // we're supposed to always find something
605 wxASSERT_MSG(editor
, wxT("Missing default cell editor"));
610 // ----------------------------------------------------------------------------
611 // wxGridCellAttrData
612 // ----------------------------------------------------------------------------
614 void wxGridCellAttrData::SetAttr(wxGridCellAttr
*attr
, int row
, int col
)
616 // Note: contrary to wxGridRowOrColAttrData::SetAttr, we must not
617 // touch attribute's reference counting explicitly, since this
618 // is managed by class wxGridCellWithAttr
619 int n
= FindIndex(row
, col
);
620 if ( n
== wxNOT_FOUND
)
625 m_attrs
.Add(new wxGridCellWithAttr(row
, col
, attr
));
627 //else: nothing to do
629 else // we already have an attribute for this cell
633 // change the attribute
634 m_attrs
[(size_t)n
].ChangeAttr(attr
);
638 // remove this attribute
639 m_attrs
.RemoveAt((size_t)n
);
644 wxGridCellAttr
*wxGridCellAttrData::GetAttr(int row
, int col
) const
646 wxGridCellAttr
*attr
= NULL
;
648 int n
= FindIndex(row
, col
);
649 if ( n
!= wxNOT_FOUND
)
651 attr
= m_attrs
[(size_t)n
].attr
;
658 void wxGridCellAttrData::UpdateAttrRows( size_t pos
, int numRows
)
660 size_t count
= m_attrs
.GetCount();
661 for ( size_t n
= 0; n
< count
; n
++ )
663 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
664 wxCoord row
= coords
.GetRow();
665 if ((size_t)row
>= pos
)
669 // If rows inserted, include row counter where necessary
670 coords
.SetRow(row
+ numRows
);
672 else if (numRows
< 0)
674 // If rows deleted ...
675 if ((size_t)row
>= pos
- numRows
)
677 // ...either decrement row counter (if row still exists)...
678 coords
.SetRow(row
+ numRows
);
682 // ...or remove the attribute
692 void wxGridCellAttrData::UpdateAttrCols( size_t pos
, int numCols
)
694 size_t count
= m_attrs
.GetCount();
695 for ( size_t n
= 0; n
< count
; n
++ )
697 wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
698 wxCoord col
= coords
.GetCol();
699 if ( (size_t)col
>= pos
)
703 // If rows inserted, include row counter where necessary
704 coords
.SetCol(col
+ numCols
);
706 else if (numCols
< 0)
708 // If rows deleted ...
709 if ((size_t)col
>= pos
- numCols
)
711 // ...either decrement row counter (if row still exists)...
712 coords
.SetCol(col
+ numCols
);
716 // ...or remove the attribute
726 int wxGridCellAttrData::FindIndex(int row
, int col
) const
728 size_t count
= m_attrs
.GetCount();
729 for ( size_t n
= 0; n
< count
; n
++ )
731 const wxGridCellCoords
& coords
= m_attrs
[n
].coords
;
732 if ( (coords
.GetRow() == row
) && (coords
.GetCol() == col
) )
741 // ----------------------------------------------------------------------------
742 // wxGridRowOrColAttrData
743 // ----------------------------------------------------------------------------
745 wxGridRowOrColAttrData::~wxGridRowOrColAttrData()
747 size_t count
= m_attrs
.GetCount();
748 for ( size_t n
= 0; n
< count
; n
++ )
750 m_attrs
[n
]->DecRef();
754 wxGridCellAttr
*wxGridRowOrColAttrData::GetAttr(int rowOrCol
) const
756 wxGridCellAttr
*attr
= NULL
;
758 int n
= m_rowsOrCols
.Index(rowOrCol
);
759 if ( n
!= wxNOT_FOUND
)
761 attr
= m_attrs
[(size_t)n
];
768 void wxGridRowOrColAttrData::SetAttr(wxGridCellAttr
*attr
, int rowOrCol
)
770 int i
= m_rowsOrCols
.Index(rowOrCol
);
771 if ( i
== wxNOT_FOUND
)
775 // store the new attribute, taking its ownership
776 m_rowsOrCols
.Add(rowOrCol
);
781 else // we have an attribute for this row or column
783 size_t n
= (size_t)i
;
785 // notice that this code works correctly even when the old attribute is
786 // the same as the new one: as we own of it, we must call DecRef() on
787 // it in any case and this won't result in destruction of the new
788 // attribute if it's the same as old one because it must have ref count
789 // of at least 2 to be passed to us while we keep a reference to it too
790 m_attrs
[n
]->DecRef();
794 // replace the attribute with the new one
797 else // remove the attribute
799 m_rowsOrCols
.RemoveAt(n
);
805 void wxGridRowOrColAttrData::UpdateAttrRowsOrCols( size_t pos
, int numRowsOrCols
)
807 size_t count
= m_attrs
.GetCount();
808 for ( size_t n
= 0; n
< count
; n
++ )
810 int & rowOrCol
= m_rowsOrCols
[n
];
811 if ( (size_t)rowOrCol
>= pos
)
813 if ( numRowsOrCols
> 0 )
815 // If rows inserted, include row counter where necessary
816 rowOrCol
+= numRowsOrCols
;
818 else if ( numRowsOrCols
< 0)
820 // If rows deleted, either decrement row counter (if row still exists)
821 if ((size_t)rowOrCol
>= pos
- numRowsOrCols
)
822 rowOrCol
+= numRowsOrCols
;
825 m_rowsOrCols
.RemoveAt(n
);
826 m_attrs
[n
]->DecRef();
836 // ----------------------------------------------------------------------------
837 // wxGridCellAttrProvider
838 // ----------------------------------------------------------------------------
840 wxGridCellAttrProvider::wxGridCellAttrProvider()
845 wxGridCellAttrProvider::~wxGridCellAttrProvider()
850 void wxGridCellAttrProvider::InitData()
852 m_data
= new wxGridCellAttrProviderData
;
855 wxGridCellAttr
*wxGridCellAttrProvider::GetAttr(int row
, int col
,
856 wxGridCellAttr::wxAttrKind kind
) const
858 wxGridCellAttr
*attr
= NULL
;
863 case (wxGridCellAttr::Any
):
864 // Get cached merge attributes.
865 // Currently not used as no cache implemented as not mutable
866 // attr = m_data->m_mergeAttr.GetAttr(row, col);
869 // Basically implement old version.
870 // Also check merge cache, so we don't have to re-merge every time..
871 wxGridCellAttr
*attrcell
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
872 wxGridCellAttr
*attrrow
= m_data
->m_rowAttrs
.GetAttr(row
);
873 wxGridCellAttr
*attrcol
= m_data
->m_colAttrs
.GetAttr(col
);
875 if ((attrcell
!= attrrow
) && (attrrow
!= attrcol
) && (attrcell
!= attrcol
))
877 // Two or more are non NULL
878 attr
= new wxGridCellAttr
;
879 attr
->SetKind(wxGridCellAttr::Merged
);
881 // Order is important..
884 attr
->MergeWith(attrcell
);
889 attr
->MergeWith(attrcol
);
894 attr
->MergeWith(attrrow
);
898 // store merge attr if cache implemented
900 //m_data->m_mergeAttr.SetAttr(attr, row, col);
904 // one or none is non null return it or null.
923 case (wxGridCellAttr::Cell
):
924 attr
= m_data
->m_cellAttrs
.GetAttr(row
, col
);
927 case (wxGridCellAttr::Col
):
928 attr
= m_data
->m_colAttrs
.GetAttr(col
);
931 case (wxGridCellAttr::Row
):
932 attr
= m_data
->m_rowAttrs
.GetAttr(row
);
937 // (wxGridCellAttr::Default):
938 // (wxGridCellAttr::Merged):
946 void wxGridCellAttrProvider::SetAttr(wxGridCellAttr
*attr
,
952 m_data
->m_cellAttrs
.SetAttr(attr
, row
, col
);
955 void wxGridCellAttrProvider::SetRowAttr(wxGridCellAttr
*attr
, int row
)
960 m_data
->m_rowAttrs
.SetAttr(attr
, row
);
963 void wxGridCellAttrProvider::SetColAttr(wxGridCellAttr
*attr
, int col
)
968 m_data
->m_colAttrs
.SetAttr(attr
, col
);
971 void wxGridCellAttrProvider::UpdateAttrRows( size_t pos
, int numRows
)
975 m_data
->m_cellAttrs
.UpdateAttrRows( pos
, numRows
);
977 m_data
->m_rowAttrs
.UpdateAttrRowsOrCols( pos
, numRows
);
981 void wxGridCellAttrProvider::UpdateAttrCols( size_t pos
, int numCols
)
985 m_data
->m_cellAttrs
.UpdateAttrCols( pos
, numCols
);
987 m_data
->m_colAttrs
.UpdateAttrRowsOrCols( pos
, numCols
);
991 const wxGridColumnHeaderRenderer
&
992 wxGridCellAttrProvider::GetColumnHeaderRenderer(int WXUNUSED(col
))
994 return gs_defaultHeaderRenderers
.colRenderer
;
997 const wxGridRowHeaderRenderer
&
998 wxGridCellAttrProvider::GetRowHeaderRenderer(int WXUNUSED(row
))
1000 return gs_defaultHeaderRenderers
.rowRenderer
;
1003 const wxGridCornerHeaderRenderer
& wxGridCellAttrProvider::GetCornerRenderer()
1005 return gs_defaultHeaderRenderers
.cornerRenderer
;
1008 // ----------------------------------------------------------------------------
1010 // ----------------------------------------------------------------------------
1012 IMPLEMENT_ABSTRACT_CLASS( wxGridTableBase
, wxObject
)
1014 wxGridTableBase::wxGridTableBase()
1017 m_attrProvider
= NULL
;
1020 wxGridTableBase::~wxGridTableBase()
1022 delete m_attrProvider
;
1025 void wxGridTableBase::SetAttrProvider(wxGridCellAttrProvider
*attrProvider
)
1027 delete m_attrProvider
;
1028 m_attrProvider
= attrProvider
;
1031 bool wxGridTableBase::CanHaveAttributes()
1033 if ( ! GetAttrProvider() )
1035 // use the default attr provider by default
1036 SetAttrProvider(new wxGridCellAttrProvider
);
1042 wxGridCellAttr
*wxGridTableBase::GetAttr(int row
, int col
, wxGridCellAttr::wxAttrKind kind
)
1044 if ( m_attrProvider
)
1045 return m_attrProvider
->GetAttr(row
, col
, kind
);
1050 void wxGridTableBase::SetAttr(wxGridCellAttr
* attr
, int row
, int col
)
1052 if ( m_attrProvider
)
1055 attr
->SetKind(wxGridCellAttr::Cell
);
1056 m_attrProvider
->SetAttr(attr
, row
, col
);
1060 // as we take ownership of the pointer and don't store it, we must
1066 void wxGridTableBase::SetRowAttr(wxGridCellAttr
*attr
, int row
)
1068 if ( m_attrProvider
)
1070 attr
->SetKind(wxGridCellAttr::Row
);
1071 m_attrProvider
->SetRowAttr(attr
, row
);
1075 // as we take ownership of the pointer and don't store it, we must
1081 void wxGridTableBase::SetColAttr(wxGridCellAttr
*attr
, int col
)
1083 if ( m_attrProvider
)
1085 attr
->SetKind(wxGridCellAttr::Col
);
1086 m_attrProvider
->SetColAttr(attr
, col
);
1090 // as we take ownership of the pointer and don't store it, we must
1096 bool wxGridTableBase::InsertRows( size_t WXUNUSED(pos
),
1097 size_t WXUNUSED(numRows
) )
1099 wxFAIL_MSG( wxT("Called grid table class function InsertRows\nbut your derived table class does not override this function") );
1104 bool wxGridTableBase::AppendRows( size_t WXUNUSED(numRows
) )
1106 wxFAIL_MSG( wxT("Called grid table class function AppendRows\nbut your derived table class does not override this function"));
1111 bool wxGridTableBase::DeleteRows( size_t WXUNUSED(pos
),
1112 size_t WXUNUSED(numRows
) )
1114 wxFAIL_MSG( wxT("Called grid table class function DeleteRows\nbut your derived table class does not override this function"));
1119 bool wxGridTableBase::InsertCols( size_t WXUNUSED(pos
),
1120 size_t WXUNUSED(numCols
) )
1122 wxFAIL_MSG( wxT("Called grid table class function InsertCols\nbut your derived table class does not override this function"));
1127 bool wxGridTableBase::AppendCols( size_t WXUNUSED(numCols
) )
1129 wxFAIL_MSG(wxT("Called grid table class function AppendCols\nbut your derived table class does not override this function"));
1134 bool wxGridTableBase::DeleteCols( size_t WXUNUSED(pos
),
1135 size_t WXUNUSED(numCols
) )
1137 wxFAIL_MSG( wxT("Called grid table class function DeleteCols\nbut your derived table class does not override this function"));
1142 wxString
wxGridTableBase::GetRowLabelValue( int row
)
1146 // RD: Starting the rows at zero confuses users,
1147 // no matter how much it makes sense to us geeks.
1153 wxString
wxGridTableBase::GetColLabelValue( int col
)
1155 // default col labels are:
1156 // cols 0 to 25 : A-Z
1157 // cols 26 to 675 : AA-ZZ
1162 for ( n
= 1; ; n
++ )
1164 s
+= (wxChar
) (wxT('A') + (wxChar
)(col
% 26));
1170 // reverse the string...
1172 for ( i
= 0; i
< n
; i
++ )
1180 wxString
wxGridTableBase::GetTypeName( int WXUNUSED(row
), int WXUNUSED(col
) )
1182 return wxGRID_VALUE_STRING
;
1185 bool wxGridTableBase::CanGetValueAs( int WXUNUSED(row
), int WXUNUSED(col
),
1186 const wxString
& typeName
)
1188 return typeName
== wxGRID_VALUE_STRING
;
1191 bool wxGridTableBase::CanSetValueAs( int row
, int col
, const wxString
& typeName
)
1193 return CanGetValueAs(row
, col
, typeName
);
1196 long wxGridTableBase::GetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
) )
1201 double wxGridTableBase::GetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
) )
1206 bool wxGridTableBase::GetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
) )
1211 void wxGridTableBase::SetValueAsLong( int WXUNUSED(row
), int WXUNUSED(col
),
1212 long WXUNUSED(value
) )
1216 void wxGridTableBase::SetValueAsDouble( int WXUNUSED(row
), int WXUNUSED(col
),
1217 double WXUNUSED(value
) )
1221 void wxGridTableBase::SetValueAsBool( int WXUNUSED(row
), int WXUNUSED(col
),
1222 bool WXUNUSED(value
) )
1226 void* wxGridTableBase::GetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
1227 const wxString
& WXUNUSED(typeName
) )
1232 void wxGridTableBase::SetValueAsCustom( int WXUNUSED(row
), int WXUNUSED(col
),
1233 const wxString
& WXUNUSED(typeName
),
1234 void* WXUNUSED(value
) )
1238 //////////////////////////////////////////////////////////////////////
1240 // Message class for the grid table to send requests and notifications
1244 wxGridTableMessage::wxGridTableMessage()
1252 wxGridTableMessage::wxGridTableMessage( wxGridTableBase
*table
, int id
,
1253 int commandInt1
, int commandInt2
)
1257 m_comInt1
= commandInt1
;
1258 m_comInt2
= commandInt2
;
1261 //////////////////////////////////////////////////////////////////////
1263 // A basic grid table for string data. An object of this class will
1264 // created by wxGrid if you don't specify an alternative table class.
1267 WX_DEFINE_OBJARRAY(wxGridStringArray
)
1269 IMPLEMENT_DYNAMIC_CLASS( wxGridStringTable
, wxGridTableBase
)
1271 wxGridStringTable::wxGridStringTable()
1277 wxGridStringTable::wxGridStringTable( int numRows
, int numCols
)
1280 m_numCols
= numCols
;
1282 m_data
.Alloc( numRows
);
1285 sa
.Alloc( numCols
);
1286 sa
.Add( wxEmptyString
, numCols
);
1288 m_data
.Add( sa
, numRows
);
1291 wxString
wxGridStringTable::GetValue( int row
, int col
)
1293 wxCHECK_MSG( (row
>= 0 && row
< GetNumberRows()) &&
1294 (col
>= 0 && col
< GetNumberCols()),
1296 wxT("invalid row or column index in wxGridStringTable") );
1298 return m_data
[row
][col
];
1301 void wxGridStringTable::SetValue( int row
, int col
, const wxString
& value
)
1303 wxCHECK_RET( (row
>= 0 && row
< GetNumberRows()) &&
1304 (col
>= 0 && col
< GetNumberCols()),
1305 wxT("invalid row or column index in wxGridStringTable") );
1307 m_data
[row
][col
] = value
;
1310 void wxGridStringTable::Clear()
1313 int numRows
, numCols
;
1315 numRows
= m_data
.GetCount();
1318 numCols
= m_data
[0].GetCount();
1320 for ( row
= 0; row
< numRows
; row
++ )
1322 for ( col
= 0; col
< numCols
; col
++ )
1324 m_data
[row
][col
] = wxEmptyString
;
1330 bool wxGridStringTable::InsertRows( size_t pos
, size_t numRows
)
1332 size_t curNumRows
= m_data
.GetCount();
1333 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
1334 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1336 if ( pos
>= curNumRows
)
1338 return AppendRows( numRows
);
1342 sa
.Alloc( curNumCols
);
1343 sa
.Add( wxEmptyString
, curNumCols
);
1344 m_data
.Insert( sa
, pos
, numRows
);
1348 wxGridTableMessage
msg( this,
1349 wxGRIDTABLE_NOTIFY_ROWS_INSERTED
,
1353 GetView()->ProcessTableMessage( msg
);
1359 bool wxGridStringTable::AppendRows( size_t numRows
)
1361 size_t curNumRows
= m_data
.GetCount();
1362 size_t curNumCols
= ( curNumRows
> 0
1363 ? m_data
[0].GetCount()
1364 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1367 if ( curNumCols
> 0 )
1369 sa
.Alloc( curNumCols
);
1370 sa
.Add( wxEmptyString
, curNumCols
);
1373 m_data
.Add( sa
, numRows
);
1377 wxGridTableMessage
msg( this,
1378 wxGRIDTABLE_NOTIFY_ROWS_APPENDED
,
1381 GetView()->ProcessTableMessage( msg
);
1387 bool wxGridStringTable::DeleteRows( size_t pos
, size_t numRows
)
1389 size_t curNumRows
= m_data
.GetCount();
1391 if ( pos
>= curNumRows
)
1393 wxFAIL_MSG( wxString::Format
1395 wxT("Called wxGridStringTable::DeleteRows(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu rows"),
1397 (unsigned long)numRows
,
1398 (unsigned long)curNumRows
1404 if ( numRows
> curNumRows
- pos
)
1406 numRows
= curNumRows
- pos
;
1409 if ( numRows
>= curNumRows
)
1415 m_data
.RemoveAt( pos
, numRows
);
1420 wxGridTableMessage
msg( this,
1421 wxGRIDTABLE_NOTIFY_ROWS_DELETED
,
1425 GetView()->ProcessTableMessage( msg
);
1431 bool wxGridStringTable::InsertCols( size_t pos
, size_t numCols
)
1435 size_t curNumRows
= m_data
.GetCount();
1436 size_t curNumCols
= ( curNumRows
> 0
1437 ? m_data
[0].GetCount()
1438 : ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1440 if ( pos
>= curNumCols
)
1442 return AppendCols( numCols
);
1445 if ( !m_colLabels
.IsEmpty() )
1447 m_colLabels
.Insert( wxEmptyString
, pos
, numCols
);
1450 for ( i
= pos
; i
< pos
+ numCols
; i
++ )
1451 m_colLabels
[i
] = wxGridTableBase::GetColLabelValue( i
);
1454 for ( row
= 0; row
< curNumRows
; row
++ )
1456 for ( col
= pos
; col
< pos
+ numCols
; col
++ )
1458 m_data
[row
].Insert( wxEmptyString
, col
);
1462 m_numCols
+= numCols
;
1466 wxGridTableMessage
msg( this,
1467 wxGRIDTABLE_NOTIFY_COLS_INSERTED
,
1471 GetView()->ProcessTableMessage( msg
);
1477 bool wxGridStringTable::AppendCols( size_t numCols
)
1481 size_t curNumRows
= m_data
.GetCount();
1483 for ( row
= 0; row
< curNumRows
; row
++ )
1485 m_data
[row
].Add( wxEmptyString
, numCols
);
1488 m_numCols
+= numCols
;
1492 wxGridTableMessage
msg( this,
1493 wxGRIDTABLE_NOTIFY_COLS_APPENDED
,
1496 GetView()->ProcessTableMessage( msg
);
1502 bool wxGridStringTable::DeleteCols( size_t pos
, size_t numCols
)
1506 size_t curNumRows
= m_data
.GetCount();
1507 size_t curNumCols
= ( curNumRows
> 0 ? m_data
[0].GetCount() :
1508 ( GetView() ? GetView()->GetNumberCols() : 0 ) );
1510 if ( pos
>= curNumCols
)
1512 wxFAIL_MSG( wxString::Format
1514 wxT("Called wxGridStringTable::DeleteCols(pos=%lu, N=%lu)\nPos value is invalid for present table with %lu cols"),
1516 (unsigned long)numCols
,
1517 (unsigned long)curNumCols
1524 colID
= GetView()->GetColAt( pos
);
1528 if ( numCols
> curNumCols
- colID
)
1530 numCols
= curNumCols
- colID
;
1533 if ( !m_colLabels
.IsEmpty() )
1535 // m_colLabels stores just as many elements as it needs, e.g. if only
1536 // the label of the first column had been set it would have only one
1537 // element and not numCols, so account for it
1538 int numRemaining
= m_colLabels
.size() - colID
;
1539 if (numRemaining
> 0)
1540 m_colLabels
.RemoveAt( colID
, wxMin(numCols
, numRemaining
) );
1543 if ( numCols
>= curNumCols
)
1545 for ( row
= 0; row
< curNumRows
; row
++ )
1547 m_data
[row
].Clear();
1552 else // something will be left
1554 for ( row
= 0; row
< curNumRows
; row
++ )
1556 m_data
[row
].RemoveAt( colID
, numCols
);
1559 m_numCols
-= numCols
;
1564 wxGridTableMessage
msg( this,
1565 wxGRIDTABLE_NOTIFY_COLS_DELETED
,
1569 GetView()->ProcessTableMessage( msg
);
1575 wxString
wxGridStringTable::GetRowLabelValue( int row
)
1577 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
1579 // using default label
1581 return wxGridTableBase::GetRowLabelValue( row
);
1585 return m_rowLabels
[row
];
1589 wxString
wxGridStringTable::GetColLabelValue( int col
)
1591 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
1593 // using default label
1595 return wxGridTableBase::GetColLabelValue( col
);
1599 return m_colLabels
[col
];
1603 void wxGridStringTable::SetRowLabelValue( int row
, const wxString
& value
)
1605 if ( row
> (int)(m_rowLabels
.GetCount()) - 1 )
1607 int n
= m_rowLabels
.GetCount();
1610 for ( i
= n
; i
<= row
; i
++ )
1612 m_rowLabels
.Add( wxGridTableBase::GetRowLabelValue(i
) );
1616 m_rowLabels
[row
] = value
;
1619 void wxGridStringTable::SetColLabelValue( int col
, const wxString
& value
)
1621 if ( col
> (int)(m_colLabels
.GetCount()) - 1 )
1623 int n
= m_colLabels
.GetCount();
1626 for ( i
= n
; i
<= col
; i
++ )
1628 m_colLabels
.Add( wxGridTableBase::GetColLabelValue(i
) );
1632 m_colLabels
[col
] = value
;
1636 //////////////////////////////////////////////////////////////////////
1637 //////////////////////////////////////////////////////////////////////
1639 BEGIN_EVENT_TABLE(wxGridSubwindow
, wxWindow
)
1640 EVT_MOUSE_CAPTURE_LOST(wxGridSubwindow::OnMouseCaptureLost
)
1643 void wxGridSubwindow::OnMouseCaptureLost(wxMouseCaptureLostEvent
& WXUNUSED(event
))
1645 m_owner
->CancelMouseCapture();
1648 BEGIN_EVENT_TABLE( wxGridRowLabelWindow
, wxGridSubwindow
)
1649 EVT_PAINT( wxGridRowLabelWindow::OnPaint
)
1650 EVT_MOUSEWHEEL( wxGridRowLabelWindow::OnMouseWheel
)
1651 EVT_MOUSE_EVENTS( wxGridRowLabelWindow::OnMouseEvent
)
1654 void wxGridRowLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
1658 // NO - don't do this because it will set both the x and y origin
1659 // coords to match the parent scrolled window and we just want to
1660 // set the y coord - MB
1662 // m_owner->PrepareDC( dc );
1665 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
1666 wxPoint pt
= dc
.GetDeviceOrigin();
1667 dc
.SetDeviceOrigin( pt
.x
, pt
.y
-y
);
1669 wxArrayInt rows
= m_owner
->CalcRowLabelsExposed( GetUpdateRegion() );
1670 m_owner
->DrawRowLabels( dc
, rows
);
1673 void wxGridRowLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
1675 m_owner
->ProcessRowLabelMouseEvent( event
);
1678 void wxGridRowLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
1680 if (!m_owner
->GetEventHandler()->ProcessEvent( event
))
1684 //////////////////////////////////////////////////////////////////////
1686 BEGIN_EVENT_TABLE( wxGridColLabelWindow
, wxGridSubwindow
)
1687 EVT_PAINT( wxGridColLabelWindow::OnPaint
)
1688 EVT_MOUSEWHEEL( wxGridColLabelWindow::OnMouseWheel
)
1689 EVT_MOUSE_EVENTS( wxGridColLabelWindow::OnMouseEvent
)
1692 void wxGridColLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
1696 // NO - don't do this because it will set both the x and y origin
1697 // coords to match the parent scrolled window and we just want to
1698 // set the x coord - MB
1700 // m_owner->PrepareDC( dc );
1703 m_owner
->CalcUnscrolledPosition( 0, 0, &x
, &y
);
1704 wxPoint pt
= dc
.GetDeviceOrigin();
1705 if (GetLayoutDirection() == wxLayout_RightToLeft
)
1706 dc
.SetDeviceOrigin( pt
.x
+x
, pt
.y
);
1708 dc
.SetDeviceOrigin( pt
.x
-x
, pt
.y
);
1710 wxArrayInt cols
= m_owner
->CalcColLabelsExposed( GetUpdateRegion() );
1711 m_owner
->DrawColLabels( dc
, cols
);
1714 void wxGridColLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
1716 m_owner
->ProcessColLabelMouseEvent( event
);
1719 void wxGridColLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
1721 if (!m_owner
->GetEventHandler()->ProcessEvent( event
))
1725 //////////////////////////////////////////////////////////////////////
1727 BEGIN_EVENT_TABLE( wxGridCornerLabelWindow
, wxGridSubwindow
)
1728 EVT_MOUSEWHEEL( wxGridCornerLabelWindow::OnMouseWheel
)
1729 EVT_MOUSE_EVENTS( wxGridCornerLabelWindow::OnMouseEvent
)
1730 EVT_PAINT( wxGridCornerLabelWindow::OnPaint
)
1733 void wxGridCornerLabelWindow::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
1737 m_owner
->DrawCornerLabel(dc
);
1740 void wxGridCornerLabelWindow::OnMouseEvent( wxMouseEvent
& event
)
1742 m_owner
->ProcessCornerLabelMouseEvent( event
);
1745 void wxGridCornerLabelWindow::OnMouseWheel( wxMouseEvent
& event
)
1747 if (!m_owner
->GetEventHandler()->ProcessEvent(event
))
1751 //////////////////////////////////////////////////////////////////////
1753 BEGIN_EVENT_TABLE( wxGridWindow
, wxGridSubwindow
)
1754 EVT_PAINT( wxGridWindow::OnPaint
)
1755 EVT_MOUSEWHEEL( wxGridWindow::OnMouseWheel
)
1756 EVT_MOUSE_EVENTS( wxGridWindow::OnMouseEvent
)
1757 EVT_KEY_DOWN( wxGridWindow::OnKeyDown
)
1758 EVT_KEY_UP( wxGridWindow::OnKeyUp
)
1759 EVT_CHAR( wxGridWindow::OnChar
)
1760 EVT_SET_FOCUS( wxGridWindow::OnFocus
)
1761 EVT_KILL_FOCUS( wxGridWindow::OnFocus
)
1762 EVT_ERASE_BACKGROUND( wxGridWindow::OnEraseBackground
)
1765 void wxGridWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
1767 wxPaintDC
dc( this );
1768 m_owner
->PrepareDC( dc
);
1769 wxRegion reg
= GetUpdateRegion();
1770 wxGridCellCoordsArray dirtyCells
= m_owner
->CalcCellsExposed( reg
);
1771 m_owner
->DrawGridCellArea( dc
, dirtyCells
);
1773 m_owner
->DrawGridSpace( dc
);
1775 m_owner
->DrawAllGridLines( dc
, reg
);
1777 m_owner
->DrawHighlight( dc
, dirtyCells
);
1780 void wxGrid::Render( wxDC
& dc
,
1781 const wxPoint
& position
,
1783 const wxGridCellCoords
& topLeft
,
1784 const wxGridCellCoords
& bottomRight
,
1787 wxCHECK_RET( bottomRight
.GetCol() < GetNumberCols(),
1788 "Invalid right column" );
1789 wxCHECK_RET( bottomRight
.GetRow() < GetNumberRows(),
1790 "Invalid bottom row" );
1792 // store user settings and reset later
1794 // remove grid selection, don't paint selection colour
1795 // unless we have wxGRID_DRAW_SELECTION
1796 // block selections are the only ones catered for here
1797 wxGridCellCoordsArray selectedCells
;
1798 bool hasSelection
= IsSelection();
1799 if ( hasSelection
&& !( style
& wxGRID_DRAW_SELECTION
) )
1801 selectedCells
= GetSelectionBlockTopLeft();
1802 // non block selections may not have a bottom right
1803 if ( GetSelectionBlockBottomRight().size() )
1804 selectedCells
.Add( GetSelectionBlockBottomRight()[ 0 ] );
1809 // store user device origin
1810 wxCoord userOriginX
, userOriginY
;
1811 dc
.GetDeviceOrigin( &userOriginX
, &userOriginY
);
1814 double scaleUserX
, scaleUserY
;
1815 dc
.GetUserScale( &scaleUserX
, &scaleUserY
);
1817 // set defaults if necessary
1818 wxGridCellCoords
leftTop( topLeft
), rightBottom( bottomRight
);
1819 if ( leftTop
.GetCol() < 0 )
1821 if ( leftTop
.GetRow() < 0 )
1823 if ( rightBottom
.GetCol() < 0 )
1824 rightBottom
.SetCol(GetNumberCols() - 1);
1825 if ( rightBottom
.GetRow() < 0 )
1826 rightBottom
.SetRow(GetNumberRows() - 1);
1828 // get grid offset, size and cell parameters
1829 wxPoint pointOffSet
;
1831 wxGridCellCoordsArray renderCells
;
1832 wxArrayInt arrayCols
;
1833 wxArrayInt arrayRows
;
1835 GetRenderSizes( leftTop
, rightBottom
,
1836 pointOffSet
, sizeGrid
,
1838 arrayCols
, arrayRows
);
1840 // add headers/labels to dimensions
1841 if ( style
& wxGRID_DRAW_ROWS_HEADER
)
1842 sizeGrid
.x
+= GetRowLabelSize();
1843 if ( style
& wxGRID_DRAW_COLS_HEADER
)
1844 sizeGrid
.y
+= GetColLabelSize();
1846 // get render start position in logical units
1847 wxPoint positionRender
= GetRenderPosition( dc
, position
);
1849 wxCoord originX
= dc
.LogicalToDeviceX( positionRender
.x
);
1850 wxCoord originY
= dc
.LogicalToDeviceY( positionRender
.y
);
1852 dc
.SetDeviceOrigin( originX
, originY
);
1854 SetRenderScale( dc
, positionRender
, size
, sizeGrid
);
1856 // draw row headers at specified origin
1857 if ( GetRowLabelSize() > 0 && ( style
& wxGRID_DRAW_ROWS_HEADER
) )
1859 if ( style
& wxGRID_DRAW_COLS_HEADER
)
1861 DrawCornerLabel( dc
); // do only if both col and row labels drawn
1862 originY
+= dc
.LogicalToDeviceYRel( GetColLabelSize() );
1865 originY
-= dc
.LogicalToDeviceYRel( pointOffSet
.y
);
1866 dc
.SetDeviceOrigin( originX
, originY
);
1868 DrawRowLabels( dc
, arrayRows
);
1870 // reset for columns
1871 if ( style
& wxGRID_DRAW_COLS_HEADER
)
1872 originY
-= dc
.LogicalToDeviceYRel( GetColLabelSize() );
1874 originY
+= dc
.LogicalToDeviceYRel( pointOffSet
.y
);
1875 // X offset so we don't overwrite row labels
1876 originX
+= dc
.LogicalToDeviceXRel( GetRowLabelSize() );
1879 // subtract col offset where startcol > 0
1880 originX
-= dc
.LogicalToDeviceXRel( pointOffSet
.x
);
1881 // no y offset for col labels, they are at the Y origin
1883 // draw column labels
1884 if ( style
& wxGRID_DRAW_COLS_HEADER
)
1886 dc
.SetDeviceOrigin( originX
, originY
);
1887 DrawColLabels( dc
, arrayCols
);
1888 // don't overwrite the labels, increment originY
1889 originY
+= dc
.LogicalToDeviceYRel( GetColLabelSize() );
1892 // set device origin to draw grid cells and lines
1893 originY
-= dc
.LogicalToDeviceYRel( pointOffSet
.y
);
1894 dc
.SetDeviceOrigin( originX
, originY
);
1896 // draw cell area background
1897 dc
.SetBrush( GetDefaultCellBackgroundColour() );
1898 dc
.SetPen( *wxTRANSPARENT_PEN
);
1899 // subtract headers from grid area dimensions
1900 wxSize
sizeCells( sizeGrid
);
1901 if ( style
& wxGRID_DRAW_ROWS_HEADER
)
1902 sizeCells
.x
-= GetRowLabelSize();
1903 if ( style
& wxGRID_DRAW_COLS_HEADER
)
1904 sizeCells
.y
-= GetColLabelSize();
1906 dc
.DrawRectangle( pointOffSet
, sizeCells
);
1909 DrawGridCellArea( dc
, renderCells
);
1912 if ( style
& wxGRID_DRAW_CELL_LINES
)
1914 wxRegion
regionClip( pointOffSet
.x
, pointOffSet
.y
,
1915 sizeCells
.x
, sizeCells
.y
);
1917 DrawRangeGridLines(dc
, regionClip
, renderCells
[0], renderCells
.Last());
1920 // draw render rectangle bounding lines
1921 DoRenderBox( dc
, style
,
1922 pointOffSet
, sizeCells
,
1923 leftTop
, rightBottom
);
1925 // restore user setings
1926 dc
.SetDeviceOrigin( userOriginX
, userOriginY
);
1927 dc
.SetUserScale( scaleUserX
, scaleUserY
);
1929 if ( selectedCells
.size() && !( style
& wxGRID_DRAW_SELECTION
) )
1931 SelectBlock( selectedCells
[ 0 ].GetRow(),
1932 selectedCells
[ 0 ].GetCol(),
1933 selectedCells
[ selectedCells
.size() -1 ].GetRow(),
1934 selectedCells
[ selectedCells
.size() -1 ].GetCol() );
1939 wxGrid::SetRenderScale(wxDC
& dc
,
1940 const wxPoint
& pos
, const wxSize
& size
,
1941 const wxSize
& sizeGrid
)
1943 double scaleX
, scaleY
;
1946 if ( size
.GetWidth() != wxDefaultSize
.GetWidth() ) // size.x was specified
1947 sizeTemp
.SetWidth( size
.GetWidth() );
1949 sizeTemp
.SetWidth( dc
.DeviceToLogicalXRel( dc
.GetSize().GetWidth() )
1952 if ( size
.GetHeight() != wxDefaultSize
.GetHeight() ) // size.y was specified
1953 sizeTemp
.SetHeight( size
.GetHeight() );
1955 sizeTemp
.SetHeight( dc
.DeviceToLogicalYRel( dc
.GetSize().GetHeight() )
1958 scaleX
= (double)( (double) sizeTemp
.GetWidth() / (double) sizeGrid
.GetWidth() );
1959 scaleY
= (double)( (double) sizeTemp
.GetHeight() / (double) sizeGrid
.GetHeight() );
1961 dc
.SetUserScale( wxMin( scaleX
, scaleY
), wxMin( scaleX
, scaleY
) );
1964 // get grid rendered size, origin offset and fill cell arrays
1965 void wxGrid::GetRenderSizes( const wxGridCellCoords
& topLeft
,
1966 const wxGridCellCoords
& bottomRight
,
1967 wxPoint
& pointOffSet
, wxSize
& sizeGrid
,
1968 wxGridCellCoordsArray
& renderCells
,
1969 wxArrayInt
& arrayCols
, wxArrayInt
& arrayRows
)
1973 sizeGrid
.SetWidth( 0 );
1974 sizeGrid
.SetHeight( 0 );
1978 wxGridSizesInfo sizeinfo
= GetColSizes();
1979 for ( col
= 0; col
<= bottomRight
.GetCol(); col
++ )
1981 if ( col
< topLeft
.GetCol() )
1983 pointOffSet
.x
+= sizeinfo
.GetSize( col
);
1987 for ( row
= topLeft
.GetRow(); row
<= bottomRight
.GetRow(); row
++ )
1989 renderCells
.Add( wxGridCellCoords( row
, col
));
1990 arrayRows
.Add( row
); // column labels rendered in DrawColLabels
1992 arrayCols
.Add( col
); // row labels rendered in DrawRowLabels
1993 sizeGrid
.x
+= sizeinfo
.GetSize( col
);
1997 sizeinfo
= GetRowSizes();
1998 for ( row
= 0; row
<= bottomRight
.GetRow(); row
++ )
2000 if ( row
< topLeft
.GetRow() )
2001 pointOffSet
.y
+= sizeinfo
.GetSize( row
);
2003 sizeGrid
.y
+= sizeinfo
.GetSize( row
);
2007 // get render start position
2008 // if position not specified use dc draw extents MaxX and MaxY
2009 wxPoint
wxGrid::GetRenderPosition( wxDC
& dc
, const wxPoint
& position
)
2011 wxPoint
positionRender( position
);
2013 if ( !positionRender
.IsFullySpecified() )
2015 if ( positionRender
.x
== wxDefaultPosition
.x
)
2016 positionRender
.x
= dc
.MaxX();
2018 if ( positionRender
.y
== wxDefaultPosition
.y
)
2019 positionRender
.y
= dc
.MaxY();
2022 return positionRender
;
2025 // draw render rectangle bounding lines
2026 // useful where there is multi cell row or col clipping and no cell border
2027 void wxGrid::DoRenderBox( wxDC
& dc
, const int& style
,
2028 const wxPoint
& pointOffSet
,
2029 const wxSize
& sizeCells
,
2030 const wxGridCellCoords
& topLeft
,
2031 const wxGridCellCoords
& bottomRight
)
2033 if ( !( style
& wxGRID_DRAW_BOX_RECT
) )
2036 int bottom
= pointOffSet
.y
+ sizeCells
.GetY(),
2037 right
= pointOffSet
.x
+ sizeCells
.GetX() - 1;
2039 // horiz top line if we are not drawing column header/labels
2040 if ( !( style
& wxGRID_DRAW_COLS_HEADER
) )
2042 int left
= pointOffSet
.x
;
2043 left
+= ( style
& wxGRID_DRAW_COLS_HEADER
)
2044 ? - GetRowLabelSize() : 0;
2045 dc
.SetPen( GetRowGridLinePen( topLeft
.GetRow() ) );
2052 // horiz bottom line
2053 dc
.SetPen( GetRowGridLinePen( bottomRight
.GetRow() ) );
2054 dc
.DrawLine( pointOffSet
.x
, bottom
- 1, right
, bottom
- 1 );
2056 // left vertical line if we are not drawing row header/labels
2057 if ( !( style
& wxGRID_DRAW_ROWS_HEADER
) )
2059 int top
= pointOffSet
.y
;
2060 top
+= ( style
& wxGRID_DRAW_COLS_HEADER
)
2061 ? - GetColLabelSize() : 0;
2062 dc
.SetPen( GetColGridLinePen( topLeft
.GetCol() ) );
2063 dc
.DrawLine( pointOffSet
.x
-1,
2069 // right vertical line
2070 dc
.SetPen( GetColGridLinePen( bottomRight
.GetCol() ) );
2071 dc
.DrawLine( right
, pointOffSet
.y
, right
, bottom
- 1 );
2074 void wxGridWindow::ScrollWindow( int dx
, int dy
, const wxRect
*rect
)
2076 wxWindow::ScrollWindow( dx
, dy
, rect
);
2077 m_owner
->GetGridRowLabelWindow()->ScrollWindow( 0, dy
, rect
);
2078 m_owner
->GetGridColLabelWindow()->ScrollWindow( dx
, 0, rect
);
2081 void wxGridWindow::OnMouseEvent( wxMouseEvent
& event
)
2083 if (event
.ButtonDown(wxMOUSE_BTN_LEFT
) && FindFocus() != this)
2086 m_owner
->ProcessGridCellMouseEvent( event
);
2089 void wxGridWindow::OnMouseWheel( wxMouseEvent
& event
)
2091 if (!m_owner
->GetEventHandler()->ProcessEvent( event
))
2095 // This seems to be required for wxMotif/wxGTK otherwise the mouse
2096 // cursor must be in the cell edit control to get key events
2098 void wxGridWindow::OnKeyDown( wxKeyEvent
& event
)
2100 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
2104 void wxGridWindow::OnKeyUp( wxKeyEvent
& event
)
2106 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
2110 void wxGridWindow::OnChar( wxKeyEvent
& event
)
2112 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
2116 void wxGridWindow::OnEraseBackground( wxEraseEvent
& WXUNUSED(event
) )
2120 void wxGridWindow::OnFocus(wxFocusEvent
& event
)
2122 // and if we have any selection, it has to be repainted, because it
2123 // uses different colour when the grid is not focused:
2124 if ( m_owner
->IsSelection() )
2130 // NB: Note that this code is in "else" branch only because the other
2131 // branch refreshes everything and so there's no point in calling
2132 // Refresh() again, *not* because it should only be done if
2133 // !IsSelection(). If the above code is ever optimized to refresh
2134 // only selected area, this needs to be moved out of the "else"
2135 // branch so that it's always executed.
2137 // current cell cursor {dis,re}appears on focus change:
2138 const wxGridCellCoords
cursorCoords(m_owner
->GetGridCursorRow(),
2139 m_owner
->GetGridCursorCol());
2140 const wxRect cursor
=
2141 m_owner
->BlockToDeviceRect(cursorCoords
, cursorCoords
);
2142 Refresh(true, &cursor
);
2145 if ( !m_owner
->GetEventHandler()->ProcessEvent( event
) )
2149 #define internalXToCol(x) XToCol(x, true)
2150 #define internalYToRow(y) YToRow(y, true)
2152 /////////////////////////////////////////////////////////////////////
2154 BEGIN_EVENT_TABLE( wxGrid
, wxScrolledWindow
)
2155 EVT_PAINT( wxGrid::OnPaint
)
2156 EVT_SIZE( wxGrid::OnSize
)
2157 EVT_KEY_DOWN( wxGrid::OnKeyDown
)
2158 EVT_KEY_UP( wxGrid::OnKeyUp
)
2159 EVT_CHAR ( wxGrid::OnChar
)
2160 EVT_ERASE_BACKGROUND( wxGrid::OnEraseBackground
)
2163 bool wxGrid::Create(wxWindow
*parent
, wxWindowID id
,
2164 const wxPoint
& pos
, const wxSize
& size
,
2165 long style
, const wxString
& name
)
2167 if (!wxScrolledWindow::Create(parent
, id
, pos
, size
,
2168 style
| wxWANTS_CHARS
, name
))
2171 m_colMinWidths
= wxLongToLongHashMap(GRID_HASH_SIZE
);
2172 m_rowMinHeights
= wxLongToLongHashMap(GRID_HASH_SIZE
);
2175 SetInitialSize(size
);
2184 m_winCapture
->ReleaseMouse();
2186 // Ensure that the editor control is destroyed before the grid is,
2187 // otherwise we crash later when the editor tries to do something with the
2188 // half destroyed grid
2189 HideCellEditControl();
2191 // Must do this or ~wxScrollHelper will pop the wrong event handler
2192 SetTargetWindow(this);
2194 wxSafeDecRef(m_defaultCellAttr
);
2196 #ifdef DEBUG_ATTR_CACHE
2197 size_t total
= gs_nAttrCacheHits
+ gs_nAttrCacheMisses
;
2198 wxPrintf(wxT("wxGrid attribute cache statistics: "
2199 "total: %u, hits: %u (%u%%)\n"),
2200 total
, gs_nAttrCacheHits
,
2201 total
? (gs_nAttrCacheHits
*100) / total
: 0);
2204 // if we own the table, just delete it, otherwise at least don't leave it
2205 // with dangling view pointer
2208 else if ( m_table
&& m_table
->GetView() == this )
2209 m_table
->SetView(NULL
);
2211 delete m_typeRegistry
;
2214 delete m_setFixedRows
;
2215 delete m_setFixedCols
;
2219 // ----- internal init and update functions
2222 // NOTE: If using the default visual attributes works everywhere then this can
2223 // be removed as well as the #else cases below.
2224 #define _USE_VISATTR 0
2226 void wxGrid::Create()
2228 // create the type registry
2229 m_typeRegistry
= new wxGridTypeRegistry
;
2231 m_cellEditCtrlEnabled
= false;
2233 m_defaultCellAttr
= new wxGridCellAttr();
2235 // Set default cell attributes
2236 m_defaultCellAttr
->SetDefAttr(m_defaultCellAttr
);
2237 m_defaultCellAttr
->SetKind(wxGridCellAttr::Default
);
2238 m_defaultCellAttr
->SetFont(GetFont());
2239 m_defaultCellAttr
->SetAlignment(wxALIGN_LEFT
, wxALIGN_TOP
);
2240 m_defaultCellAttr
->SetRenderer(new wxGridCellStringRenderer
);
2241 m_defaultCellAttr
->SetEditor(new wxGridCellTextEditor
);
2244 wxVisualAttributes gva
= wxListBox::GetClassDefaultAttributes();
2245 wxVisualAttributes lva
= wxPanel::GetClassDefaultAttributes();
2247 m_defaultCellAttr
->SetTextColour(gva
.colFg
);
2248 m_defaultCellAttr
->SetBackgroundColour(gva
.colBg
);
2251 m_defaultCellAttr
->SetTextColour(
2252 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
2253 m_defaultCellAttr
->SetBackgroundColour(
2254 wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
));
2259 m_currentCellCoords
= wxGridNoCellCoords
;
2261 // subwindow components that make up the wxGrid
2262 m_rowLabelWin
= new wxGridRowLabelWindow(this);
2263 CreateColumnWindow();
2264 m_cornerLabelWin
= new wxGridCornerLabelWindow(this);
2265 m_gridWin
= new wxGridWindow( this );
2267 SetTargetWindow( m_gridWin
);
2270 wxColour gfg
= gva
.colFg
;
2271 wxColour gbg
= gva
.colBg
;
2272 wxColour lfg
= lva
.colFg
;
2273 wxColour lbg
= lva
.colBg
;
2275 wxColour gfg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT
);
2276 wxColour gbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW
);
2277 wxColour lfg
= wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT
);
2278 wxColour lbg
= wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE
);
2281 m_cornerLabelWin
->SetOwnForegroundColour(lfg
);
2282 m_cornerLabelWin
->SetOwnBackgroundColour(lbg
);
2283 m_rowLabelWin
->SetOwnForegroundColour(lfg
);
2284 m_rowLabelWin
->SetOwnBackgroundColour(lbg
);
2285 m_colWindow
->SetOwnForegroundColour(lfg
);
2286 m_colWindow
->SetOwnBackgroundColour(lbg
);
2288 m_gridWin
->SetOwnForegroundColour(gfg
);
2289 m_gridWin
->SetOwnBackgroundColour(gbg
);
2291 m_labelBackgroundColour
= m_rowLabelWin
->GetBackgroundColour();
2292 m_labelTextColour
= m_rowLabelWin
->GetForegroundColour();
2294 // now that we have the grid window, use its font to compute the default
2296 m_defaultRowHeight
= m_gridWin
->GetCharHeight();
2297 #if defined(__WXMOTIF__) || defined(__WXGTK__) // see also text ctrl sizing in ShowCellEditControl()
2298 m_defaultRowHeight
+= 8;
2300 m_defaultRowHeight
+= 4;
2305 void wxGrid::CreateColumnWindow()
2307 if ( m_useNativeHeader
)
2309 m_colWindow
= new wxGridHeaderCtrl(this);
2310 m_colLabelHeight
= m_colWindow
->GetBestSize().y
;
2312 else // draw labels ourselves
2314 m_colWindow
= new wxGridColLabelWindow(this);
2315 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
2319 bool wxGrid::CreateGrid( int numRows
, int numCols
,
2320 wxGridSelectionModes selmode
)
2322 wxCHECK_MSG( !m_created
,
2324 wxT("wxGrid::CreateGrid or wxGrid::SetTable called more than once") );
2326 return SetTable(new wxGridStringTable(numRows
, numCols
), true, selmode
);
2329 void wxGrid::SetSelectionMode(wxGridSelectionModes selmode
)
2331 wxCHECK_RET( m_created
,
2332 wxT("Called wxGrid::SetSelectionMode() before calling CreateGrid()") );
2334 m_selection
->SetSelectionMode( selmode
);
2337 wxGrid::wxGridSelectionModes
wxGrid::GetSelectionMode() const
2339 wxCHECK_MSG( m_created
, wxGridSelectCells
,
2340 wxT("Called wxGrid::GetSelectionMode() before calling CreateGrid()") );
2342 return m_selection
->GetSelectionMode();
2346 wxGrid::SetTable(wxGridTableBase
*table
,
2348 wxGrid::wxGridSelectionModes selmode
)
2350 bool checkSelection
= false;
2353 // stop all processing
2358 m_table
->SetView(0);
2364 wxDELETE(m_selection
);
2369 checkSelection
= true;
2371 // kill row and column size arrays
2372 m_colWidths
.Empty();
2373 m_colRights
.Empty();
2374 m_rowHeights
.Empty();
2375 m_rowBottoms
.Empty();
2380 m_numRows
= table
->GetNumberRows();
2381 m_numCols
= table
->GetNumberCols();
2383 if ( m_useNativeHeader
)
2384 GetGridColHeader()->SetColumnCount(m_numCols
);
2387 m_table
->SetView( this );
2388 m_ownTable
= takeOwnership
;
2389 m_selection
= new wxGridSelection( this, selmode
);
2392 // If the newly set table is smaller than the
2393 // original one current cell and selection regions
2394 // might be invalid,
2395 m_selectedBlockCorner
= wxGridNoCellCoords
;
2396 m_currentCellCoords
=
2397 wxGridCellCoords(wxMin(m_numRows
, m_currentCellCoords
.GetRow()),
2398 wxMin(m_numCols
, m_currentCellCoords
.GetCol()));
2399 if (m_selectedBlockTopLeft
.GetRow() >= m_numRows
||
2400 m_selectedBlockTopLeft
.GetCol() >= m_numCols
)
2402 m_selectedBlockTopLeft
= wxGridNoCellCoords
;
2403 m_selectedBlockBottomRight
= wxGridNoCellCoords
;
2406 m_selectedBlockBottomRight
=
2407 wxGridCellCoords(wxMin(m_numRows
,
2408 m_selectedBlockBottomRight
.GetRow()),
2410 m_selectedBlockBottomRight
.GetCol()));
2424 m_cornerLabelWin
= NULL
;
2425 m_rowLabelWin
= NULL
;
2433 m_defaultCellAttr
= NULL
;
2434 m_typeRegistry
= NULL
;
2435 m_winCapture
= NULL
;
2437 m_rowLabelWidth
= WXGRID_DEFAULT_ROW_LABEL_WIDTH
;
2438 m_colLabelHeight
= WXGRID_DEFAULT_COL_LABEL_HEIGHT
;
2441 m_setFixedCols
= NULL
;
2444 m_attrCache
.row
= -1;
2445 m_attrCache
.col
= -1;
2446 m_attrCache
.attr
= NULL
;
2448 m_labelFont
= GetFont();
2449 m_labelFont
.SetWeight( wxBOLD
);
2451 m_rowLabelHorizAlign
= wxALIGN_CENTRE
;
2452 m_rowLabelVertAlign
= wxALIGN_CENTRE
;
2454 m_colLabelHorizAlign
= wxALIGN_CENTRE
;
2455 m_colLabelVertAlign
= wxALIGN_CENTRE
;
2456 m_colLabelTextOrientation
= wxHORIZONTAL
;
2458 m_defaultColWidth
= WXGRID_DEFAULT_COL_WIDTH
;
2459 m_defaultRowHeight
= 0; // this will be initialized after creation
2461 m_minAcceptableColWidth
= WXGRID_MIN_COL_WIDTH
;
2462 m_minAcceptableRowHeight
= WXGRID_MIN_ROW_HEIGHT
;
2464 m_gridLineColour
= wxColour( 192,192,192 );
2465 m_gridLinesEnabled
= true;
2466 m_gridLinesClipHorz
=
2467 m_gridLinesClipVert
= true;
2468 m_cellHighlightColour
= *wxBLACK
;
2469 m_cellHighlightPenWidth
= 2;
2470 m_cellHighlightROPenWidth
= 1;
2472 m_canDragColMove
= false;
2474 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
2475 m_winCapture
= NULL
;
2476 m_canDragRowSize
= true;
2477 m_canDragColSize
= true;
2478 m_canDragGridSize
= true;
2479 m_canDragCell
= false;
2481 m_dragRowOrCol
= -1;
2482 m_isDragging
= false;
2483 m_startDragPos
= wxDefaultPosition
;
2485 m_sortCol
= wxNOT_FOUND
;
2486 m_sortIsAscending
= true;
2489 m_nativeColumnLabels
= false;
2491 m_waitForSlowClick
= false;
2493 m_rowResizeCursor
= wxCursor( wxCURSOR_SIZENS
);
2494 m_colResizeCursor
= wxCursor( wxCURSOR_SIZEWE
);
2496 m_currentCellCoords
= wxGridNoCellCoords
;
2498 m_selectedBlockTopLeft
=
2499 m_selectedBlockBottomRight
=
2500 m_selectedBlockCorner
= wxGridNoCellCoords
;
2502 m_selectionBackground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
2503 m_selectionForeground
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
2505 m_editable
= true; // default for whole grid
2507 m_inOnKeyDown
= false;
2513 // we can't call SetScrollRate() as the window isn't created yet but OTOH
2514 // we don't need to call it neither as the scroll position is (0, 0) right
2515 // now anyhow, so just set the parameters directly
2516 m_xScrollPixelsPerLine
= GRID_SCROLL_LINE_X
;
2517 m_yScrollPixelsPerLine
= GRID_SCROLL_LINE_Y
;
2519 m_tabBehaviour
= Tab_Stop
;
2522 // ----------------------------------------------------------------------------
2523 // the idea is to call these functions only when necessary because they create
2524 // quite big arrays which eat memory mostly unnecessary - in particular, if
2525 // default widths/heights are used for all rows/columns, we may not use these
2528 // with some extra code, it should be possible to only store the widths/heights
2529 // different from default ones (resulting in space savings for huge grids) but
2530 // this is not done currently
2531 // ----------------------------------------------------------------------------
2533 void wxGrid::InitRowHeights()
2535 m_rowHeights
.Empty();
2536 m_rowBottoms
.Empty();
2538 m_rowHeights
.Alloc( m_numRows
);
2539 m_rowBottoms
.Alloc( m_numRows
);
2541 m_rowHeights
.Add( m_defaultRowHeight
, m_numRows
);
2544 for ( int i
= 0; i
< m_numRows
; i
++ )
2546 rowBottom
+= m_defaultRowHeight
;
2547 m_rowBottoms
.Add( rowBottom
);
2551 void wxGrid::InitColWidths()
2553 m_colWidths
.Empty();
2554 m_colRights
.Empty();
2556 m_colWidths
.Alloc( m_numCols
);
2557 m_colRights
.Alloc( m_numCols
);
2559 m_colWidths
.Add( m_defaultColWidth
, m_numCols
);
2561 for ( int i
= 0; i
< m_numCols
; i
++ )
2563 int colRight
= ( GetColPos( i
) + 1 ) * m_defaultColWidth
;
2564 m_colRights
.Add( colRight
);
2568 int wxGrid::GetColWidth(int col
) const
2570 if ( m_colWidths
.IsEmpty() )
2571 return m_defaultColWidth
;
2573 // a negative width indicates a hidden column
2574 return m_colWidths
[col
] > 0 ? m_colWidths
[col
] : 0;
2577 int wxGrid::GetColLeft(int col
) const
2579 if ( m_colRights
.IsEmpty() )
2580 return GetColPos( col
) * m_defaultColWidth
;
2582 return m_colRights
[col
] - GetColWidth(col
);
2585 int wxGrid::GetColRight(int col
) const
2587 return m_colRights
.IsEmpty() ? (GetColPos( col
) + 1) * m_defaultColWidth
2591 int wxGrid::GetRowHeight(int row
) const
2593 // no custom heights / hidden rows
2594 if ( m_rowHeights
.IsEmpty() )
2595 return m_defaultRowHeight
;
2597 // a negative height indicates a hidden row
2598 return m_rowHeights
[row
] > 0 ? m_rowHeights
[row
] : 0;
2601 int wxGrid::GetRowTop(int row
) const
2603 if ( m_rowBottoms
.IsEmpty() )
2604 return row
* m_defaultRowHeight
;
2606 return m_rowBottoms
[row
] - GetRowHeight(row
);
2609 int wxGrid::GetRowBottom(int row
) const
2611 return m_rowBottoms
.IsEmpty() ? (row
+ 1) * m_defaultRowHeight
2612 : m_rowBottoms
[row
];
2615 void wxGrid::CalcDimensions()
2617 // compute the size of the scrollable area
2618 int w
= m_numCols
> 0 ? GetColRight(GetColAt(m_numCols
- 1)) : 0;
2619 int h
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0;
2624 // take into account editor if shown
2625 if ( IsCellEditControlShown() )
2628 int r
= m_currentCellCoords
.GetRow();
2629 int c
= m_currentCellCoords
.GetCol();
2630 int x
= GetColLeft(c
);
2631 int y
= GetRowTop(r
);
2633 // how big is the editor
2634 wxGridCellAttr
* attr
= GetCellAttr(r
, c
);
2635 wxGridCellEditor
* editor
= attr
->GetEditor(this, r
, c
);
2636 editor
->GetControl()->GetSize(&w2
, &h2
);
2647 // preserve (more or less) the previous position
2649 GetViewStart( &x
, &y
);
2651 // ensure the position is valid for the new scroll ranges
2653 x
= wxMax( w
- 1, 0 );
2655 y
= wxMax( h
- 1, 0 );
2657 // update the virtual size and refresh the scrollbars to reflect it
2658 m_gridWin
->SetVirtualSize(w
, h
);
2662 // if our OnSize() hadn't been called (it would if we have scrollbars), we
2663 // still must reposition the children
2667 wxSize
wxGrid::GetSizeAvailableForScrollTarget(const wxSize
& size
)
2669 wxSize
sizeGridWin(size
);
2670 sizeGridWin
.x
-= m_rowLabelWidth
;
2671 sizeGridWin
.y
-= m_colLabelHeight
;
2676 void wxGrid::CalcWindowSizes()
2678 // escape if the window is has not been fully created yet
2680 if ( m_cornerLabelWin
== NULL
)
2684 GetClientSize( &cw
, &ch
);
2686 // the grid may be too small to have enough space for the labels yet, don't
2687 // size the windows to negative sizes in this case
2688 int gw
= cw
- m_rowLabelWidth
;
2689 int gh
= ch
- m_colLabelHeight
;
2695 if ( m_cornerLabelWin
&& m_cornerLabelWin
->IsShown() )
2696 m_cornerLabelWin
->SetSize( 0, 0, m_rowLabelWidth
, m_colLabelHeight
);
2698 if ( m_colWindow
&& m_colWindow
->IsShown() )
2699 m_colWindow
->SetSize( m_rowLabelWidth
, 0, gw
, m_colLabelHeight
);
2701 if ( m_rowLabelWin
&& m_rowLabelWin
->IsShown() )
2702 m_rowLabelWin
->SetSize( 0, m_colLabelHeight
, m_rowLabelWidth
, gh
);
2704 if ( m_gridWin
&& m_gridWin
->IsShown() )
2705 m_gridWin
->SetSize( m_rowLabelWidth
, m_colLabelHeight
, gw
, gh
);
2708 // this is called when the grid table sends a message
2709 // to indicate that it has been redimensioned
2711 bool wxGrid::Redimension( wxGridTableMessage
& msg
)
2714 bool result
= false;
2716 // Clear the attribute cache as the attribute might refer to a different
2717 // cell than stored in the cache after adding/removing rows/columns.
2720 // By the same reasoning, the editor should be dismissed if columns are
2721 // added or removed. And for consistency, it should IMHO always be
2722 // removed, not only if the cell "underneath" it actually changes.
2723 // For now, I intentionally do not save the editor's content as the
2724 // cell it might want to save that stuff to might no longer exist.
2725 HideCellEditControl();
2727 switch ( msg
.GetId() )
2729 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
2731 size_t pos
= msg
.GetCommandInt();
2732 int numRows
= msg
.GetCommandInt2();
2734 m_numRows
+= numRows
;
2736 if ( !m_rowHeights
.IsEmpty() )
2738 m_rowHeights
.Insert( m_defaultRowHeight
, pos
, numRows
);
2739 m_rowBottoms
.Insert( 0, pos
, numRows
);
2743 bottom
= m_rowBottoms
[pos
- 1];
2745 for ( i
= pos
; i
< m_numRows
; i
++ )
2747 bottom
+= m_rowHeights
[i
];
2748 m_rowBottoms
[i
] = bottom
;
2752 if ( m_currentCellCoords
== wxGridNoCellCoords
)
2754 // if we have just inserted cols into an empty grid the current
2755 // cell will be undefined...
2757 SetCurrentCell( 0, 0 );
2761 m_selection
->UpdateRows( pos
, numRows
);
2762 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
2764 attrProvider
->UpdateAttrRows( pos
, numRows
);
2766 if ( !GetBatchCount() )
2769 m_rowLabelWin
->Refresh();
2775 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
2777 int numRows
= msg
.GetCommandInt();
2778 int oldNumRows
= m_numRows
;
2779 m_numRows
+= numRows
;
2781 if ( !m_rowHeights
.IsEmpty() )
2783 m_rowHeights
.Add( m_defaultRowHeight
, numRows
);
2784 m_rowBottoms
.Add( 0, numRows
);
2787 if ( oldNumRows
> 0 )
2788 bottom
= m_rowBottoms
[oldNumRows
- 1];
2790 for ( i
= oldNumRows
; i
< m_numRows
; i
++ )
2792 bottom
+= m_rowHeights
[i
];
2793 m_rowBottoms
[i
] = bottom
;
2797 if ( m_currentCellCoords
== wxGridNoCellCoords
)
2799 // if we have just inserted cols into an empty grid the current
2800 // cell will be undefined...
2802 SetCurrentCell( 0, 0 );
2805 if ( !GetBatchCount() )
2808 m_rowLabelWin
->Refresh();
2814 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
2816 size_t pos
= msg
.GetCommandInt();
2817 int numRows
= msg
.GetCommandInt2();
2818 m_numRows
-= numRows
;
2820 if ( !m_rowHeights
.IsEmpty() )
2822 m_rowHeights
.RemoveAt( pos
, numRows
);
2823 m_rowBottoms
.RemoveAt( pos
, numRows
);
2826 for ( i
= 0; i
< m_numRows
; i
++ )
2828 h
+= m_rowHeights
[i
];
2829 m_rowBottoms
[i
] = h
;
2835 m_currentCellCoords
= wxGridNoCellCoords
;
2839 if ( m_currentCellCoords
.GetRow() >= m_numRows
)
2840 m_currentCellCoords
.Set( 0, 0 );
2844 m_selection
->UpdateRows( pos
, -((int)numRows
) );
2845 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
2848 attrProvider
->UpdateAttrRows( pos
, -((int)numRows
) );
2850 // ifdef'd out following patch from Paul Gammans
2852 // No need to touch column attributes, unless we
2853 // removed _all_ rows, in this case, we remove
2854 // all column attributes.
2855 // I hate to do this here, but the
2856 // needed data is not available inside UpdateAttrRows.
2857 if ( !GetNumberRows() )
2858 attrProvider
->UpdateAttrCols( 0, -GetNumberCols() );
2862 if ( !GetBatchCount() )
2865 m_rowLabelWin
->Refresh();
2871 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
2873 size_t pos
= msg
.GetCommandInt();
2874 int numCols
= msg
.GetCommandInt2();
2875 m_numCols
+= numCols
;
2877 if ( m_useNativeHeader
)
2878 GetGridColHeader()->SetColumnCount(m_numCols
);
2880 if ( !m_colAt
.IsEmpty() )
2882 //Shift the column IDs
2883 for ( i
= 0; i
< m_numCols
- numCols
; i
++ )
2885 if ( m_colAt
[i
] >= (int)pos
)
2886 m_colAt
[i
] += numCols
;
2889 m_colAt
.Insert( pos
, pos
, numCols
);
2891 //Set the new columns' positions
2892 for ( i
= pos
+ 1; i
< (int)pos
+ numCols
; i
++ )
2898 if ( !m_colWidths
.IsEmpty() )
2900 m_colWidths
.Insert( m_defaultColWidth
, pos
, numCols
);
2901 m_colRights
.Insert( 0, pos
, numCols
);
2905 right
= m_colRights
[GetColAt( pos
- 1 )];
2908 for ( colPos
= pos
; colPos
< m_numCols
; colPos
++ )
2910 i
= GetColAt( colPos
);
2912 right
+= m_colWidths
[i
];
2913 m_colRights
[i
] = right
;
2917 if ( m_currentCellCoords
== wxGridNoCellCoords
)
2919 // if we have just inserted cols into an empty grid the current
2920 // cell will be undefined...
2922 SetCurrentCell( 0, 0 );
2926 m_selection
->UpdateCols( pos
, numCols
);
2927 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
2929 attrProvider
->UpdateAttrCols( pos
, numCols
);
2930 if ( !GetBatchCount() )
2933 m_colWindow
->Refresh();
2939 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
2941 int numCols
= msg
.GetCommandInt();
2942 int oldNumCols
= m_numCols
;
2943 m_numCols
+= numCols
;
2944 if ( m_useNativeHeader
)
2945 GetGridColHeader()->SetColumnCount(m_numCols
);
2947 if ( !m_colAt
.IsEmpty() )
2949 m_colAt
.Add( 0, numCols
);
2951 //Set the new columns' positions
2952 for ( i
= oldNumCols
; i
< m_numCols
; i
++ )
2958 if ( !m_colWidths
.IsEmpty() )
2960 m_colWidths
.Add( m_defaultColWidth
, numCols
);
2961 m_colRights
.Add( 0, numCols
);
2964 if ( oldNumCols
> 0 )
2965 right
= m_colRights
[GetColAt( oldNumCols
- 1 )];
2968 for ( colPos
= oldNumCols
; colPos
< m_numCols
; colPos
++ )
2970 i
= GetColAt( colPos
);
2972 right
+= m_colWidths
[i
];
2973 m_colRights
[i
] = right
;
2977 if ( m_currentCellCoords
== wxGridNoCellCoords
)
2979 // if we have just inserted cols into an empty grid the current
2980 // cell will be undefined...
2982 SetCurrentCell( 0, 0 );
2984 if ( !GetBatchCount() )
2987 m_colWindow
->Refresh();
2993 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
2995 size_t pos
= msg
.GetCommandInt();
2996 int numCols
= msg
.GetCommandInt2();
2997 m_numCols
-= numCols
;
2998 if ( m_useNativeHeader
)
2999 GetGridColHeader()->SetColumnCount(m_numCols
);
3001 if ( !m_colAt
.IsEmpty() )
3003 int colID
= GetColAt( pos
);
3005 m_colAt
.RemoveAt( pos
, numCols
);
3007 //Shift the column IDs
3009 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
3011 if ( m_colAt
[colPos
] > colID
)
3012 m_colAt
[colPos
] -= numCols
;
3016 if ( !m_colWidths
.IsEmpty() )
3018 m_colWidths
.RemoveAt( pos
, numCols
);
3019 m_colRights
.RemoveAt( pos
, numCols
);
3023 for ( colPos
= 0; colPos
< m_numCols
; colPos
++ )
3025 i
= GetColAt( colPos
);
3027 w
+= m_colWidths
[i
];
3034 m_currentCellCoords
= wxGridNoCellCoords
;
3038 if ( m_currentCellCoords
.GetCol() >= m_numCols
)
3039 m_currentCellCoords
.Set( 0, 0 );
3043 m_selection
->UpdateCols( pos
, -((int)numCols
) );
3044 wxGridCellAttrProvider
* attrProvider
= m_table
->GetAttrProvider();
3047 attrProvider
->UpdateAttrCols( pos
, -((int)numCols
) );
3049 // ifdef'd out following patch from Paul Gammans
3051 // No need to touch row attributes, unless we
3052 // removed _all_ columns, in this case, we remove
3053 // all row attributes.
3054 // I hate to do this here, but the
3055 // needed data is not available inside UpdateAttrCols.
3056 if ( !GetNumberCols() )
3057 attrProvider
->UpdateAttrRows( 0, -GetNumberRows() );
3061 if ( !GetBatchCount() )
3064 m_colWindow
->Refresh();
3071 if (result
&& !GetBatchCount() )
3072 m_gridWin
->Refresh();
3077 wxArrayInt
wxGrid::CalcRowLabelsExposed( const wxRegion
& reg
) const
3079 wxRegionIterator
iter( reg
);
3082 wxArrayInt rowlabels
;
3089 // TODO: remove this when we can...
3090 // There is a bug in wxMotif that gives garbage update
3091 // rectangles if you jump-scroll a long way by clicking the
3092 // scrollbar with middle button. This is a work-around
3094 #if defined(__WXMOTIF__)
3096 m_gridWin
->GetClientSize( &cw
, &ch
);
3097 if ( r
.GetTop() > ch
)
3099 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
3102 // logical bounds of update region
3105 CalcUnscrolledPosition( 0, r
.GetTop(), &dummy
, &top
);
3106 CalcUnscrolledPosition( 0, r
.GetBottom(), &dummy
, &bottom
);
3108 // find the row labels within these bounds
3111 for ( row
= internalYToRow(top
); row
< m_numRows
; row
++ )
3113 if ( GetRowBottom(row
) < top
)
3116 if ( GetRowTop(row
) > bottom
)
3119 rowlabels
.Add( row
);
3128 wxArrayInt
wxGrid::CalcColLabelsExposed( const wxRegion
& reg
) const
3130 wxRegionIterator
iter( reg
);
3133 wxArrayInt colLabels
;
3140 // TODO: remove this when we can...
3141 // There is a bug in wxMotif that gives garbage update
3142 // rectangles if you jump-scroll a long way by clicking the
3143 // scrollbar with middle button. This is a work-around
3145 #if defined(__WXMOTIF__)
3147 m_gridWin
->GetClientSize( &cw
, &ch
);
3148 if ( r
.GetLeft() > cw
)
3150 r
.SetRight( wxMin( r
.GetRight(), cw
) );
3153 // logical bounds of update region
3156 CalcUnscrolledPosition( r
.GetLeft(), 0, &left
, &dummy
);
3157 CalcUnscrolledPosition( r
.GetRight(), 0, &right
, &dummy
);
3159 // find the cells within these bounds
3163 for ( colPos
= GetColPos( internalXToCol(left
) ); colPos
< m_numCols
; colPos
++ )
3165 col
= GetColAt( colPos
);
3167 if ( GetColRight(col
) < left
)
3170 if ( GetColLeft(col
) > right
)
3173 colLabels
.Add( col
);
3182 wxGridCellCoordsArray
wxGrid::CalcCellsExposed( const wxRegion
& reg
) const
3186 wxGridCellCoordsArray cellsExposed
;
3188 int left
, top
, right
, bottom
;
3189 for ( wxRegionIterator
iter(reg
); iter
; ++iter
)
3193 // Skip 0-height cells, they're invisible anyhow, don't waste time
3194 // getting their rectangles and so on.
3195 if ( !r
.GetHeight() )
3198 // TODO: remove this when we can...
3199 // There is a bug in wxMotif that gives garbage update
3200 // rectangles if you jump-scroll a long way by clicking the
3201 // scrollbar with middle button. This is a work-around
3203 #if defined(__WXMOTIF__)
3205 m_gridWin
->GetClientSize( &cw
, &ch
);
3206 if ( r
.GetTop() > ch
) r
.SetTop( 0 );
3207 if ( r
.GetLeft() > cw
) r
.SetLeft( 0 );
3208 r
.SetRight( wxMin( r
.GetRight(), cw
) );
3209 r
.SetBottom( wxMin( r
.GetBottom(), ch
) );
3212 // logical bounds of update region
3214 CalcUnscrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
3215 CalcUnscrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
3217 // find the cells within these bounds
3219 for ( int row
= internalYToRow(top
); row
< m_numRows
; row
++ )
3221 if ( GetRowBottom(row
) <= top
)
3224 if ( GetRowTop(row
) > bottom
)
3227 // add all dirty cells in this row: notice that the columns which
3228 // are dirty don't depend on the row so we compute them only once
3229 // for the first dirty row and then reuse for all the next ones
3232 // do determine the dirty columns
3233 for ( int pos
= XToPos(left
); pos
<= XToPos(right
); pos
++ )
3234 cols
.push_back(GetColAt(pos
));
3236 // if there are no dirty columns at all, nothing to do
3241 const size_t count
= cols
.size();
3242 for ( size_t n
= 0; n
< count
; n
++ )
3243 cellsExposed
.Add(wxGridCellCoords(row
, cols
[n
]));
3247 return cellsExposed
;
3251 void wxGrid::ProcessRowLabelMouseEvent( wxMouseEvent
& event
)
3254 wxPoint
pos( event
.GetPosition() );
3255 CalcUnscrolledPosition( pos
.x
, pos
.y
, &x
, &y
);
3257 if ( event
.Dragging() )
3261 m_isDragging
= true;
3262 m_rowLabelWin
->CaptureMouse();
3265 if ( event
.LeftIsDown() )
3267 switch ( m_cursorMode
)
3269 case WXGRID_CURSOR_RESIZE_ROW
:
3271 int cw
, ch
, left
, dummy
;
3272 m_gridWin
->GetClientSize( &cw
, &ch
);
3273 CalcUnscrolledPosition( 0, 0, &left
, &dummy
);
3275 wxClientDC
dc( m_gridWin
);
3278 GetRowTop(m_dragRowOrCol
) +
3279 GetRowMinimalHeight(m_dragRowOrCol
) );
3280 dc
.SetLogicalFunction(wxINVERT
);
3281 if ( m_dragLastPos
>= 0 )
3283 dc
.DrawLine( left
, m_dragLastPos
, left
+cw
, m_dragLastPos
);
3285 dc
.DrawLine( left
, y
, left
+cw
, y
);
3290 case WXGRID_CURSOR_SELECT_ROW
:
3292 if ( (row
= YToRow( y
)) >= 0 )
3295 m_selection
->SelectRow(row
, event
);
3300 // default label to suppress warnings about "enumeration value
3301 // 'xxx' not handled in switch
3309 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
3314 if (m_rowLabelWin
->HasCapture())
3315 m_rowLabelWin
->ReleaseMouse();
3316 m_isDragging
= false;
3319 // ------------ Entering or leaving the window
3321 if ( event
.Entering() || event
.Leaving() )
3323 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
3326 // ------------ Left button pressed
3328 else if ( event
.LeftDown() )
3330 row
= YToEdgeOfRow(y
);
3331 if ( row
!= wxNOT_FOUND
&& CanDragRowSize(row
) )
3333 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
);
3335 else // not a request to start resizing
3339 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, row
, -1, event
) )
3341 if ( !event
.ShiftDown() && !event
.CmdDown() )
3345 if ( event
.ShiftDown() )
3347 m_selection
->SelectBlock
3349 m_currentCellCoords
.GetRow(), 0,
3350 row
, GetNumberCols() - 1,
3356 m_selection
->SelectRow(row
, event
);
3360 ChangeCursorMode(WXGRID_CURSOR_SELECT_ROW
, m_rowLabelWin
);
3365 // ------------ Left double click
3367 else if (event
.LeftDClick() )
3369 row
= YToEdgeOfRow(y
);
3370 if ( row
!= wxNOT_FOUND
&& CanDragRowSize(row
) )
3372 // adjust row height depending on label text
3374 // TODO: generate RESIZING event, see #10754
3375 AutoSizeRowLabelSize( row
);
3377 SendGridSizeEvent(wxEVT_GRID_ROW_SIZE
, row
, -1, event
);
3379 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, GetColLabelWindow());
3382 else // not on row separator or it's not resizable
3386 !SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, row
, -1, event
) )
3388 // no default action at the moment
3393 // ------------ Left button released
3395 else if ( event
.LeftUp() )
3397 if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
3398 DoEndDragResizeRow(event
);
3400 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
);
3404 // ------------ Right button down
3406 else if ( event
.RightDown() )
3410 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, row
, -1, event
) )
3412 // no default action at the moment
3416 // ------------ Right double click
3418 else if ( event
.RightDClick() )
3422 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, row
, -1, event
) )
3424 // no default action at the moment
3428 // ------------ No buttons down and mouse moving
3430 else if ( event
.Moving() )
3432 m_dragRowOrCol
= YToEdgeOfRow( y
);
3433 if ( m_dragRowOrCol
!= wxNOT_FOUND
)
3435 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
3437 if ( CanDragRowSize(m_dragRowOrCol
) )
3438 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, m_rowLabelWin
, false);
3441 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
3443 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, m_rowLabelWin
, false);
3448 void wxGrid::UpdateColumnSortingIndicator(int col
)
3450 wxCHECK_RET( col
!= wxNOT_FOUND
, "invalid column index" );
3452 if ( m_useNativeHeader
)
3453 GetGridColHeader()->UpdateColumn(col
);
3454 else if ( m_nativeColumnLabels
)
3455 m_colWindow
->Refresh();
3456 //else: sorting indicator display not yet implemented in grid version
3459 void wxGrid::SetSortingColumn(int col
, bool ascending
)
3461 if ( col
== m_sortCol
)
3463 // we are already using this column for sorting (or not sorting at all)
3464 // but we might still change the sorting order, check for it
3465 if ( m_sortCol
!= wxNOT_FOUND
&& ascending
!= m_sortIsAscending
)
3467 m_sortIsAscending
= ascending
;
3469 UpdateColumnSortingIndicator(m_sortCol
);
3472 else // we're changing the column used for sorting
3474 const int sortColOld
= m_sortCol
;
3476 // change it before updating the column as we want GetSortingColumn()
3477 // to return the correct new value
3480 if ( sortColOld
!= wxNOT_FOUND
)
3481 UpdateColumnSortingIndicator(sortColOld
);
3483 if ( m_sortCol
!= wxNOT_FOUND
)
3485 m_sortIsAscending
= ascending
;
3486 UpdateColumnSortingIndicator(m_sortCol
);
3491 void wxGrid::DoColHeaderClick(int col
)
3493 // we consider that the grid was resorted if this event is processed and
3495 if ( SendEvent(wxEVT_GRID_COL_SORT
, -1, col
) == 1 )
3497 SetSortingColumn(col
, IsSortingBy(col
) ? !m_sortIsAscending
: true);
3502 void wxGrid::DoStartResizeCol(int col
)
3504 m_dragRowOrCol
= col
;
3506 DoUpdateResizeColWidth(GetColWidth(m_dragRowOrCol
));
3509 void wxGrid::DoUpdateResizeCol(int x
)
3511 int cw
, ch
, dummy
, top
;
3512 m_gridWin
->GetClientSize( &cw
, &ch
);
3513 CalcUnscrolledPosition( 0, 0, &dummy
, &top
);
3515 wxClientDC
dc( m_gridWin
);
3518 x
= wxMax( x
, GetColLeft(m_dragRowOrCol
) + GetColMinimalWidth(m_dragRowOrCol
));
3519 dc
.SetLogicalFunction(wxINVERT
);
3520 if ( m_dragLastPos
>= 0 )
3522 dc
.DrawLine( m_dragLastPos
, top
, m_dragLastPos
, top
+ ch
);
3524 dc
.DrawLine( x
, top
, x
, top
+ ch
);
3528 void wxGrid::DoUpdateResizeColWidth(int w
)
3530 DoUpdateResizeCol(GetColLeft(m_dragRowOrCol
) + w
);
3533 void wxGrid::ProcessColLabelMouseEvent( wxMouseEvent
& event
)
3536 CalcUnscrolledPosition( event
.GetPosition().x
, 0, &x
, NULL
);
3538 int col
= XToCol(x
);
3539 if ( event
.Dragging() )
3543 m_isDragging
= true;
3544 GetColLabelWindow()->CaptureMouse();
3546 if ( m_cursorMode
== WXGRID_CURSOR_MOVE_COL
&& col
!= -1 )
3547 DoStartMoveCol(col
);
3550 if ( event
.LeftIsDown() )
3552 switch ( m_cursorMode
)
3554 case WXGRID_CURSOR_RESIZE_COL
:
3555 DoUpdateResizeCol(x
);
3558 case WXGRID_CURSOR_SELECT_COL
:
3563 m_selection
->SelectCol(col
, event
);
3568 case WXGRID_CURSOR_MOVE_COL
:
3570 int posNew
= XToPos(x
);
3571 int colNew
= GetColAt(posNew
);
3573 // determine the position of the drop marker
3575 if ( x
>= GetColLeft(colNew
) + (GetColWidth(colNew
) / 2) )
3576 markerX
= GetColRight(colNew
);
3578 markerX
= GetColLeft(colNew
);
3580 if ( markerX
!= m_dragLastPos
)
3582 wxClientDC
dc( GetColLabelWindow() );
3586 GetColLabelWindow()->GetClientSize( &cw
, &ch
);
3590 //Clean up the last indicator
3591 if ( m_dragLastPos
>= 0 )
3593 wxPen
pen( GetColLabelWindow()->GetBackgroundColour(), 2 );
3595 dc
.DrawLine( m_dragLastPos
+ 1, 0, m_dragLastPos
+ 1, ch
);
3596 dc
.SetPen(wxNullPen
);
3598 if ( XToCol( m_dragLastPos
) != -1 )
3599 DrawColLabel( dc
, XToCol( m_dragLastPos
) );
3602 const wxColour
*color
;
3603 //Moving to the same place? Don't draw a marker
3604 if ( colNew
== m_dragRowOrCol
)
3605 color
= wxLIGHT_GREY
;
3610 wxPen
pen( *color
, 2 );
3613 dc
.DrawLine( markerX
, 0, markerX
, ch
);
3615 dc
.SetPen(wxNullPen
);
3617 m_dragLastPos
= markerX
- 1;
3622 // default label to suppress warnings about "enumeration value
3623 // 'xxx' not handled in switch
3631 if ( m_isDragging
&& (event
.Entering() || event
.Leaving()) )
3636 if (GetColLabelWindow()->HasCapture())
3637 GetColLabelWindow()->ReleaseMouse();
3638 m_isDragging
= false;
3641 // ------------ Entering or leaving the window
3643 if ( event
.Entering() || event
.Leaving() )
3645 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, GetColLabelWindow());
3648 // ------------ Left button pressed
3650 else if ( event
.LeftDown() )
3652 int colEdge
= XToEdgeOfCol(x
);
3653 if ( colEdge
!= wxNOT_FOUND
&& CanDragColSize(colEdge
) )
3655 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, GetColLabelWindow());
3657 else // not a request to start resizing
3660 !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, col
, event
) )
3662 if ( m_canDragColMove
)
3664 //Show button as pressed
3665 wxClientDC
dc( GetColLabelWindow() );
3666 int colLeft
= GetColLeft( col
);
3667 int colRight
= GetColRight( col
) - 1;
3668 dc
.SetPen( wxPen( GetColLabelWindow()->GetBackgroundColour(), 1 ) );
3669 dc
.DrawLine( colLeft
, 1, colLeft
, m_colLabelHeight
-1 );
3670 dc
.DrawLine( colLeft
, 1, colRight
, 1 );
3672 ChangeCursorMode(WXGRID_CURSOR_MOVE_COL
, GetColLabelWindow());
3676 if ( !event
.ShiftDown() && !event
.CmdDown() )
3680 if ( event
.ShiftDown() )
3682 m_selection
->SelectBlock
3684 0, m_currentCellCoords
.GetCol(),
3685 GetNumberRows() - 1, col
,
3691 m_selection
->SelectCol(col
, event
);
3695 ChangeCursorMode(WXGRID_CURSOR_SELECT_COL
, GetColLabelWindow());
3701 // ------------ Left double click
3703 if ( event
.LeftDClick() )
3705 const int colEdge
= XToEdgeOfCol(x
);
3706 if ( colEdge
== -1 )
3709 ! SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, col
, event
) )
3711 // no default action at the moment
3716 // adjust column width depending on label text
3718 // TODO: generate RESIZING event, see #10754
3719 AutoSizeColLabelSize( colEdge
);
3721 SendGridSizeEvent(wxEVT_GRID_COL_SIZE
, -1, colEdge
, event
);
3723 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, GetColLabelWindow());
3728 // ------------ Left button released
3730 else if ( event
.LeftUp() )
3732 switch ( m_cursorMode
)
3734 case WXGRID_CURSOR_RESIZE_COL
:
3735 DoEndDragResizeCol(event
);
3738 case WXGRID_CURSOR_MOVE_COL
:
3739 if ( m_dragLastPos
== -1 || col
== m_dragRowOrCol
)
3741 // the column didn't actually move anywhere
3743 DoColHeaderClick(col
);
3744 m_colWindow
->Refresh(); // "unpress" the column
3748 // get the position of the column we're over
3749 int pos
= XToPos(x
);
3751 // we may need to adjust the drop position but don't bother
3752 // checking for it if we can't anyhow
3755 // also find the index of the column we're over: notice
3756 // that the existing "col" variable may be invalid but
3757 // we need a valid one here
3758 const int colValid
= GetColAt(pos
);
3760 // if we're on the "near" (usually left but right in
3761 // RTL case) part of the column, the actual position we
3762 // should be placed in is actually the one before it
3764 const int middle
= GetColLeft(colValid
) +
3765 GetColWidth(colValid
)/2;
3766 if ( GetLayoutDirection() == wxLayout_LeftToRight
)
3767 onNearPart
= (x
<= middle
);
3768 else // wxLayout_RightToLeft
3769 onNearPart
= (x
> middle
);
3779 case WXGRID_CURSOR_SELECT_COL
:
3780 case WXGRID_CURSOR_SELECT_CELL
:
3781 case WXGRID_CURSOR_RESIZE_ROW
:
3782 case WXGRID_CURSOR_SELECT_ROW
:
3784 DoColHeaderClick(col
);
3788 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, GetColLabelWindow());
3792 // ------------ Right button down
3794 else if ( event
.RightDown() )
3797 !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, col
, event
) )
3799 // no default action at the moment
3803 // ------------ Right double click
3805 else if ( event
.RightDClick() )
3808 !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, col
, event
) )
3810 // no default action at the moment
3814 // ------------ No buttons down and mouse moving
3816 else if ( event
.Moving() )
3818 m_dragRowOrCol
= XToEdgeOfCol( x
);
3819 if ( m_dragRowOrCol
>= 0 )
3821 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
3823 if ( CanDragColSize(m_dragRowOrCol
) )
3824 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, GetColLabelWindow(), false);
3827 else if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
3829 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
, GetColLabelWindow(), false);
3834 void wxGrid::ProcessCornerLabelMouseEvent( wxMouseEvent
& event
)
3836 if ( event
.LeftDown() )
3838 // indicate corner label by having both row and
3841 if ( !SendEvent( wxEVT_GRID_LABEL_LEFT_CLICK
, -1, -1, event
) )
3846 else if ( event
.LeftDClick() )
3848 SendEvent( wxEVT_GRID_LABEL_LEFT_DCLICK
, -1, -1, event
);
3850 else if ( event
.RightDown() )
3852 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_CLICK
, -1, -1, event
) )
3854 // no default action at the moment
3857 else if ( event
.RightDClick() )
3859 if ( !SendEvent( wxEVT_GRID_LABEL_RIGHT_DCLICK
, -1, -1, event
) )
3861 // no default action at the moment
3866 void wxGrid::CancelMouseCapture()
3868 // cancel operation currently in progress, whatever it is
3871 m_isDragging
= false;
3872 m_startDragPos
= wxDefaultPosition
;
3874 m_cursorMode
= WXGRID_CURSOR_SELECT_CELL
;
3875 m_winCapture
->SetCursor( *wxSTANDARD_CURSOR
);
3876 m_winCapture
= NULL
;
3878 // remove traces of whatever we drew on screen
3883 void wxGrid::ChangeCursorMode(CursorMode mode
,
3888 static const wxChar
*const cursorModes
[] =
3898 wxLogTrace(wxT("grid"),
3899 wxT("wxGrid cursor mode (mouse capture for %s): %s -> %s"),
3900 win
== m_colWindow
? wxT("colLabelWin")
3901 : win
? wxT("rowLabelWin")
3903 cursorModes
[m_cursorMode
], cursorModes
[mode
]);
3904 #endif // wxUSE_LOG_TRACE
3906 if ( mode
== m_cursorMode
&&
3907 win
== m_winCapture
&&
3908 captureMouse
== (m_winCapture
!= NULL
))
3913 // by default use the grid itself
3919 m_winCapture
->ReleaseMouse();
3920 m_winCapture
= NULL
;
3923 m_cursorMode
= mode
;
3925 switch ( m_cursorMode
)
3927 case WXGRID_CURSOR_RESIZE_ROW
:
3928 win
->SetCursor( m_rowResizeCursor
);
3931 case WXGRID_CURSOR_RESIZE_COL
:
3932 win
->SetCursor( m_colResizeCursor
);
3935 case WXGRID_CURSOR_MOVE_COL
:
3936 win
->SetCursor( wxCursor(wxCURSOR_HAND
) );
3940 win
->SetCursor( *wxSTANDARD_CURSOR
);
3944 // we need to capture mouse when resizing
3945 bool resize
= m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
||
3946 m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
;
3948 if ( captureMouse
&& resize
)
3950 win
->CaptureMouse();
3955 // ----------------------------------------------------------------------------
3956 // grid mouse event processing
3957 // ----------------------------------------------------------------------------
3960 wxGrid::DoGridCellDrag(wxMouseEvent
& event
,
3961 const wxGridCellCoords
& coords
,
3964 bool performDefault
= true ;
3966 if ( coords
== wxGridNoCellCoords
)
3967 return performDefault
; // we're outside any valid cell
3969 // Hide the edit control, so it won't interfere with drag-shrinking.
3970 if ( IsCellEditControlShown() )
3972 HideCellEditControl();
3973 SaveEditControlValue();
3976 switch ( event
.GetModifiers() )
3979 if ( m_selectedBlockCorner
== wxGridNoCellCoords
)
3980 m_selectedBlockCorner
= coords
;
3981 UpdateBlockBeingSelected(m_selectedBlockCorner
, coords
);
3985 if ( CanDragCell() )
3989 if ( m_selectedBlockCorner
== wxGridNoCellCoords
)
3990 m_selectedBlockCorner
= coords
;
3992 // if event is handled by user code, no further processing
3993 if ( SendEvent(wxEVT_GRID_CELL_BEGIN_DRAG
, coords
, event
) != 0 )
3994 performDefault
= false;
3996 return performDefault
;
4000 UpdateBlockBeingSelected(m_currentCellCoords
, coords
);
4004 // we don't handle the other key modifiers
4008 return performDefault
;
4011 void wxGrid::DoGridLineDrag(wxMouseEvent
& event
, const wxGridOperations
& oper
)
4013 wxClientDC
dc(m_gridWin
);
4015 dc
.SetLogicalFunction(wxINVERT
);
4017 const wxRect
rectWin(CalcUnscrolledPosition(wxPoint(0, 0)),
4018 m_gridWin
->GetClientSize());
4020 // erase the previously drawn line, if any
4021 if ( m_dragLastPos
>= 0 )
4022 oper
.DrawParallelLineInRect(dc
, rectWin
, m_dragLastPos
);
4024 // we need the vertical position for rows and horizontal for columns here
4025 m_dragLastPos
= oper
.Dual().Select(CalcUnscrolledPosition(event
.GetPosition()));
4027 // don't allow resizing beneath the minimal size
4028 const int posMin
= oper
.GetLineStartPos(this, m_dragRowOrCol
) +
4029 oper
.GetMinimalLineSize(this, m_dragRowOrCol
);
4030 if ( m_dragLastPos
< posMin
)
4031 m_dragLastPos
= posMin
;
4033 // and draw it at the new position
4034 oper
.DrawParallelLineInRect(dc
, rectWin
, m_dragLastPos
);
4037 void wxGrid::DoGridDragEvent(wxMouseEvent
& event
, const wxGridCellCoords
& coords
)
4039 if ( !m_isDragging
)
4041 // Don't start doing anything until the mouse has been dragged far
4043 const wxPoint
& pt
= event
.GetPosition();
4044 if ( m_startDragPos
== wxDefaultPosition
)
4046 m_startDragPos
= pt
;
4050 if ( abs(m_startDragPos
.x
- pt
.x
) <= DRAG_SENSITIVITY
&&
4051 abs(m_startDragPos
.y
- pt
.y
) <= DRAG_SENSITIVITY
)
4055 const bool isFirstDrag
= !m_isDragging
;
4056 m_isDragging
= true;
4058 switch ( m_cursorMode
)
4060 case WXGRID_CURSOR_SELECT_CELL
:
4061 // no further handling if handled by user
4062 if ( DoGridCellDrag(event
, coords
, isFirstDrag
) == false )
4066 case WXGRID_CURSOR_RESIZE_ROW
:
4067 DoGridLineDrag(event
, wxGridRowOperations());
4070 case WXGRID_CURSOR_RESIZE_COL
:
4071 DoGridLineDrag(event
, wxGridColumnOperations());
4080 wxASSERT_MSG( !m_winCapture
, "shouldn't capture the mouse twice" );
4082 m_winCapture
= m_gridWin
;
4083 m_winCapture
->CaptureMouse();
4088 wxGrid::DoGridCellLeftDown(wxMouseEvent
& event
,
4089 const wxGridCellCoords
& coords
,
4092 if ( SendEvent(wxEVT_GRID_CELL_LEFT_CLICK
, coords
, event
) )
4094 // event handled by user code, no need to do anything here
4098 if ( !event
.CmdDown() )
4101 if ( event
.ShiftDown() )
4105 m_selection
->SelectBlock(m_currentCellCoords
, coords
, event
);
4106 m_selectedBlockCorner
= coords
;
4109 else if ( XToEdgeOfCol(pos
.x
) < 0 && YToEdgeOfRow(pos
.y
) < 0 )
4111 DisableCellEditControl();
4112 MakeCellVisible( coords
);
4114 if ( event
.CmdDown() )
4118 m_selection
->ToggleCellSelection(coords
, event
);
4121 m_selectedBlockTopLeft
= wxGridNoCellCoords
;
4122 m_selectedBlockBottomRight
= wxGridNoCellCoords
;
4123 m_selectedBlockCorner
= coords
;
4129 // In row or column selection mode just clicking on the cell
4130 // should select the row or column containing it: this is more
4131 // convenient for the kinds of controls that use such selection
4132 // mode and is compatible with 2.8 behaviour (see #12062).
4133 switch ( m_selection
->GetSelectionMode() )
4135 case wxGridSelectCells
:
4136 case wxGridSelectRowsOrColumns
:
4137 // nothing to do in these cases
4140 case wxGridSelectRows
:
4141 m_selection
->SelectRow(coords
.GetRow());
4144 case wxGridSelectColumns
:
4145 m_selection
->SelectCol(coords
.GetCol());
4150 m_waitForSlowClick
= m_currentCellCoords
== coords
&&
4151 coords
!= wxGridNoCellCoords
;
4152 SetCurrentCell( coords
);
4158 wxGrid::DoGridCellLeftDClick(wxMouseEvent
& event
,
4159 const wxGridCellCoords
& coords
,
4162 if ( XToEdgeOfCol(pos
.x
) < 0 && YToEdgeOfRow(pos
.y
) < 0 )
4164 if ( !SendEvent(wxEVT_GRID_CELL_LEFT_DCLICK
, coords
, event
) )
4166 // we want double click to select a cell and start editing
4167 // (i.e. to behave in same way as sequence of two slow clicks):
4168 m_waitForSlowClick
= true;
4174 wxGrid::DoGridCellLeftUp(wxMouseEvent
& event
, const wxGridCellCoords
& coords
)
4176 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4180 m_winCapture
->ReleaseMouse();
4181 m_winCapture
= NULL
;
4184 if ( coords
== m_currentCellCoords
&& m_waitForSlowClick
&& CanEnableCellControl() )
4187 EnableCellEditControl();
4189 wxGridCellAttr
*attr
= GetCellAttr(coords
);
4190 wxGridCellEditor
*editor
= attr
->GetEditor(this, coords
.GetRow(), coords
.GetCol());
4191 editor
->StartingClick();
4195 m_waitForSlowClick
= false;
4197 else if ( m_selectedBlockTopLeft
!= wxGridNoCellCoords
&&
4198 m_selectedBlockBottomRight
!= wxGridNoCellCoords
)
4202 m_selection
->SelectBlock( m_selectedBlockTopLeft
,
4203 m_selectedBlockBottomRight
,
4207 m_selectedBlockTopLeft
= wxGridNoCellCoords
;
4208 m_selectedBlockBottomRight
= wxGridNoCellCoords
;
4210 // Show the edit control, if it has been hidden for
4212 ShowCellEditControl();
4215 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_ROW
)
4217 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
4218 DoEndDragResizeRow(event
);
4220 else if ( m_cursorMode
== WXGRID_CURSOR_RESIZE_COL
)
4222 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
4223 DoEndDragResizeCol(event
);
4230 wxGrid::DoGridMouseMoveEvent(wxMouseEvent
& WXUNUSED(event
),
4231 const wxGridCellCoords
& coords
,
4234 if ( coords
.GetRow() < 0 || coords
.GetCol() < 0 )
4236 // out of grid cell area
4237 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
4241 int dragRow
= YToEdgeOfRow( pos
.y
);
4242 int dragCol
= XToEdgeOfCol( pos
.x
);
4244 // Dragging on the corner of a cell to resize in both
4245 // directions is not implemented yet...
4247 if ( dragRow
>= 0 && dragCol
>= 0 )
4249 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
4253 if ( dragRow
>= 0 && CanDragGridSize() && CanDragRowSize(dragRow
) )
4255 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4257 m_dragRowOrCol
= dragRow
;
4258 ChangeCursorMode(WXGRID_CURSOR_RESIZE_ROW
, NULL
, false);
4261 // When using the native header window we can only resize the columns by
4262 // dragging the dividers in it because we can't make it enter into the
4263 // column resizing mode programmatically
4264 else if ( dragCol
>= 0 && !m_useNativeHeader
&&
4265 CanDragGridSize() && CanDragColSize(dragCol
) )
4267 if ( m_cursorMode
== WXGRID_CURSOR_SELECT_CELL
)
4269 m_dragRowOrCol
= dragCol
;
4270 ChangeCursorMode(WXGRID_CURSOR_RESIZE_COL
, NULL
, false);
4273 else // Neither on a row or col edge
4275 if ( m_cursorMode
!= WXGRID_CURSOR_SELECT_CELL
)
4277 ChangeCursorMode(WXGRID_CURSOR_SELECT_CELL
);
4282 void wxGrid::ProcessGridCellMouseEvent(wxMouseEvent
& event
)
4284 if ( event
.Entering() || event
.Leaving() )
4286 // we don't care about these events but we must not reset m_isDragging
4287 // if they happen so return before anything else is done
4292 const wxPoint pos
= CalcUnscrolledPosition(event
.GetPosition());
4294 // coordinates of the cell under mouse
4295 wxGridCellCoords coords
= XYToCell(pos
);
4297 int cell_rows
, cell_cols
;
4298 GetCellSize( coords
.GetRow(), coords
.GetCol(), &cell_rows
, &cell_cols
);
4299 if ( (cell_rows
< 0) || (cell_cols
< 0) )
4301 coords
.SetRow(coords
.GetRow() + cell_rows
);
4302 coords
.SetCol(coords
.GetCol() + cell_cols
);
4305 if ( event
.Dragging() )
4307 if ( event
.LeftIsDown() )
4308 DoGridDragEvent(event
, coords
);
4314 m_isDragging
= false;
4315 m_startDragPos
= wxDefaultPosition
;
4317 // deal with various button presses
4318 if ( event
.IsButton() )
4320 if ( coords
!= wxGridNoCellCoords
)
4322 DisableCellEditControl();
4324 if ( event
.LeftDown() )
4325 DoGridCellLeftDown(event
, coords
, pos
);
4326 else if ( event
.LeftDClick() )
4327 DoGridCellLeftDClick(event
, coords
, pos
);
4328 else if ( event
.RightDown() )
4329 SendEvent(wxEVT_GRID_CELL_RIGHT_CLICK
, coords
, event
);
4330 else if ( event
.RightDClick() )
4331 SendEvent(wxEVT_GRID_CELL_RIGHT_DCLICK
, coords
, event
);
4334 // this one should be called even if we're not over any cell
4335 if ( event
.LeftUp() )
4337 DoGridCellLeftUp(event
, coords
);
4340 else if ( event
.Moving() )
4342 DoGridMouseMoveEvent(event
, coords
, pos
);
4344 else // unknown mouse event?
4350 // this function returns true only if the size really changed
4351 bool wxGrid::DoEndDragResizeLine(const wxGridOperations
& oper
)
4353 if ( m_dragLastPos
== -1 )
4356 const wxGridOperations
& doper
= oper
.Dual();
4358 const wxSize size
= m_gridWin
->GetClientSize();
4360 const wxPoint ptOrigin
= CalcUnscrolledPosition(wxPoint(0, 0));
4362 // erase the last line we drew
4363 wxClientDC
dc(m_gridWin
);
4365 dc
.SetLogicalFunction(wxINVERT
);
4367 const int posLineStart
= oper
.Select(ptOrigin
);
4368 const int posLineEnd
= oper
.Select(ptOrigin
) + oper
.Select(size
);
4370 oper
.DrawParallelLine(dc
, posLineStart
, posLineEnd
, m_dragLastPos
);
4372 // temporarily hide the edit control before resizing
4373 HideCellEditControl();
4374 SaveEditControlValue();
4376 // do resize the line
4377 const int lineStart
= oper
.GetLineStartPos(this, m_dragRowOrCol
);
4378 const int lineSizeOld
= oper
.GetLineSize(this, m_dragRowOrCol
);
4379 oper
.SetLineSize(this, m_dragRowOrCol
,
4380 wxMax(m_dragLastPos
- lineStart
,
4381 oper
.GetMinimalLineSize(this, m_dragRowOrCol
)));
4383 sizeChanged
= oper
.GetLineSize(this, m_dragRowOrCol
) != lineSizeOld
;
4387 // refresh now if we're not frozen
4388 if ( !GetBatchCount() )
4390 // we need to refresh everything beyond the resized line in the header
4393 // get the position from which to refresh in the other direction
4394 wxRect
rect(CellToRect(oper
.MakeCoords(m_dragRowOrCol
, 0)));
4395 rect
.SetPosition(CalcScrolledPosition(rect
.GetPosition()));
4397 // we only need the ordinate (for rows) or abscissa (for columns) here,
4398 // and need to cover the entire window in the other direction
4399 oper
.Select(rect
) = 0;
4401 wxRect
rectHeader(rect
.GetPosition(),
4404 oper
.GetHeaderWindowSize(this),
4405 doper
.Select(size
) - doper
.Select(rect
)
4408 oper
.GetHeaderWindow(this)->Refresh(true, &rectHeader
);
4411 // also refresh the grid window: extend the rectangle
4414 oper
.SelectSize(rect
) = oper
.Select(size
);
4416 int subtractLines
= 0;
4417 int line
= doper
.PosToLine(this, posLineStart
);
4420 // ensure that if we have a multi-cell block we redraw all of
4421 // it by increasing the refresh area to cover it entirely if a
4422 // part of it is affected
4423 const int lineEnd
= doper
.PosToLine(this, posLineEnd
, true);
4424 for ( ; line
< lineEnd
; line
++ )
4426 int cellLines
= oper
.Select(
4427 GetCellSize(oper
.MakeCoords(m_dragRowOrCol
, line
)));
4428 if ( cellLines
< subtractLines
)
4429 subtractLines
= cellLines
;
4434 oper
.GetLineStartPos(this, m_dragRowOrCol
+ subtractLines
);
4435 startPos
= doper
.CalcScrolledPosition(this, startPos
);
4437 doper
.Select(rect
) = startPos
;
4438 doper
.SelectSize(rect
) = doper
.Select(size
) - startPos
;
4440 m_gridWin
->Refresh(false, &rect
);
4444 // show the edit control back again
4445 ShowCellEditControl();
4450 void wxGrid::DoEndDragResizeRow(const wxMouseEvent
& event
)
4452 // TODO: generate RESIZING event, see #10754
4454 if ( DoEndDragResizeLine(wxGridRowOperations()) )
4455 SendGridSizeEvent(wxEVT_GRID_ROW_SIZE
, m_dragRowOrCol
, -1, event
);
4458 void wxGrid::DoEndDragResizeCol(const wxMouseEvent
& event
)
4460 // TODO: generate RESIZING event, see #10754
4462 if ( DoEndDragResizeLine(wxGridColumnOperations()) )
4463 SendGridSizeEvent(wxEVT_GRID_COL_SIZE
, -1, m_dragRowOrCol
, event
);
4466 void wxGrid::DoStartMoveCol(int col
)
4468 m_dragRowOrCol
= col
;
4471 void wxGrid::DoEndMoveCol(int pos
)
4473 wxASSERT_MSG( m_dragRowOrCol
!= -1, "no matching DoStartMoveCol?" );
4475 if ( SendEvent(wxEVT_GRID_COL_MOVE
, -1, m_dragRowOrCol
) != -1 )
4476 SetColPos(m_dragRowOrCol
, pos
);
4477 //else: vetoed by user
4479 m_dragRowOrCol
= -1;
4482 void wxGrid::RefreshAfterColPosChange()
4484 // recalculate the column rights as the column positions have changed,
4485 // unless we calculate them dynamically because all columns widths are the
4486 // same and it's easy to do
4487 if ( !m_colWidths
.empty() )
4490 for ( int colPos
= 0; colPos
< m_numCols
; colPos
++ )
4492 int colID
= GetColAt( colPos
);
4494 colRight
+= m_colWidths
[colID
];
4495 m_colRights
[colID
] = colRight
;
4499 // and make the changes visible
4500 if ( m_useNativeHeader
)
4502 if ( m_colAt
.empty() )
4503 GetGridColHeader()->ResetColumnsOrder();
4505 GetGridColHeader()->SetColumnsOrder(m_colAt
);
4509 m_colWindow
->Refresh();
4511 m_gridWin
->Refresh();
4514 void wxGrid::SetColumnsOrder(const wxArrayInt
& order
)
4518 RefreshAfterColPosChange();
4521 void wxGrid::SetColPos(int idx
, int pos
)
4523 // we're going to need m_colAt now, initialize it if needed
4524 if ( m_colAt
.empty() )
4526 m_colAt
.reserve(m_numCols
);
4527 for ( int i
= 0; i
< m_numCols
; i
++ )
4528 m_colAt
.push_back(i
);
4531 wxHeaderCtrl::MoveColumnInOrderArray(m_colAt
, idx
, pos
);
4533 RefreshAfterColPosChange();
4536 void wxGrid::ResetColPos()
4540 RefreshAfterColPosChange();
4543 void wxGrid::EnableDragColMove( bool enable
)
4545 if ( m_canDragColMove
== enable
)
4548 if ( m_useNativeHeader
)
4550 // update all columns to make them [not] reorderable
4551 GetGridColHeader()->SetColumnCount(m_numCols
);
4554 m_canDragColMove
= enable
;
4556 // we use to call ResetColPos() from here if !enable but this doesn't seem
4557 // right as it would mean there would be no way to "freeze" the current
4558 // columns order by disabling moving them after putting them in the desired
4559 // order, whereas now you can always call ResetColPos() manually if needed
4564 // ------ interaction with data model
4566 bool wxGrid::ProcessTableMessage( wxGridTableMessage
& msg
)
4568 switch ( msg
.GetId() )
4570 case wxGRIDTABLE_REQUEST_VIEW_GET_VALUES
:
4571 return GetModelValues();
4573 case wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES
:
4574 return SetModelValues();
4576 case wxGRIDTABLE_NOTIFY_ROWS_INSERTED
:
4577 case wxGRIDTABLE_NOTIFY_ROWS_APPENDED
:
4578 case wxGRIDTABLE_NOTIFY_ROWS_DELETED
:
4579 case wxGRIDTABLE_NOTIFY_COLS_INSERTED
:
4580 case wxGRIDTABLE_NOTIFY_COLS_APPENDED
:
4581 case wxGRIDTABLE_NOTIFY_COLS_DELETED
:
4582 return Redimension( msg
);
4589 // The behaviour of this function depends on the grid table class
4590 // Clear() function. For the default wxGridStringTable class the
4591 // behaviour is to replace all cell contents with wxEmptyString but
4592 // not to change the number of rows or cols.
4594 void wxGrid::ClearGrid()
4598 if (IsCellEditControlEnabled())
4599 DisableCellEditControl();
4602 if (!GetBatchCount())
4603 m_gridWin
->Refresh();
4608 wxGrid::DoModifyLines(bool (wxGridTableBase::*funcModify
)(size_t, size_t),
4609 int pos
, int num
, bool WXUNUSED(updateLabels
) )
4611 wxCHECK_MSG( m_created
, false, "must finish creating the grid first" );
4616 if ( IsCellEditControlEnabled() )
4617 DisableCellEditControl();
4619 return (m_table
->*funcModify
)(pos
, num
);
4621 // the table will have sent the results of the insert row
4622 // operation to this view object as a grid table message
4626 wxGrid::DoAppendLines(bool (wxGridTableBase::*funcAppend
)(size_t),
4627 int num
, bool WXUNUSED(updateLabels
))
4629 wxCHECK_MSG( m_created
, false, "must finish creating the grid first" );
4634 return (m_table
->*funcAppend
)(num
);
4637 // ----------------------------------------------------------------------------
4638 // event generation helpers
4639 // ----------------------------------------------------------------------------
4642 wxGrid::SendGridSizeEvent(wxEventType type
,
4644 const wxMouseEvent
& mouseEv
)
4646 int rowOrCol
= row
== -1 ? col
: row
;
4648 wxGridSizeEvent
gridEvt( GetId(),
4652 mouseEv
.GetX() + GetRowLabelSize(),
4653 mouseEv
.GetY() + GetColLabelSize(),
4656 GetEventHandler()->ProcessEvent(gridEvt
);
4659 // Generate a grid event based on a mouse event and return:
4660 // -1 if the event was vetoed
4661 // +1 if the event was processed (but not vetoed)
4662 // 0 if the event wasn't handled
4664 wxGrid::SendEvent(const wxEventType type
,
4666 const wxMouseEvent
& mouseEv
)
4668 bool claimed
, vetoed
;
4670 if ( type
== wxEVT_GRID_RANGE_SELECT
)
4672 // Right now, it should _never_ end up here!
4673 wxGridRangeSelectEvent
gridEvt( GetId(),
4676 m_selectedBlockTopLeft
,
4677 m_selectedBlockBottomRight
,
4681 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
4682 vetoed
= !gridEvt
.IsAllowed();
4684 else if ( type
== wxEVT_GRID_LABEL_LEFT_CLICK
||
4685 type
== wxEVT_GRID_LABEL_LEFT_DCLICK
||
4686 type
== wxEVT_GRID_LABEL_RIGHT_CLICK
||
4687 type
== wxEVT_GRID_LABEL_RIGHT_DCLICK
)
4689 wxPoint pos
= mouseEv
.GetPosition();
4691 if ( mouseEv
.GetEventObject() == GetGridRowLabelWindow() )
4692 pos
.y
+= GetColLabelSize();
4693 if ( mouseEv
.GetEventObject() == GetGridColLabelWindow() )
4694 pos
.x
+= GetRowLabelSize();
4696 wxGridEvent
gridEvt( GetId(),
4704 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
4705 vetoed
= !gridEvt
.IsAllowed();
4709 wxGridEvent
gridEvt( GetId(),
4713 mouseEv
.GetX() + GetRowLabelSize(),
4714 mouseEv
.GetY() + GetColLabelSize(),
4718 if ( type
== wxEVT_GRID_CELL_BEGIN_DRAG
)
4720 // by default the dragging is not supported, the user code must
4721 // explicitly allow the event for it to take place
4725 claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
4726 vetoed
= !gridEvt
.IsAllowed();
4729 // A Veto'd event may not be `claimed' so test this first
4733 return claimed
? 1 : 0;
4736 // Generate a grid event of specified type, return value same as above
4739 wxGrid::SendEvent(const wxEventType type
, int row
, int col
, const wxString
& s
)
4741 wxGridEvent
gridEvt( GetId(), type
, this, row
, col
);
4742 gridEvt
.SetString(s
);
4744 const bool claimed
= GetEventHandler()->ProcessEvent(gridEvt
);
4746 // A Veto'd event may not be `claimed' so test this first
4747 if ( !gridEvt
.IsAllowed() )
4750 return claimed
? 1 : 0;
4753 void wxGrid::OnPaint( wxPaintEvent
& WXUNUSED(event
) )
4755 // needed to prevent zillions of paint events on MSW
4759 void wxGrid::Refresh(bool eraseb
, const wxRect
* rect
)
4761 // Don't do anything if between Begin/EndBatch...
4762 // EndBatch() will do all this on the last nested one anyway.
4763 if ( m_created
&& !GetBatchCount() )
4765 // Refresh to get correct scrolled position:
4766 wxScrolledWindow::Refresh(eraseb
, rect
);
4770 int rect_x
, rect_y
, rectWidth
, rectHeight
;
4771 int width_label
, width_cell
, height_label
, height_cell
;
4774 // Copy rectangle can get scroll offsets..
4775 rect_x
= rect
->GetX();
4776 rect_y
= rect
->GetY();
4777 rectWidth
= rect
->GetWidth();
4778 rectHeight
= rect
->GetHeight();
4780 width_label
= m_rowLabelWidth
- rect_x
;
4781 if (width_label
> rectWidth
)
4782 width_label
= rectWidth
;
4784 height_label
= m_colLabelHeight
- rect_y
;
4785 if (height_label
> rectHeight
)
4786 height_label
= rectHeight
;
4788 if (rect_x
> m_rowLabelWidth
)
4790 x
= rect_x
- m_rowLabelWidth
;
4791 width_cell
= rectWidth
;
4796 width_cell
= rectWidth
- (m_rowLabelWidth
- rect_x
);
4799 if (rect_y
> m_colLabelHeight
)
4801 y
= rect_y
- m_colLabelHeight
;
4802 height_cell
= rectHeight
;
4807 height_cell
= rectHeight
- (m_colLabelHeight
- rect_y
);
4810 // Paint corner label part intersecting rect.
4811 if ( width_label
> 0 && height_label
> 0 )
4813 wxRect
anotherrect(rect_x
, rect_y
, width_label
, height_label
);
4814 m_cornerLabelWin
->Refresh(eraseb
, &anotherrect
);
4817 // Paint col labels part intersecting rect.
4818 if ( width_cell
> 0 && height_label
> 0 )
4820 wxRect
anotherrect(x
, rect_y
, width_cell
, height_label
);
4821 m_colWindow
->Refresh(eraseb
, &anotherrect
);
4824 // Paint row labels part intersecting rect.
4825 if ( width_label
> 0 && height_cell
> 0 )
4827 wxRect
anotherrect(rect_x
, y
, width_label
, height_cell
);
4828 m_rowLabelWin
->Refresh(eraseb
, &anotherrect
);
4831 // Paint cell area part intersecting rect.
4832 if ( width_cell
> 0 && height_cell
> 0 )
4834 wxRect
anotherrect(x
, y
, width_cell
, height_cell
);
4835 m_gridWin
->Refresh(eraseb
, &anotherrect
);
4840 m_cornerLabelWin
->Refresh(eraseb
, NULL
);
4841 m_colWindow
->Refresh(eraseb
, NULL
);
4842 m_rowLabelWin
->Refresh(eraseb
, NULL
);
4843 m_gridWin
->Refresh(eraseb
, NULL
);
4848 void wxGrid::OnSize(wxSizeEvent
& WXUNUSED(event
))
4850 if (m_targetWindow
!= this) // check whether initialisation has been done
4852 // reposition our children windows
4857 void wxGrid::OnKeyDown( wxKeyEvent
& event
)
4859 if ( m_inOnKeyDown
)
4861 // shouldn't be here - we are going round in circles...
4863 wxFAIL_MSG( wxT("wxGrid::OnKeyDown called while already active") );
4866 m_inOnKeyDown
= true;
4868 // propagate the event up and see if it gets processed
4869 wxWindow
*parent
= GetParent();
4870 wxKeyEvent
keyEvt( event
);
4871 keyEvt
.SetEventObject( parent
);
4873 if ( !parent
->GetEventHandler()->ProcessEvent( keyEvt
) )
4875 if (GetLayoutDirection() == wxLayout_RightToLeft
)
4877 if (event
.GetKeyCode() == WXK_RIGHT
)
4878 event
.m_keyCode
= WXK_LEFT
;
4879 else if (event
.GetKeyCode() == WXK_LEFT
)
4880 event
.m_keyCode
= WXK_RIGHT
;
4883 // try local handlers
4884 switch ( event
.GetKeyCode() )
4887 if ( event
.ControlDown() )
4888 MoveCursorUpBlock( event
.ShiftDown() );
4890 MoveCursorUp( event
.ShiftDown() );
4894 if ( event
.ControlDown() )
4895 MoveCursorDownBlock( event
.ShiftDown() );
4897 MoveCursorDown( event
.ShiftDown() );
4901 if ( event
.ControlDown() )
4902 MoveCursorLeftBlock( event
.ShiftDown() );
4904 MoveCursorLeft( event
.ShiftDown() );
4908 if ( event
.ControlDown() )
4909 MoveCursorRightBlock( event
.ShiftDown() );
4911 MoveCursorRight( event
.ShiftDown() );
4915 case WXK_NUMPAD_ENTER
:
4916 if ( event
.ControlDown() )
4918 event
.Skip(); // to let the edit control have the return
4922 if ( GetGridCursorRow() < GetNumberRows()-1 )
4924 MoveCursorDown( event
.ShiftDown() );
4928 // at the bottom of a column
4929 DisableCellEditControl();
4940 // send an event to the grid's parents for custom handling
4941 wxGridEvent
gridEvt(GetId(), wxEVT_GRID_TABBING
, this,
4942 GetGridCursorRow(), GetGridCursorCol(),
4943 -1, -1, false, event
);
4944 if ( ProcessWindowEvent(gridEvt
) )
4946 // the event has been handled so no need for more processing
4950 DoGridProcessTab( event
);
4954 GoToCell(event
.ControlDown() ? 0
4955 : m_currentCellCoords
.GetRow(),
4960 GoToCell(event
.ControlDown() ? m_numRows
- 1
4961 : m_currentCellCoords
.GetRow(),
4974 // Ctrl-Space selects the current column, Shift-Space -- the
4975 // current row and Ctrl-Shift-Space -- everything
4976 switch ( m_selection
? event
.GetModifiers() : wxMOD_NONE
)
4979 m_selection
->SelectCol(m_currentCellCoords
.GetCol());
4983 m_selection
->SelectRow(m_currentCellCoords
.GetRow());
4986 case wxMOD_CONTROL
| wxMOD_SHIFT
:
4987 m_selection
->SelectBlock(0, 0,
4988 m_numRows
- 1, m_numCols
- 1);
4992 if ( !IsEditable() )
4994 MoveCursorRight(false);
4997 //else: fall through
5010 m_inOnKeyDown
= false;
5013 void wxGrid::OnKeyUp( wxKeyEvent
& event
)
5015 // try local handlers
5017 if ( event
.GetKeyCode() == WXK_SHIFT
)
5019 if ( m_selectedBlockTopLeft
!= wxGridNoCellCoords
&&
5020 m_selectedBlockBottomRight
!= wxGridNoCellCoords
)
5024 m_selection
->SelectBlock(
5025 m_selectedBlockTopLeft
,
5026 m_selectedBlockBottomRight
,
5031 m_selectedBlockTopLeft
= wxGridNoCellCoords
;
5032 m_selectedBlockBottomRight
= wxGridNoCellCoords
;
5033 m_selectedBlockCorner
= wxGridNoCellCoords
;
5037 void wxGrid::OnChar( wxKeyEvent
& event
)
5039 // is it possible to edit the current cell at all?
5040 if ( !IsCellEditControlEnabled() && CanEnableCellControl() )
5042 // yes, now check whether the cells editor accepts the key
5043 int row
= m_currentCellCoords
.GetRow();
5044 int col
= m_currentCellCoords
.GetCol();
5045 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
5046 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
5048 // <F2> is special and will always start editing, for
5049 // other keys - ask the editor itself
5050 if ( (event
.GetKeyCode() == WXK_F2
&& !event
.HasModifiers())
5051 || editor
->IsAcceptedKey(event
) )
5053 // ensure cell is visble
5054 MakeCellVisible(row
, col
);
5055 EnableCellEditControl();
5057 // a problem can arise if the cell is not completely
5058 // visible (even after calling MakeCellVisible the
5059 // control is not created and calling StartingKey will
5061 if ( event
.GetKeyCode() != WXK_F2
&& editor
->IsCreated() && m_cellEditCtrlEnabled
)
5062 editor
->StartingKey(event
);
5078 void wxGrid::OnEraseBackground(wxEraseEvent
&)
5082 void wxGrid::DoGridProcessTab(wxKeyboardState
& kbdState
)
5084 const bool isForwardTab
= !kbdState
.ShiftDown();
5086 // TAB processing only changes when we are at the borders of the grid, so
5087 // let's first handle the common behaviour when we are not at the border.
5090 if ( GetGridCursorCol() < GetNumberCols() - 1 )
5092 MoveCursorRight( false );
5098 if ( GetGridCursorCol() )
5100 MoveCursorLeft( false );
5106 // We only get here if the cursor is at the border of the grid, apply the
5107 // configured behaviour.
5108 switch ( m_tabBehaviour
)
5111 // Nothing special to do, we remain at the current cell.
5115 // Go to the beginning of the next or the end of the previous row.
5118 if ( GetGridCursorRow() < GetNumberRows() - 1 )
5120 GoToCell( GetGridCursorRow() + 1, 0 );
5126 if ( GetGridCursorRow() > 0 )
5128 GoToCell( GetGridCursorRow() - 1, GetNumberCols() - 1 );
5135 if ( Navigate( isForwardTab
? wxNavigationKeyEvent::IsForward
5136 : wxNavigationKeyEvent::IsBackward
) )
5141 // If we remain in this cell, stop editing it if we were doing so.
5142 DisableCellEditControl();
5145 bool wxGrid::SetCurrentCell( const wxGridCellCoords
& coords
)
5147 if ( SendEvent(wxEVT_GRID_SELECT_CELL
, coords
) == -1 )
5149 // the event has been vetoed - do nothing
5153 #if !defined(__WXMAC__)
5154 wxClientDC
dc( m_gridWin
);
5158 if ( m_currentCellCoords
!= wxGridNoCellCoords
)
5160 DisableCellEditControl();
5162 if ( IsVisible( m_currentCellCoords
, false ) )
5165 r
= BlockToDeviceRect( m_currentCellCoords
, m_currentCellCoords
);
5166 if ( !m_gridLinesEnabled
)
5174 wxGridCellCoordsArray cells
= CalcCellsExposed( r
);
5176 // Otherwise refresh redraws the highlight!
5177 m_currentCellCoords
= coords
;
5179 #if defined(__WXMAC__)
5180 m_gridWin
->Refresh(true /*, & r */);
5182 DrawGridCellArea( dc
, cells
);
5183 DrawAllGridLines( dc
, r
);
5188 m_currentCellCoords
= coords
;
5190 wxGridCellAttr
*attr
= GetCellAttr( coords
);
5191 #if !defined(__WXMAC__)
5192 DrawCellHighlight( dc
, attr
);
5200 wxGrid::UpdateBlockBeingSelected(int topRow
, int leftCol
,
5201 int bottomRow
, int rightCol
)
5203 MakeCellVisible(m_selectedBlockCorner
);
5204 m_selectedBlockCorner
= wxGridCellCoords(bottomRow
, rightCol
);
5208 switch ( m_selection
->GetSelectionMode() )
5211 wxFAIL_MSG( "unknown selection mode" );
5214 case wxGridSelectCells
:
5215 // arbitrary blocks selection allowed so just use the cell
5216 // coordinates as is
5219 case wxGridSelectRows
:
5220 // only full rows selection allowd, ensure that we do select
5223 rightCol
= GetNumberCols() - 1;
5226 case wxGridSelectColumns
:
5227 // same as above but for columns
5229 bottomRow
= GetNumberRows() - 1;
5232 case wxGridSelectRowsOrColumns
:
5233 // in this mode we can select only full rows or full columns so
5234 // it doesn't make sense to select blocks at all (and we can't
5235 // extend the block because there is no preferred direction, we
5236 // could only extend it to cover the entire grid but this is
5242 EnsureFirstLessThanSecond(topRow
, bottomRow
);
5243 EnsureFirstLessThanSecond(leftCol
, rightCol
);
5245 wxGridCellCoords updateTopLeft
= wxGridCellCoords(topRow
, leftCol
),
5246 updateBottomRight
= wxGridCellCoords(bottomRow
, rightCol
);
5248 // First the case that we selected a completely new area
5249 if ( m_selectedBlockTopLeft
== wxGridNoCellCoords
||
5250 m_selectedBlockBottomRight
== wxGridNoCellCoords
)
5253 rect
= BlockToDeviceRect( wxGridCellCoords ( topRow
, leftCol
),
5254 wxGridCellCoords ( bottomRow
, rightCol
) );
5255 m_gridWin
->Refresh( false, &rect
);
5258 // Now handle changing an existing selection area.
5259 else if ( m_selectedBlockTopLeft
!= updateTopLeft
||
5260 m_selectedBlockBottomRight
!= updateBottomRight
)
5262 // Compute two optimal update rectangles:
5263 // Either one rectangle is a real subset of the
5264 // other, or they are (almost) disjoint!
5266 bool need_refresh
[4];
5270 need_refresh
[3] = false;
5273 // Store intermediate values
5274 wxCoord oldLeft
= m_selectedBlockTopLeft
.GetCol();
5275 wxCoord oldTop
= m_selectedBlockTopLeft
.GetRow();
5276 wxCoord oldRight
= m_selectedBlockBottomRight
.GetCol();
5277 wxCoord oldBottom
= m_selectedBlockBottomRight
.GetRow();
5279 // Determine the outer/inner coordinates.
5280 EnsureFirstLessThanSecond(oldLeft
, leftCol
);
5281 EnsureFirstLessThanSecond(oldTop
, topRow
);
5282 EnsureFirstLessThanSecond(rightCol
, oldRight
);
5283 EnsureFirstLessThanSecond(bottomRow
, oldBottom
);
5285 // Now, either the stuff marked old is the outer
5286 // rectangle or we don't have a situation where one
5287 // is contained in the other.
5289 if ( oldLeft
< leftCol
)
5291 // Refresh the newly selected or deselected
5292 // area to the left of the old or new selection.
5293 need_refresh
[0] = true;
5294 rect
[0] = BlockToDeviceRect(
5295 wxGridCellCoords( oldTop
, oldLeft
),
5296 wxGridCellCoords( oldBottom
, leftCol
- 1 ) );
5299 if ( oldTop
< topRow
)
5301 // Refresh the newly selected or deselected
5302 // area above the old or new selection.
5303 need_refresh
[1] = true;
5304 rect
[1] = BlockToDeviceRect(
5305 wxGridCellCoords( oldTop
, leftCol
),
5306 wxGridCellCoords( topRow
- 1, rightCol
) );
5309 if ( oldRight
> rightCol
)
5311 // Refresh the newly selected or deselected
5312 // area to the right of the old or new selection.
5313 need_refresh
[2] = true;
5314 rect
[2] = BlockToDeviceRect(
5315 wxGridCellCoords( oldTop
, rightCol
+ 1 ),
5316 wxGridCellCoords( oldBottom
, oldRight
) );
5319 if ( oldBottom
> bottomRow
)
5321 // Refresh the newly selected or deselected
5322 // area below the old or new selection.
5323 need_refresh
[3] = true;
5324 rect
[3] = BlockToDeviceRect(
5325 wxGridCellCoords( bottomRow
+ 1, leftCol
),
5326 wxGridCellCoords( oldBottom
, rightCol
) );
5329 // various Refresh() calls
5330 for (i
= 0; i
< 4; i
++ )
5331 if ( need_refresh
[i
] && rect
[i
] != wxGridNoCellRect
)
5332 m_gridWin
->Refresh( false, &(rect
[i
]) );
5336 m_selectedBlockTopLeft
= updateTopLeft
;
5337 m_selectedBlockBottomRight
= updateBottomRight
;
5341 // ------ functions to get/send data (see also public functions)
5344 bool wxGrid::GetModelValues()
5346 // Hide the editor, so it won't hide a changed value.
5347 HideCellEditControl();
5351 // all we need to do is repaint the grid
5353 m_gridWin
->Refresh();
5360 bool wxGrid::SetModelValues()
5364 // Disable the editor, so it won't hide a changed value.
5365 // Do we also want to save the current value of the editor first?
5367 DisableCellEditControl();
5371 for ( row
= 0; row
< m_numRows
; row
++ )
5373 for ( col
= 0; col
< m_numCols
; col
++ )
5375 m_table
->SetValue( row
, col
, GetCellValue(row
, col
) );
5385 // Note - this function only draws cells that are in the list of
5386 // exposed cells (usually set from the update region by
5387 // CalcExposedCells)
5389 void wxGrid::DrawGridCellArea( wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
5391 if ( !m_numRows
|| !m_numCols
)
5394 int i
, numCells
= cells
.GetCount();
5395 int row
, col
, cell_rows
, cell_cols
;
5396 wxGridCellCoordsArray redrawCells
;
5398 for ( i
= numCells
- 1; i
>= 0; i
-- )
5400 row
= cells
[i
].GetRow();
5401 col
= cells
[i
].GetCol();
5402 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
5404 // If this cell is part of a multicell block, find owner for repaint
5405 if ( cell_rows
<= 0 || cell_cols
<= 0 )
5407 wxGridCellCoords
cell( row
+ cell_rows
, col
+ cell_cols
);
5408 bool marked
= false;
5409 for ( int j
= 0; j
< numCells
; j
++ )
5411 if ( cell
== cells
[j
] )
5420 int count
= redrawCells
.GetCount();
5421 for (int j
= 0; j
< count
; j
++)
5423 if ( cell
== redrawCells
[j
] )
5431 redrawCells
.Add( cell
);
5434 // don't bother drawing this cell
5438 // If this cell is empty, find cell to left that might want to overflow
5439 if (m_table
&& m_table
->IsEmptyCell(row
, col
))
5441 for ( int l
= 0; l
< cell_rows
; l
++ )
5443 // find a cell in this row to leave already marked for repaint
5445 for (int k
= 0; k
< int(redrawCells
.GetCount()); k
++)
5446 if ((redrawCells
[k
].GetCol() < left
) &&
5447 (redrawCells
[k
].GetRow() == row
))
5449 left
= redrawCells
[k
].GetCol();
5453 left
= 0; // oh well
5455 for (int j
= col
- 1; j
>= left
; j
--)
5457 if (!m_table
->IsEmptyCell(row
+ l
, j
))
5459 if (GetCellOverflow(row
+ l
, j
))
5461 wxGridCellCoords
cell(row
+ l
, j
);
5462 bool marked
= false;
5464 for (int k
= 0; k
< numCells
; k
++)
5466 if ( cell
== cells
[k
] )
5475 int count
= redrawCells
.GetCount();
5476 for (int k
= 0; k
< count
; k
++)
5478 if ( cell
== redrawCells
[k
] )
5485 redrawCells
.Add( cell
);
5494 DrawCell( dc
, cells
[i
] );
5497 numCells
= redrawCells
.GetCount();
5499 for ( i
= numCells
- 1; i
>= 0; i
-- )
5501 DrawCell( dc
, redrawCells
[i
] );
5505 void wxGrid::DrawGridSpace( wxDC
& dc
)
5508 m_gridWin
->GetClientSize( &cw
, &ch
);
5511 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
5513 int rightCol
= m_numCols
> 0 ? GetColRight(GetColAt( m_numCols
- 1 )) : 0;
5514 int bottomRow
= m_numRows
> 0 ? GetRowBottom(m_numRows
- 1) : 0;
5516 if ( right
> rightCol
|| bottom
> bottomRow
)
5519 CalcUnscrolledPosition( 0, 0, &left
, &top
);
5521 dc
.SetBrush(GetDefaultCellBackgroundColour());
5522 dc
.SetPen( *wxTRANSPARENT_PEN
);
5524 if ( right
> rightCol
)
5526 dc
.DrawRectangle( rightCol
, top
, right
- rightCol
, ch
);
5529 if ( bottom
> bottomRow
)
5531 dc
.DrawRectangle( left
, bottomRow
, cw
, bottom
- bottomRow
);
5536 void wxGrid::DrawCell( wxDC
& dc
, const wxGridCellCoords
& coords
)
5538 int row
= coords
.GetRow();
5539 int col
= coords
.GetCol();
5541 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
5544 // we draw the cell border ourselves
5545 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
5547 bool isCurrent
= coords
== m_currentCellCoords
;
5549 wxRect rect
= CellToRect( row
, col
);
5551 // if the editor is shown, we should use it and not the renderer
5552 // Note: However, only if it is really _shown_, i.e. not hidden!
5553 if ( isCurrent
&& IsCellEditControlShown() )
5555 // NB: this "#if..." is temporary and fixes a problem where the
5556 // edit control is erased by this code after being rendered.
5557 // On wxMac (QD build only), the cell editor is a wxTextCntl and is rendered
5558 // implicitly, causing this out-of order render.
5559 #if !defined(__WXMAC__)
5560 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
5561 editor
->PaintBackground(dc
, rect
, *attr
);
5567 // but all the rest is drawn by the cell renderer and hence may be customized
5568 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
5569 renderer
->Draw(*this, *attr
, dc
, rect
, row
, col
, IsInSelection(coords
));
5576 void wxGrid::DrawCellHighlight( wxDC
& dc
, const wxGridCellAttr
*attr
)
5578 // don't show highlight when the grid doesn't have focus
5582 int row
= m_currentCellCoords
.GetRow();
5583 int col
= m_currentCellCoords
.GetCol();
5585 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
5588 wxRect rect
= CellToRect(row
, col
);
5590 // hmmm... what could we do here to show that the cell is disabled?
5591 // for now, I just draw a thinner border than for the other ones, but
5592 // it doesn't look really good
5594 int penWidth
= attr
->IsReadOnly() ? m_cellHighlightROPenWidth
: m_cellHighlightPenWidth
;
5598 // The center of the drawn line is where the position/width/height of
5599 // the rectangle is actually at (on wxMSW at least), so the
5600 // size of the rectangle is reduced to compensate for the thickness of
5601 // the line. If this is too strange on non-wxMSW platforms then
5602 // please #ifdef this appropriately.
5603 rect
.x
+= penWidth
/ 2;
5604 rect
.y
+= penWidth
/ 2;
5605 rect
.width
-= penWidth
- 1;
5606 rect
.height
-= penWidth
- 1;
5608 // Now draw the rectangle
5609 // use the cellHighlightColour if the cell is inside a selection, this
5610 // will ensure the cell is always visible.
5611 dc
.SetPen(wxPen(IsInSelection(row
,col
) ? m_selectionForeground
5612 : m_cellHighlightColour
,
5614 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
5615 dc
.DrawRectangle(rect
);
5619 wxPen
wxGrid::GetDefaultGridLinePen()
5621 return wxPen(GetGridLineColour());
5624 wxPen
wxGrid::GetRowGridLinePen(int WXUNUSED(row
))
5626 return GetDefaultGridLinePen();
5629 wxPen
wxGrid::GetColGridLinePen(int WXUNUSED(col
))
5631 return GetDefaultGridLinePen();
5634 void wxGrid::DrawCellBorder( wxDC
& dc
, const wxGridCellCoords
& coords
)
5636 int row
= coords
.GetRow();
5637 int col
= coords
.GetCol();
5638 if ( GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
5642 wxRect rect
= CellToRect( row
, col
);
5644 // right hand border
5645 dc
.SetPen( GetColGridLinePen(col
) );
5646 dc
.DrawLine( rect
.x
+ rect
.width
, rect
.y
,
5647 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
+ 1 );
5650 dc
.SetPen( GetRowGridLinePen(row
) );
5651 dc
.DrawLine( rect
.x
, rect
.y
+ rect
.height
,
5652 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
5655 void wxGrid::DrawHighlight(wxDC
& dc
, const wxGridCellCoordsArray
& cells
)
5657 // This if block was previously in wxGrid::OnPaint but that doesn't
5658 // seem to get called under wxGTK - MB
5660 if ( m_currentCellCoords
== wxGridNoCellCoords
&&
5661 m_numRows
&& m_numCols
)
5663 m_currentCellCoords
.Set(0, 0);
5666 if ( IsCellEditControlShown() )
5668 // don't show highlight when the edit control is shown
5672 // if the active cell was repainted, repaint its highlight too because it
5673 // might have been damaged by the grid lines
5674 size_t count
= cells
.GetCount();
5675 for ( size_t n
= 0; n
< count
; n
++ )
5677 wxGridCellCoords cell
= cells
[n
];
5679 // If we are using attributes, then we may have just exposed another
5680 // cell in a partially-visible merged cluster of cells. If the "anchor"
5681 // (upper left) cell of this merged cluster is the cell indicated by
5682 // m_currentCellCoords, then we need to refresh the cell highlight even
5683 // though the "anchor" itself is not part of our update segment.
5684 if ( CanHaveAttributes() )
5688 GetCellSize(cell
.GetRow(), cell
.GetCol(), &rows
, &cols
);
5691 cell
.SetRow(cell
.GetRow() + rows
);
5694 cell
.SetCol(cell
.GetCol() + cols
);
5697 if ( cell
== m_currentCellCoords
)
5699 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
5700 DrawCellHighlight(dc
, attr
);
5708 // Used by wxGrid::Render() to draw the grid lines only for the cells in the
5711 wxGrid::DrawRangeGridLines(wxDC
& dc
,
5712 const wxRegion
& reg
,
5713 const wxGridCellCoords
& topLeft
,
5714 const wxGridCellCoords
& bottomRight
)
5716 if ( !m_gridLinesEnabled
)
5719 int top
, left
, width
, height
;
5720 reg
.GetBox( left
, top
, width
, height
);
5722 // create a clipping region
5723 wxRegion
clippedcells( dc
.LogicalToDeviceX( left
),
5724 dc
.LogicalToDeviceY( top
),
5725 dc
.LogicalToDeviceXRel( width
),
5726 dc
.LogicalToDeviceYRel( height
) );
5728 // subtract multi cell span area from clipping region for lines
5730 for ( int row
= topLeft
.GetRow(); row
<= bottomRight
.GetRow(); row
++ )
5732 for ( int col
= topLeft
.GetCol(); col
<= bottomRight
.GetCol(); col
++ )
5734 int cell_rows
, cell_cols
;
5735 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
5736 if ( cell_rows
> 1 || cell_cols
> 1 ) // multi cell
5738 rect
= CellToRect( row
, col
);
5739 // cater for scaling
5740 // device origin already set in ::Render() for x, y
5741 rect
.x
= dc
.LogicalToDeviceX( rect
.x
);
5742 rect
.y
= dc
.LogicalToDeviceY( rect
.y
);
5743 rect
.width
= dc
.LogicalToDeviceXRel( rect
.width
);
5744 rect
.height
= dc
.LogicalToDeviceYRel( rect
.height
) - 1;
5745 clippedcells
.Subtract( rect
);
5747 else if ( cell_rows
< 0 || cell_cols
< 0 ) // part of multicell
5749 rect
= CellToRect( row
+ cell_rows
, col
+ cell_cols
);
5750 rect
.x
= dc
.LogicalToDeviceX( rect
.x
);
5751 rect
.y
= dc
.LogicalToDeviceY( rect
.y
);
5752 rect
.width
= dc
.LogicalToDeviceXRel( rect
.width
);
5753 rect
.height
= dc
.LogicalToDeviceYRel( rect
.height
) - 1;
5754 clippedcells
.Subtract( rect
);
5759 dc
.SetDeviceClippingRegion( clippedcells
);
5762 top
, left
, top
+ height
, left
+ width
,
5763 topLeft
.GetRow(), topLeft
.GetCol(),
5764 bottomRight
.GetRow(), bottomRight
.GetCol());
5766 dc
.DestroyClippingRegion();
5769 // This is used to redraw all grid lines e.g. when the grid line colour
5772 void wxGrid::DrawAllGridLines( wxDC
& dc
, const wxRegion
& WXUNUSED(reg
) )
5774 if ( !m_gridLinesEnabled
)
5777 int top
, bottom
, left
, right
;
5780 m_gridWin
->GetClientSize(&cw
, &ch
);
5781 CalcUnscrolledPosition( 0, 0, &left
, &top
);
5782 CalcUnscrolledPosition( cw
, ch
, &right
, &bottom
);
5784 // avoid drawing grid lines past the last row and col
5785 if ( m_gridLinesClipHorz
)
5790 const int lastColRight
= GetColRight(GetColAt(m_numCols
- 1));
5791 if ( right
> lastColRight
)
5792 right
= lastColRight
;
5795 if ( m_gridLinesClipVert
)
5800 const int lastRowBottom
= GetRowBottom(m_numRows
- 1);
5801 if ( bottom
> lastRowBottom
)
5802 bottom
= lastRowBottom
;
5805 // no gridlines inside multicells, clip them out
5806 int leftCol
= GetColPos( internalXToCol(left
) );
5807 int topRow
= internalYToRow(top
);
5808 int rightCol
= GetColPos( internalXToCol(right
) );
5809 int bottomRow
= internalYToRow(bottom
);
5811 wxRegion
clippedcells(0, 0, cw
, ch
);
5813 int cell_rows
, cell_cols
;
5816 for ( int j
= topRow
; j
<= bottomRow
; j
++ )
5818 for ( int colPos
= leftCol
; colPos
<= rightCol
; colPos
++ )
5820 int i
= GetColAt( colPos
);
5822 GetCellSize( j
, i
, &cell_rows
, &cell_cols
);
5823 if ((cell_rows
> 1) || (cell_cols
> 1))
5825 rect
= CellToRect(j
,i
);
5826 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
5827 clippedcells
.Subtract(rect
);
5829 else if ((cell_rows
< 0) || (cell_cols
< 0))
5831 rect
= CellToRect(j
+ cell_rows
, i
+ cell_cols
);
5832 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
5833 clippedcells
.Subtract(rect
);
5838 dc
.SetDeviceClippingRegion( clippedcells
);
5841 top
, left
, bottom
, right
,
5842 topRow
, leftCol
, m_numRows
, m_numCols
);
5844 dc
.DestroyClippingRegion();
5848 wxGrid::DoDrawGridLines(wxDC
& dc
,
5850 int bottom
, int right
,
5851 int topRow
, int leftCol
,
5852 int bottomRow
, int rightCol
)
5854 // horizontal grid lines
5855 for ( int i
= topRow
; i
< bottomRow
; i
++ )
5857 int bot
= GetRowBottom(i
) - 1;
5864 dc
.SetPen( GetRowGridLinePen(i
) );
5865 dc
.DrawLine( left
, bot
, right
, bot
);
5869 // vertical grid lines
5870 for ( int colPos
= leftCol
; colPos
< rightCol
; colPos
++ )
5872 int i
= GetColAt( colPos
);
5874 int colRight
= GetColRight(i
);
5876 if (GetLayoutDirection() != wxLayout_RightToLeft
)
5880 if ( colRight
> right
)
5883 if ( colRight
>= left
)
5885 dc
.SetPen( GetColGridLinePen(i
) );
5886 dc
.DrawLine( colRight
, top
, colRight
, bottom
);
5891 void wxGrid::DrawRowLabels( wxDC
& dc
, const wxArrayInt
& rows
)
5896 const size_t numLabels
= rows
.GetCount();
5897 for ( size_t i
= 0; i
< numLabels
; i
++ )
5899 DrawRowLabel( dc
, rows
[i
] );
5903 void wxGrid::DrawRowLabel( wxDC
& dc
, int row
)
5905 if ( GetRowHeight(row
) <= 0 || m_rowLabelWidth
<= 0 )
5908 wxGridCellAttrProvider
* const
5909 attrProvider
= m_table
? m_table
->GetAttrProvider() : NULL
;
5911 // notice that an explicit static_cast is needed to avoid a compilation
5912 // error with VC7.1 which, for some reason, tries to instantiate (abstract)
5913 // wxGridRowHeaderRenderer class without it
5914 const wxGridRowHeaderRenderer
&
5915 rend
= attrProvider
? attrProvider
->GetRowHeaderRenderer(row
)
5916 : static_cast<const wxGridRowHeaderRenderer
&>
5917 (gs_defaultHeaderRenderers
.rowRenderer
);
5919 wxRect
rect(0, GetRowTop(row
), m_rowLabelWidth
, GetRowHeight(row
));
5920 rend
.DrawBorder(*this, dc
, rect
);
5923 GetRowLabelAlignment(&hAlign
, &vAlign
);
5925 rend
.DrawLabel(*this, dc
, GetRowLabelValue(row
),
5926 rect
, hAlign
, vAlign
, wxHORIZONTAL
);
5929 void wxGrid::UseNativeColHeader(bool native
)
5931 if ( native
== m_useNativeHeader
)
5935 m_useNativeHeader
= native
;
5937 CreateColumnWindow();
5939 if ( m_useNativeHeader
)
5940 GetGridColHeader()->SetColumnCount(m_numCols
);
5944 void wxGrid::SetUseNativeColLabels( bool native
)
5946 wxASSERT_MSG( !m_useNativeHeader
,
5947 "doesn't make sense when using native header" );
5949 m_nativeColumnLabels
= native
;
5952 int height
= wxRendererNative::Get().GetHeaderButtonHeight( this );
5953 SetColLabelSize( height
);
5956 GetColLabelWindow()->Refresh();
5957 m_cornerLabelWin
->Refresh();
5960 void wxGrid::DrawColLabels( wxDC
& dc
,const wxArrayInt
& cols
)
5965 const size_t numLabels
= cols
.GetCount();
5966 for ( size_t i
= 0; i
< numLabels
; i
++ )
5968 DrawColLabel( dc
, cols
[i
] );
5972 void wxGrid::DrawCornerLabel(wxDC
& dc
)
5974 wxRect
rect(wxSize(m_rowLabelWidth
, m_colLabelHeight
));
5976 if ( m_nativeColumnLabels
)
5980 wxRendererNative::Get().DrawHeaderButton(m_cornerLabelWin
, dc
, rect
, 0);
5987 wxGridCellAttrProvider
* const
5988 attrProvider
= m_table
? m_table
->GetAttrProvider() : NULL
;
5989 const wxGridCornerHeaderRenderer
&
5990 rend
= attrProvider
? attrProvider
->GetCornerRenderer()
5991 : static_cast<wxGridCornerHeaderRenderer
&>
5992 (gs_defaultHeaderRenderers
.cornerRenderer
);
5994 rend
.DrawBorder(*this, dc
, rect
);
5998 void wxGrid::DrawColLabel(wxDC
& dc
, int col
)
6000 if ( GetColWidth(col
) <= 0 || m_colLabelHeight
<= 0 )
6003 int colLeft
= GetColLeft(col
);
6005 wxRect
rect(colLeft
, 0, GetColWidth(col
), m_colLabelHeight
);
6006 wxGridCellAttrProvider
* const
6007 attrProvider
= m_table
? m_table
->GetAttrProvider() : NULL
;
6008 const wxGridColumnHeaderRenderer
&
6009 rend
= attrProvider
? attrProvider
->GetColumnHeaderRenderer(col
)
6010 : static_cast<wxGridColumnHeaderRenderer
&>
6011 (gs_defaultHeaderRenderers
.colRenderer
);
6013 if ( m_nativeColumnLabels
)
6015 wxRendererNative::Get().DrawHeaderButton
6017 GetColLabelWindow(),
6022 ? IsSortOrderAscending()
6023 ? wxHDR_SORT_ICON_UP
6024 : wxHDR_SORT_ICON_DOWN
6025 : wxHDR_SORT_ICON_NONE
6031 // It is reported that we need to erase the background to avoid display
6032 // artefacts, see #12055.
6033 wxDCBrushChanger
setBrush(dc
, m_colWindow
->GetBackgroundColour());
6034 dc
.DrawRectangle(rect
);
6036 rend
.DrawBorder(*this, dc
, rect
);
6040 GetColLabelAlignment(&hAlign
, &vAlign
);
6041 const int orient
= GetColLabelTextOrientation();
6043 rend
.DrawLabel(*this, dc
, GetColLabelValue(col
), rect
, hAlign
, vAlign
, orient
);
6046 // TODO: these 2 functions should be replaced with wxDC::DrawLabel() to which
6047 // we just have to add textOrientation support
6048 void wxGrid::DrawTextRectangle( wxDC
& dc
,
6049 const wxString
& value
,
6053 int textOrientation
) const
6055 wxArrayString lines
;
6057 StringToLines( value
, lines
);
6059 DrawTextRectangle(dc
, lines
, rect
, horizAlign
, vertAlign
, textOrientation
);
6062 void wxGrid::DrawTextRectangle(wxDC
& dc
,
6063 const wxArrayString
& lines
,
6067 int textOrientation
) const
6069 if ( lines
.empty() )
6072 wxDCClipper
clip(dc
, rect
);
6077 if ( textOrientation
== wxHORIZONTAL
)
6078 GetTextBoxSize( dc
, lines
, &textWidth
, &textHeight
);
6080 GetTextBoxSize( dc
, lines
, &textHeight
, &textWidth
);
6084 switch ( vertAlign
)
6086 case wxALIGN_BOTTOM
:
6087 if ( textOrientation
== wxHORIZONTAL
)
6088 y
= rect
.y
+ (rect
.height
- textHeight
- 1);
6090 x
= rect
.x
+ rect
.width
- textWidth
;
6093 case wxALIGN_CENTRE
:
6094 if ( textOrientation
== wxHORIZONTAL
)
6095 y
= rect
.y
+ ((rect
.height
- textHeight
) / 2);
6097 x
= rect
.x
+ ((rect
.width
- textWidth
) / 2);
6102 if ( textOrientation
== wxHORIZONTAL
)
6109 // Align each line of a multi-line label
6110 size_t nLines
= lines
.GetCount();
6111 for ( size_t l
= 0; l
< nLines
; l
++ )
6113 const wxString
& line
= lines
[l
];
6117 *(textOrientation
== wxHORIZONTAL
? &y
: &x
) += dc
.GetCharHeight();
6121 wxCoord lineWidth
= 0,
6123 dc
.GetTextExtent(line
, &lineWidth
, &lineHeight
);
6125 switch ( horizAlign
)
6128 if ( textOrientation
== wxHORIZONTAL
)
6129 x
= rect
.x
+ (rect
.width
- lineWidth
- 1);
6131 y
= rect
.y
+ lineWidth
+ 1;
6134 case wxALIGN_CENTRE
:
6135 if ( textOrientation
== wxHORIZONTAL
)
6136 x
= rect
.x
+ ((rect
.width
- lineWidth
) / 2);
6138 y
= rect
.y
+ rect
.height
- ((rect
.height
- lineWidth
) / 2);
6143 if ( textOrientation
== wxHORIZONTAL
)
6146 y
= rect
.y
+ rect
.height
- 1;
6150 if ( textOrientation
== wxHORIZONTAL
)
6152 dc
.DrawText( line
, x
, y
);
6157 dc
.DrawRotatedText( line
, x
, y
, 90.0 );
6163 // Split multi-line text up into an array of strings.
6164 // Any existing contents of the string array are preserved.
6166 // TODO: refactor wxTextFile::Read() and reuse the same code from here
6167 void wxGrid::StringToLines( const wxString
& value
, wxArrayString
& lines
) const
6171 wxString eol
= wxTextFile::GetEOL( wxTextFileType_Unix
);
6172 wxString tVal
= wxTextFile::Translate( value
, wxTextFileType_Unix
);
6174 while ( startPos
< (int)tVal
.length() )
6176 pos
= tVal
.Mid(startPos
).Find( eol
);
6181 else if ( pos
== 0 )
6183 lines
.Add( wxEmptyString
);
6187 lines
.Add( tVal
.Mid(startPos
, pos
) );
6190 startPos
+= pos
+ 1;
6193 if ( startPos
< (int)tVal
.length() )
6195 lines
.Add( tVal
.Mid( startPos
) );
6199 void wxGrid::GetTextBoxSize( const wxDC
& dc
,
6200 const wxArrayString
& lines
,
6201 long *width
, long *height
) const
6205 wxCoord lineW
= 0, lineH
= 0;
6208 for ( i
= 0; i
< lines
.GetCount(); i
++ )
6210 dc
.GetTextExtent( lines
[i
], &lineW
, &lineH
);
6211 w
= wxMax( w
, lineW
);
6220 // ------ Batch processing.
6222 void wxGrid::EndBatch()
6224 if ( m_batchCount
> 0 )
6227 if ( !m_batchCount
)
6230 m_rowLabelWin
->Refresh();
6231 m_colWindow
->Refresh();
6232 m_cornerLabelWin
->Refresh();
6233 m_gridWin
->Refresh();
6238 // Use this, rather than wxWindow::Refresh(), to force an immediate
6239 // repainting of the grid. Has no effect if you are already inside a
6240 // BeginBatch / EndBatch block.
6242 void wxGrid::ForceRefresh()
6248 bool wxGrid::Enable(bool enable
)
6250 if ( !wxScrolledWindow::Enable(enable
) )
6253 // redraw in the new state
6254 m_gridWin
->Refresh();
6260 // ------ Edit control functions
6263 void wxGrid::EnableEditing( bool edit
)
6265 if ( edit
!= m_editable
)
6268 EnableCellEditControl(edit
);
6273 void wxGrid::EnableCellEditControl( bool enable
)
6278 if ( enable
!= m_cellEditCtrlEnabled
)
6282 if ( SendEvent(wxEVT_GRID_EDITOR_SHOWN
) == -1 )
6285 // this should be checked by the caller!
6286 wxASSERT_MSG( CanEnableCellControl(), wxT("can't enable editing for this cell!") );
6288 // do it before ShowCellEditControl()
6289 m_cellEditCtrlEnabled
= enable
;
6291 ShowCellEditControl();
6295 SendEvent(wxEVT_GRID_EDITOR_HIDDEN
);
6297 HideCellEditControl();
6298 SaveEditControlValue();
6300 // do it after HideCellEditControl()
6301 m_cellEditCtrlEnabled
= enable
;
6306 bool wxGrid::IsCurrentCellReadOnly() const
6309 attr
= const_cast<wxGrid
*>(this)->GetCellAttr(m_currentCellCoords
);
6310 bool readonly
= attr
->IsReadOnly();
6316 bool wxGrid::CanEnableCellControl() const
6318 return m_editable
&& (m_currentCellCoords
!= wxGridNoCellCoords
) &&
6319 !IsCurrentCellReadOnly();
6322 bool wxGrid::IsCellEditControlEnabled() const
6324 // the cell edit control might be disable for all cells or just for the
6325 // current one if it's read only
6326 return m_cellEditCtrlEnabled
? !IsCurrentCellReadOnly() : false;
6329 bool wxGrid::IsCellEditControlShown() const
6331 bool isShown
= false;
6333 if ( m_cellEditCtrlEnabled
)
6335 int row
= m_currentCellCoords
.GetRow();
6336 int col
= m_currentCellCoords
.GetCol();
6337 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6338 wxGridCellEditor
* editor
= attr
->GetEditor((wxGrid
*) this, row
, col
);
6343 if ( editor
->IsCreated() )
6345 isShown
= editor
->GetControl()->IsShown();
6355 void wxGrid::ShowCellEditControl()
6357 if ( IsCellEditControlEnabled() )
6359 if ( !IsVisible( m_currentCellCoords
, false ) )
6361 m_cellEditCtrlEnabled
= false;
6366 wxRect rect
= CellToRect( m_currentCellCoords
);
6367 int row
= m_currentCellCoords
.GetRow();
6368 int col
= m_currentCellCoords
.GetCol();
6370 // if this is part of a multicell, find owner (topleft)
6371 int cell_rows
, cell_cols
;
6372 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
6373 if ( cell_rows
<= 0 || cell_cols
<= 0 )
6377 m_currentCellCoords
.SetRow( row
);
6378 m_currentCellCoords
.SetCol( col
);
6381 // erase the highlight and the cell contents because the editor
6382 // might not cover the entire cell
6383 wxClientDC
dc( m_gridWin
);
6385 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6386 dc
.SetBrush(wxBrush(attr
->GetBackgroundColour()));
6387 dc
.SetPen(*wxTRANSPARENT_PEN
);
6388 dc
.DrawRectangle(rect
);
6390 // convert to scrolled coords
6391 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
6397 // cell is shifted by one pixel
6398 // However, don't allow x or y to become negative
6399 // since the SetSize() method interprets that as
6406 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
6407 if ( !editor
->IsCreated() )
6409 editor
->Create(m_gridWin
, wxID_ANY
,
6410 new wxGridCellEditorEvtHandler(this, editor
));
6412 wxGridEditorCreatedEvent
evt(GetId(),
6413 wxEVT_GRID_EDITOR_CREATED
,
6417 editor
->GetControl());
6418 GetEventHandler()->ProcessEvent(evt
);
6421 // resize editor to overflow into righthand cells if allowed
6422 int maxWidth
= rect
.width
;
6423 wxString value
= GetCellValue(row
, col
);
6424 if ( (value
!= wxEmptyString
) && (attr
->GetOverflow()) )
6427 GetTextExtent(value
, &maxWidth
, &y
, NULL
, NULL
, &attr
->GetFont());
6428 if (maxWidth
< rect
.width
)
6429 maxWidth
= rect
.width
;
6432 int client_right
= m_gridWin
->GetClientSize().GetWidth();
6433 if (rect
.x
+ maxWidth
> client_right
)
6434 maxWidth
= client_right
- rect
.x
;
6436 if ((maxWidth
> rect
.width
) && (col
< m_numCols
) && m_table
)
6438 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
6439 // may have changed earlier
6440 for (int i
= col
+ cell_cols
; i
< m_numCols
; i
++)
6443 GetCellSize( row
, i
, &c_rows
, &c_cols
);
6445 // looks weird going over a multicell
6446 if (m_table
->IsEmptyCell( row
, i
) &&
6447 (rect
.width
< maxWidth
) && (c_rows
== 1))
6449 rect
.width
+= GetColWidth( i
);
6455 if (rect
.GetRight() > client_right
)
6456 rect
.SetRight( client_right
- 1 );
6459 editor
->SetCellAttr( attr
);
6460 editor
->SetSize( rect
);
6462 editor
->GetControl()->Move(
6463 editor
->GetControl()->GetPosition().x
+ nXMove
,
6464 editor
->GetControl()->GetPosition().y
);
6465 editor
->Show( true, attr
);
6467 // recalc dimensions in case we need to
6468 // expand the scrolled window to account for editor
6471 editor
->BeginEdit(row
, col
, this);
6472 editor
->SetCellAttr(NULL
);
6480 void wxGrid::HideCellEditControl()
6482 if ( IsCellEditControlEnabled() )
6484 int row
= m_currentCellCoords
.GetRow();
6485 int col
= m_currentCellCoords
.GetCol();
6487 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
6488 wxGridCellEditor
*editor
= attr
->GetEditor(this, row
, col
);
6489 const bool editorHadFocus
= editor
->GetControl()->HasFocus();
6490 editor
->Show( false );
6494 // return the focus to the grid itself if the editor had it
6496 // note that we must not do this unconditionally to avoid stealing
6497 // focus from the window which just received it if we are hiding the
6498 // editor precisely because we lost focus
6499 if ( editorHadFocus
)
6500 m_gridWin
->SetFocus();
6502 // refresh whole row to the right
6503 wxRect
rect( CellToRect(row
, col
) );
6504 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
6505 rect
.width
= m_gridWin
->GetClientSize().GetWidth() - rect
.x
;
6508 // ensure that the pixels under the focus ring get refreshed as well
6509 rect
.Inflate(10, 10);
6512 m_gridWin
->Refresh( false, &rect
);
6516 void wxGrid::SaveEditControlValue()
6518 if ( IsCellEditControlEnabled() )
6520 int row
= m_currentCellCoords
.GetRow();
6521 int col
= m_currentCellCoords
.GetCol();
6523 wxString oldval
= GetCellValue(row
, col
);
6525 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
6526 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
6529 bool changed
= editor
->EndEdit(row
, col
, this, oldval
, &newval
);
6531 if ( changed
&& SendEvent(wxEVT_GRID_CELL_CHANGING
, newval
) != -1 )
6533 editor
->ApplyEdit(row
, col
, this);
6535 // for compatibility reasons dating back to wx 2.8 when this event
6536 // was called wxEVT_GRID_CELL_CHANGE and wxEVT_GRID_CELL_CHANGING
6537 // didn't exist we allow vetoing this one too
6538 if ( SendEvent(wxEVT_GRID_CELL_CHANGED
, oldval
) == -1 )
6540 // Event has been vetoed, set the data back.
6541 SetCellValue(row
, col
, oldval
);
6551 // ------ Grid location functions
6552 // Note that all of these functions work with the logical coordinates of
6553 // grid cells and labels so you will need to convert from device
6554 // coordinates for mouse events etc.
6557 wxGridCellCoords
wxGrid::XYToCell(int x
, int y
) const
6559 int row
= YToRow(y
);
6560 int col
= XToCol(x
);
6562 return row
== -1 || col
== -1 ? wxGridNoCellCoords
6563 : wxGridCellCoords(row
, col
);
6566 // compute row or column from some (unscrolled) coordinate value, using either
6567 // m_defaultRowHeight/m_defaultColWidth or binary search on array of
6568 // m_rowBottoms/m_colRights to do it quickly in O(log n) time.
6569 // NOTE: This may not work correctly for reordered columns.
6570 int wxGrid::PosToLinePos(int coord
,
6572 const wxGridOperations
& oper
) const
6574 const int numLines
= oper
.GetNumberOfLines(this);
6577 return clipToMinMax
&& numLines
> 0 ? 0 : wxNOT_FOUND
;
6579 const int defaultLineSize
= oper
.GetDefaultLineSize(this);
6580 wxCHECK_MSG( defaultLineSize
, -1, "can't have 0 default line size" );
6582 int maxPos
= coord
/ defaultLineSize
,
6585 // check for the simplest case: if we have no explicit line sizes
6586 // configured, then we already know the line this position falls in
6587 const wxArrayInt
& lineEnds
= oper
.GetLineEnds(this);
6588 if ( lineEnds
.empty() )
6590 if ( maxPos
< numLines
)
6593 return clipToMinMax
? numLines
- 1 : -1;
6597 // binary search is quite efficient and we can't really make any assumptions
6598 // on where to start here since row and columns could be of size 0 if they are
6599 // hidden. While this could be made more efficient, some profiling will be
6600 // necessary to determine if it really is a performance bottleneck
6601 maxPos
= numLines
- 1;
6603 // check if the position is beyond the last column
6604 const int lineAtMaxPos
= oper
.GetLineAt(this, maxPos
);
6605 if ( coord
>= lineEnds
[lineAtMaxPos
] )
6606 return clipToMinMax
? maxPos
: -1;
6608 // or before the first one
6609 const int lineAt0
= oper
.GetLineAt(this, 0);
6610 if ( coord
< lineEnds
[lineAt0
] )
6614 // finally do perform the binary search
6615 while ( minPos
< maxPos
)
6617 wxCHECK_MSG( lineEnds
[oper
.GetLineAt(this, minPos
)] <= coord
&&
6618 coord
< lineEnds
[oper
.GetLineAt(this, maxPos
)],
6620 "wxGrid: internal error in PosToLinePos()" );
6622 if ( coord
>= lineEnds
[oper
.GetLineAt(this, maxPos
- 1)] )
6627 const int median
= minPos
+ (maxPos
- minPos
+ 1) / 2;
6628 if ( coord
< lineEnds
[oper
.GetLineAt(this, median
)] )
6638 wxGrid::PosToLine(int coord
,
6640 const wxGridOperations
& oper
) const
6642 int pos
= PosToLinePos(coord
, clipToMinMax
, oper
);
6644 return pos
== wxNOT_FOUND
? wxNOT_FOUND
: oper
.GetLineAt(this, pos
);
6647 int wxGrid::YToRow(int y
, bool clipToMinMax
) const
6649 return PosToLine(y
, clipToMinMax
, wxGridRowOperations());
6652 int wxGrid::XToCol(int x
, bool clipToMinMax
) const
6654 return PosToLine(x
, clipToMinMax
, wxGridColumnOperations());
6657 int wxGrid::XToPos(int x
) const
6659 return PosToLinePos(x
, true /* clip */, wxGridColumnOperations());
6662 // return the row number such that the y coord is near the edge of, or -1 if
6663 // not near an edge.
6665 // notice that position can only possibly be near an edge if the row/column is
6666 // large enough to still allow for an "inner" area that is _not_ near the edge
6667 // (i.e., if the height/width is smaller than WXGRID_LABEL_EDGE_ZONE, pos will
6668 // _never_ be considered to be near the edge).
6669 int wxGrid::PosToEdgeOfLine(int pos
, const wxGridOperations
& oper
) const
6671 const int line
= oper
.PosToLine(this, pos
, true);
6673 if ( oper
.GetLineSize(this, line
) > WXGRID_LABEL_EDGE_ZONE
)
6675 // We know that we are in this line, test whether we are close enough
6676 // to start or end border, respectively.
6677 if ( abs(oper
.GetLineEndPos(this, line
) - pos
) < WXGRID_LABEL_EDGE_ZONE
)
6679 else if ( line
> 0 &&
6680 pos
- oper
.GetLineStartPos(this,
6681 line
) < WXGRID_LABEL_EDGE_ZONE
)
6683 return oper
.GetLineBefore(this, line
);
6690 int wxGrid::YToEdgeOfRow(int y
) const
6692 return PosToEdgeOfLine(y
, wxGridRowOperations());
6695 int wxGrid::XToEdgeOfCol(int x
) const
6697 return PosToEdgeOfLine(x
, wxGridColumnOperations());
6700 wxRect
wxGrid::CellToRect( int row
, int col
) const
6702 wxRect
rect( -1, -1, -1, -1 );
6704 if ( row
>= 0 && row
< m_numRows
&&
6705 col
>= 0 && col
< m_numCols
)
6707 int i
, cell_rows
, cell_cols
;
6708 rect
.width
= rect
.height
= 0;
6709 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
6710 // if negative then find multicell owner
6715 GetCellSize( row
, col
, &cell_rows
, &cell_cols
);
6717 rect
.x
= GetColLeft(col
);
6718 rect
.y
= GetRowTop(row
);
6719 for (i
=col
; i
< col
+ cell_cols
; i
++)
6720 rect
.width
+= GetColWidth(i
);
6721 for (i
=row
; i
< row
+ cell_rows
; i
++)
6722 rect
.height
+= GetRowHeight(i
);
6724 // if grid lines are enabled, then the area of the cell is a bit smaller
6725 if (m_gridLinesEnabled
)
6735 bool wxGrid::IsVisible( int row
, int col
, bool wholeCellVisible
) const
6737 // get the cell rectangle in logical coords
6739 wxRect
r( CellToRect( row
, col
) );
6741 // convert to device coords
6743 int left
, top
, right
, bottom
;
6744 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
6745 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
6747 // check against the client area of the grid window
6749 m_gridWin
->GetClientSize( &cw
, &ch
);
6751 if ( wholeCellVisible
)
6753 // is the cell wholly visible ?
6754 return ( left
>= 0 && right
<= cw
&&
6755 top
>= 0 && bottom
<= ch
);
6759 // is the cell partly visible ?
6761 return ( ((left
>= 0 && left
< cw
) || (right
> 0 && right
<= cw
)) &&
6762 ((top
>= 0 && top
< ch
) || (bottom
> 0 && bottom
<= ch
)) );
6766 // make the specified cell location visible by doing a minimal amount
6769 void wxGrid::MakeCellVisible( int row
, int col
)
6772 int xpos
= -1, ypos
= -1;
6774 if ( row
>= 0 && row
< m_numRows
&&
6775 col
>= 0 && col
< m_numCols
)
6777 // get the cell rectangle in logical coords
6778 wxRect
r( CellToRect( row
, col
) );
6780 // convert to device coords
6781 int left
, top
, right
, bottom
;
6782 CalcScrolledPosition( r
.GetLeft(), r
.GetTop(), &left
, &top
);
6783 CalcScrolledPosition( r
.GetRight(), r
.GetBottom(), &right
, &bottom
);
6786 m_gridWin
->GetClientSize( &cw
, &ch
);
6792 else if ( bottom
> ch
)
6794 int h
= r
.GetHeight();
6796 for ( i
= row
- 1; i
>= 0; i
-- )
6798 int rowHeight
= GetRowHeight(i
);
6799 if ( h
+ rowHeight
> ch
)
6806 // we divide it later by GRID_SCROLL_LINE, make sure that we don't
6807 // have rounding errors (this is important, because if we do,
6808 // we might not scroll at all and some cells won't be redrawn)
6810 // Sometimes GRID_SCROLL_LINE / 2 is not enough,
6811 // so just add a full scroll unit...
6812 ypos
+= m_yScrollPixelsPerLine
;
6815 // special handling for wide cells - show always left part of the cell!
6816 // Otherwise, e.g. when stepping from row to row, it would jump between
6817 // left and right part of the cell on every step!
6819 if ( left
< 0 || (right
- left
) >= cw
)
6823 else if ( right
> cw
)
6825 // position the view so that the cell is on the right
6827 CalcUnscrolledPosition(0, 0, &x0
, &y0
);
6828 xpos
= x0
+ (right
- cw
);
6830 // see comment for ypos above
6831 xpos
+= m_xScrollPixelsPerLine
;
6834 if ( xpos
!= -1 || ypos
!= -1 )
6837 xpos
/= m_xScrollPixelsPerLine
;
6839 ypos
/= m_yScrollPixelsPerLine
;
6840 Scroll( xpos
, ypos
);
6847 // ------ Grid cursor movement functions
6851 wxGrid::DoMoveCursor(bool expandSelection
,
6852 const wxGridDirectionOperations
& diroper
)
6854 if ( m_currentCellCoords
== wxGridNoCellCoords
)
6857 if ( expandSelection
)
6859 wxGridCellCoords coords
= m_selectedBlockCorner
;
6860 if ( coords
== wxGridNoCellCoords
)
6861 coords
= m_currentCellCoords
;
6863 if ( diroper
.IsAtBoundary(coords
) )
6866 diroper
.Advance(coords
);
6868 UpdateBlockBeingSelected(m_currentCellCoords
, coords
);
6870 else // don't expand selection
6874 if ( diroper
.IsAtBoundary(m_currentCellCoords
) )
6877 wxGridCellCoords coords
= m_currentCellCoords
;
6878 diroper
.Advance(coords
);
6886 bool wxGrid::MoveCursorUp(bool expandSelection
)
6888 return DoMoveCursor(expandSelection
,
6889 wxGridBackwardOperations(this, wxGridRowOperations()));
6892 bool wxGrid::MoveCursorDown(bool expandSelection
)
6894 return DoMoveCursor(expandSelection
,
6895 wxGridForwardOperations(this, wxGridRowOperations()));
6898 bool wxGrid::MoveCursorLeft(bool expandSelection
)
6900 return DoMoveCursor(expandSelection
,
6901 wxGridBackwardOperations(this, wxGridColumnOperations()));
6904 bool wxGrid::MoveCursorRight(bool expandSelection
)
6906 return DoMoveCursor(expandSelection
,
6907 wxGridForwardOperations(this, wxGridColumnOperations()));
6910 bool wxGrid::DoMoveCursorByPage(const wxGridDirectionOperations
& diroper
)
6912 if ( m_currentCellCoords
== wxGridNoCellCoords
)
6915 if ( diroper
.IsAtBoundary(m_currentCellCoords
) )
6918 const int oldRow
= m_currentCellCoords
.GetRow();
6919 int newRow
= diroper
.MoveByPixelDistance(oldRow
, m_gridWin
->GetClientSize().y
);
6920 if ( newRow
== oldRow
)
6922 wxGridCellCoords
coords(m_currentCellCoords
);
6923 diroper
.Advance(coords
);
6924 newRow
= coords
.GetRow();
6927 GoToCell(newRow
, m_currentCellCoords
.GetCol());
6932 bool wxGrid::MovePageUp()
6934 return DoMoveCursorByPage(
6935 wxGridBackwardOperations(this, wxGridRowOperations()));
6938 bool wxGrid::MovePageDown()
6940 return DoMoveCursorByPage(
6941 wxGridForwardOperations(this, wxGridRowOperations()));
6944 // helper of DoMoveCursorByBlock(): advance the cell coordinates using diroper
6945 // until we find a non-empty cell or reach the grid end
6947 wxGrid::AdvanceToNextNonEmpty(wxGridCellCoords
& coords
,
6948 const wxGridDirectionOperations
& diroper
)
6950 while ( !diroper
.IsAtBoundary(coords
) )
6952 diroper
.Advance(coords
);
6953 if ( !m_table
->IsEmpty(coords
) )
6959 wxGrid::DoMoveCursorByBlock(bool expandSelection
,
6960 const wxGridDirectionOperations
& diroper
)
6962 if ( !m_table
|| m_currentCellCoords
== wxGridNoCellCoords
)
6965 if ( diroper
.IsAtBoundary(m_currentCellCoords
) )
6968 wxGridCellCoords
coords(m_currentCellCoords
);
6969 if ( m_table
->IsEmpty(coords
) )
6971 // we are in an empty cell: find the next block of non-empty cells
6972 AdvanceToNextNonEmpty(coords
, diroper
);
6974 else // current cell is not empty
6976 diroper
.Advance(coords
);
6977 if ( m_table
->IsEmpty(coords
) )
6979 // we started at the end of a block, find the next one
6980 AdvanceToNextNonEmpty(coords
, diroper
);
6982 else // we're in a middle of a block
6984 // go to the end of it, i.e. find the last cell before the next
6986 while ( !diroper
.IsAtBoundary(coords
) )
6988 wxGridCellCoords
coordsNext(coords
);
6989 diroper
.Advance(coordsNext
);
6990 if ( m_table
->IsEmpty(coordsNext
) )
6993 coords
= coordsNext
;
6998 if ( expandSelection
)
7000 UpdateBlockBeingSelected(m_currentCellCoords
, coords
);
7011 bool wxGrid::MoveCursorUpBlock(bool expandSelection
)
7013 return DoMoveCursorByBlock(
7015 wxGridBackwardOperations(this, wxGridRowOperations())
7019 bool wxGrid::MoveCursorDownBlock( bool expandSelection
)
7021 return DoMoveCursorByBlock(
7023 wxGridForwardOperations(this, wxGridRowOperations())
7027 bool wxGrid::MoveCursorLeftBlock( bool expandSelection
)
7029 return DoMoveCursorByBlock(
7031 wxGridBackwardOperations(this, wxGridColumnOperations())
7035 bool wxGrid::MoveCursorRightBlock( bool expandSelection
)
7037 return DoMoveCursorByBlock(
7039 wxGridForwardOperations(this, wxGridColumnOperations())
7044 // ------ Label values and formatting
7047 void wxGrid::GetRowLabelAlignment( int *horiz
, int *vert
) const
7050 *horiz
= m_rowLabelHorizAlign
;
7052 *vert
= m_rowLabelVertAlign
;
7055 void wxGrid::GetColLabelAlignment( int *horiz
, int *vert
) const
7058 *horiz
= m_colLabelHorizAlign
;
7060 *vert
= m_colLabelVertAlign
;
7063 int wxGrid::GetColLabelTextOrientation() const
7065 return m_colLabelTextOrientation
;
7068 wxString
wxGrid::GetRowLabelValue( int row
) const
7072 return m_table
->GetRowLabelValue( row
);
7082 wxString
wxGrid::GetColLabelValue( int col
) const
7086 return m_table
->GetColLabelValue( col
);
7096 void wxGrid::SetRowLabelSize( int width
)
7098 wxASSERT( width
>= 0 || width
== wxGRID_AUTOSIZE
);
7100 if ( width
== wxGRID_AUTOSIZE
)
7102 width
= CalcColOrRowLabelAreaMinSize(wxGRID_ROW
);
7105 if ( width
!= m_rowLabelWidth
)
7109 m_rowLabelWin
->Show( false );
7110 m_cornerLabelWin
->Show( false );
7112 else if ( m_rowLabelWidth
== 0 )
7114 m_rowLabelWin
->Show( true );
7115 if ( m_colLabelHeight
> 0 )
7116 m_cornerLabelWin
->Show( true );
7119 m_rowLabelWidth
= width
;
7121 wxScrolledWindow::Refresh( true );
7125 void wxGrid::SetColLabelSize( int height
)
7127 wxASSERT( height
>=0 || height
== wxGRID_AUTOSIZE
);
7129 if ( height
== wxGRID_AUTOSIZE
)
7131 height
= CalcColOrRowLabelAreaMinSize(wxGRID_COLUMN
);
7134 if ( height
!= m_colLabelHeight
)
7138 m_colWindow
->Show( false );
7139 m_cornerLabelWin
->Show( false );
7141 else if ( m_colLabelHeight
== 0 )
7143 m_colWindow
->Show( true );
7144 if ( m_rowLabelWidth
> 0 )
7145 m_cornerLabelWin
->Show( true );
7148 m_colLabelHeight
= height
;
7150 wxScrolledWindow::Refresh( true );
7154 void wxGrid::SetLabelBackgroundColour( const wxColour
& colour
)
7156 if ( m_labelBackgroundColour
!= colour
)
7158 m_labelBackgroundColour
= colour
;
7159 m_rowLabelWin
->SetBackgroundColour( colour
);
7160 m_colWindow
->SetBackgroundColour( colour
);
7161 m_cornerLabelWin
->SetBackgroundColour( colour
);
7163 if ( !GetBatchCount() )
7165 m_rowLabelWin
->Refresh();
7166 m_colWindow
->Refresh();
7167 m_cornerLabelWin
->Refresh();
7172 void wxGrid::SetLabelTextColour( const wxColour
& colour
)
7174 if ( m_labelTextColour
!= colour
)
7176 m_labelTextColour
= colour
;
7177 if ( !GetBatchCount() )
7179 m_rowLabelWin
->Refresh();
7180 m_colWindow
->Refresh();
7185 void wxGrid::SetLabelFont( const wxFont
& font
)
7188 if ( !GetBatchCount() )
7190 m_rowLabelWin
->Refresh();
7191 m_colWindow
->Refresh();
7195 void wxGrid::SetRowLabelAlignment( int horiz
, int vert
)
7197 // allow old (incorrect) defs to be used
7200 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
7201 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
7202 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
7207 case wxTOP
: vert
= wxALIGN_TOP
; break;
7208 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
7209 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
7212 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
7214 m_rowLabelHorizAlign
= horiz
;
7217 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
7219 m_rowLabelVertAlign
= vert
;
7222 if ( !GetBatchCount() )
7224 m_rowLabelWin
->Refresh();
7228 void wxGrid::SetColLabelAlignment( int horiz
, int vert
)
7230 // allow old (incorrect) defs to be used
7233 case wxLEFT
: horiz
= wxALIGN_LEFT
; break;
7234 case wxRIGHT
: horiz
= wxALIGN_RIGHT
; break;
7235 case wxCENTRE
: horiz
= wxALIGN_CENTRE
; break;
7240 case wxTOP
: vert
= wxALIGN_TOP
; break;
7241 case wxBOTTOM
: vert
= wxALIGN_BOTTOM
; break;
7242 case wxCENTRE
: vert
= wxALIGN_CENTRE
; break;
7245 if ( horiz
== wxALIGN_LEFT
|| horiz
== wxALIGN_CENTRE
|| horiz
== wxALIGN_RIGHT
)
7247 m_colLabelHorizAlign
= horiz
;
7250 if ( vert
== wxALIGN_TOP
|| vert
== wxALIGN_CENTRE
|| vert
== wxALIGN_BOTTOM
)
7252 m_colLabelVertAlign
= vert
;
7255 if ( !GetBatchCount() )
7257 m_colWindow
->Refresh();
7261 // Note: under MSW, the default column label font must be changed because it
7262 // does not support vertical printing
7264 // Example: wxFont font(9, wxSWISS, wxNORMAL, wxBOLD);
7265 // pGrid->SetLabelFont(font);
7266 // pGrid->SetColLabelTextOrientation(wxVERTICAL);
7268 void wxGrid::SetColLabelTextOrientation( int textOrientation
)
7270 if ( textOrientation
== wxHORIZONTAL
|| textOrientation
== wxVERTICAL
)
7271 m_colLabelTextOrientation
= textOrientation
;
7273 if ( !GetBatchCount() )
7274 m_colWindow
->Refresh();
7277 void wxGrid::SetRowLabelValue( int row
, const wxString
& s
)
7281 m_table
->SetRowLabelValue( row
, s
);
7282 if ( !GetBatchCount() )
7284 wxRect rect
= CellToRect( row
, 0 );
7285 if ( rect
.height
> 0 )
7287 CalcScrolledPosition(0, rect
.y
, &rect
.x
, &rect
.y
);
7289 rect
.width
= m_rowLabelWidth
;
7290 m_rowLabelWin
->Refresh( true, &rect
);
7296 void wxGrid::SetColLabelValue( int col
, const wxString
& s
)
7300 m_table
->SetColLabelValue( col
, s
);
7301 if ( !GetBatchCount() )
7303 if ( m_useNativeHeader
)
7305 GetGridColHeader()->UpdateColumn(col
);
7309 wxRect rect
= CellToRect( 0, col
);
7310 if ( rect
.width
> 0 )
7312 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &rect
.y
);
7314 rect
.height
= m_colLabelHeight
;
7315 GetColLabelWindow()->Refresh( true, &rect
);
7322 void wxGrid::SetGridLineColour( const wxColour
& colour
)
7324 if ( m_gridLineColour
!= colour
)
7326 m_gridLineColour
= colour
;
7328 if ( GridLinesEnabled() )
7333 void wxGrid::SetCellHighlightColour( const wxColour
& colour
)
7335 if ( m_cellHighlightColour
!= colour
)
7337 m_cellHighlightColour
= colour
;
7339 wxClientDC
dc( m_gridWin
);
7341 wxGridCellAttr
* attr
= GetCellAttr(m_currentCellCoords
);
7342 DrawCellHighlight(dc
, attr
);
7347 void wxGrid::SetCellHighlightPenWidth(int width
)
7349 if (m_cellHighlightPenWidth
!= width
)
7351 m_cellHighlightPenWidth
= width
;
7353 // Just redrawing the cell highlight is not enough since that won't
7354 // make any visible change if the thickness is getting smaller.
7355 int row
= m_currentCellCoords
.GetRow();
7356 int col
= m_currentCellCoords
.GetCol();
7357 if ( row
== -1 || col
== -1 || GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7360 wxRect rect
= CellToRect(row
, col
);
7361 m_gridWin
->Refresh(true, &rect
);
7365 void wxGrid::SetCellHighlightROPenWidth(int width
)
7367 if (m_cellHighlightROPenWidth
!= width
)
7369 m_cellHighlightROPenWidth
= width
;
7371 // Just redrawing the cell highlight is not enough since that won't
7372 // make any visible change if the thickness is getting smaller.
7373 int row
= m_currentCellCoords
.GetRow();
7374 int col
= m_currentCellCoords
.GetCol();
7375 if ( row
== -1 || col
== -1 ||
7376 GetColWidth(col
) <= 0 || GetRowHeight(row
) <= 0 )
7379 wxRect rect
= CellToRect(row
, col
);
7380 m_gridWin
->Refresh(true, &rect
);
7384 void wxGrid::RedrawGridLines()
7386 // the lines will be redrawn when the window is thawn
7387 if ( GetBatchCount() )
7390 if ( GridLinesEnabled() )
7392 wxClientDC
dc( m_gridWin
);
7394 DrawAllGridLines( dc
, wxRegion() );
7396 else // remove the grid lines
7398 m_gridWin
->Refresh();
7402 void wxGrid::EnableGridLines( bool enable
)
7404 if ( enable
!= m_gridLinesEnabled
)
7406 m_gridLinesEnabled
= enable
;
7412 void wxGrid::DoClipGridLines(bool& var
, bool clip
)
7418 if ( GridLinesEnabled() )
7423 int wxGrid::GetDefaultRowSize() const
7425 return m_defaultRowHeight
;
7428 int wxGrid::GetRowSize( int row
) const
7430 wxCHECK_MSG( row
>= 0 && row
< m_numRows
, 0, wxT("invalid row index") );
7432 return GetRowHeight(row
);
7435 int wxGrid::GetDefaultColSize() const
7437 return m_defaultColWidth
;
7440 int wxGrid::GetColSize( int col
) const
7442 wxCHECK_MSG( col
>= 0 && col
< m_numCols
, 0, wxT("invalid column index") );
7444 return GetColWidth(col
);
7447 // ============================================================================
7448 // access to the grid attributes: each of them has a default value in the grid
7449 // itself and may be overidden on a per-cell basis
7450 // ============================================================================
7452 // ----------------------------------------------------------------------------
7453 // setting default attributes
7454 // ----------------------------------------------------------------------------
7456 void wxGrid::SetDefaultCellBackgroundColour( const wxColour
& col
)
7458 m_defaultCellAttr
->SetBackgroundColour(col
);
7460 m_gridWin
->SetBackgroundColour(col
);
7464 void wxGrid::SetDefaultCellTextColour( const wxColour
& col
)
7466 m_defaultCellAttr
->SetTextColour(col
);
7469 void wxGrid::SetDefaultCellAlignment( int horiz
, int vert
)
7471 m_defaultCellAttr
->SetAlignment(horiz
, vert
);
7474 void wxGrid::SetDefaultCellOverflow( bool allow
)
7476 m_defaultCellAttr
->SetOverflow(allow
);
7479 void wxGrid::SetDefaultCellFont( const wxFont
& font
)
7481 m_defaultCellAttr
->SetFont(font
);
7484 // For editors and renderers the type registry takes precedence over the
7485 // default attr, so we need to register the new editor/renderer for the string
7486 // data type in order to make setting a default editor/renderer appear to
7489 void wxGrid::SetDefaultRenderer(wxGridCellRenderer
*renderer
)
7491 RegisterDataType(wxGRID_VALUE_STRING
,
7493 GetDefaultEditorForType(wxGRID_VALUE_STRING
));
7496 void wxGrid::SetDefaultEditor(wxGridCellEditor
*editor
)
7498 RegisterDataType(wxGRID_VALUE_STRING
,
7499 GetDefaultRendererForType(wxGRID_VALUE_STRING
),
7503 // ----------------------------------------------------------------------------
7504 // access to the default attributes
7505 // ----------------------------------------------------------------------------
7507 wxColour
wxGrid::GetDefaultCellBackgroundColour() const
7509 return m_defaultCellAttr
->GetBackgroundColour();
7512 wxColour
wxGrid::GetDefaultCellTextColour() const
7514 return m_defaultCellAttr
->GetTextColour();
7517 wxFont
wxGrid::GetDefaultCellFont() const
7519 return m_defaultCellAttr
->GetFont();
7522 void wxGrid::GetDefaultCellAlignment( int *horiz
, int *vert
) const
7524 m_defaultCellAttr
->GetAlignment(horiz
, vert
);
7527 bool wxGrid::GetDefaultCellOverflow() const
7529 return m_defaultCellAttr
->GetOverflow();
7532 wxGridCellRenderer
*wxGrid::GetDefaultRenderer() const
7534 return m_defaultCellAttr
->GetRenderer(NULL
, 0, 0);
7537 wxGridCellEditor
*wxGrid::GetDefaultEditor() const
7539 return m_defaultCellAttr
->GetEditor(NULL
, 0, 0);
7542 // ----------------------------------------------------------------------------
7543 // access to cell attributes
7544 // ----------------------------------------------------------------------------
7546 wxColour
wxGrid::GetCellBackgroundColour(int row
, int col
) const
7548 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7549 wxColour colour
= attr
->GetBackgroundColour();
7555 wxColour
wxGrid::GetCellTextColour( int row
, int col
) const
7557 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7558 wxColour colour
= attr
->GetTextColour();
7564 wxFont
wxGrid::GetCellFont( int row
, int col
) const
7566 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7567 wxFont font
= attr
->GetFont();
7573 void wxGrid::GetCellAlignment( int row
, int col
, int *horiz
, int *vert
) const
7575 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7576 attr
->GetAlignment(horiz
, vert
);
7580 bool wxGrid::GetCellOverflow( int row
, int col
) const
7582 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7583 bool allow
= attr
->GetOverflow();
7590 wxGrid::GetCellSize( int row
, int col
, int *num_rows
, int *num_cols
) const
7592 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
7593 attr
->GetSize( num_rows
, num_cols
);
7596 if ( *num_rows
== 1 && *num_cols
== 1 )
7597 return CellSpan_None
; // just a normal cell
7599 if ( *num_rows
< 0 || *num_cols
< 0 )
7600 return CellSpan_Inside
; // covered by a multi-span cell
7602 // this cell spans multiple cells to its right/bottom
7603 return CellSpan_Main
;
7606 wxGridCellRenderer
* wxGrid::GetCellRenderer(int row
, int col
) const
7608 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7609 wxGridCellRenderer
* renderer
= attr
->GetRenderer(this, row
, col
);
7615 wxGridCellEditor
* wxGrid::GetCellEditor(int row
, int col
) const
7617 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7618 wxGridCellEditor
* editor
= attr
->GetEditor(this, row
, col
);
7624 bool wxGrid::IsReadOnly(int row
, int col
) const
7626 wxGridCellAttr
* attr
= GetCellAttr(row
, col
);
7627 bool isReadOnly
= attr
->IsReadOnly();
7633 // ----------------------------------------------------------------------------
7634 // attribute support: cache, automatic provider creation, ...
7635 // ----------------------------------------------------------------------------
7637 bool wxGrid::CanHaveAttributes() const
7644 return m_table
->CanHaveAttributes();
7647 void wxGrid::ClearAttrCache()
7649 if ( m_attrCache
.row
!= -1 )
7651 wxGridCellAttr
*oldAttr
= m_attrCache
.attr
;
7652 m_attrCache
.attr
= NULL
;
7653 m_attrCache
.row
= -1;
7654 // wxSafeDecRec(...) might cause event processing that accesses
7655 // the cached attribute, if one exists (e.g. by deleting the
7656 // editor stored within the attribute). Therefore it is important
7657 // to invalidate the cache before calling wxSafeDecRef!
7658 wxSafeDecRef(oldAttr
);
7662 void wxGrid::RefreshAttr(int row
, int col
)
7664 if ( m_attrCache
.row
== row
&& m_attrCache
.col
== col
)
7669 void wxGrid::CacheAttr(int row
, int col
, wxGridCellAttr
*attr
) const
7673 wxGrid
* const self
= const_cast<wxGrid
*>(this);
7675 self
->ClearAttrCache();
7676 self
->m_attrCache
.row
= row
;
7677 self
->m_attrCache
.col
= col
;
7678 self
->m_attrCache
.attr
= attr
;
7683 bool wxGrid::LookupAttr(int row
, int col
, wxGridCellAttr
**attr
) const
7685 if ( row
== m_attrCache
.row
&& col
== m_attrCache
.col
)
7687 *attr
= m_attrCache
.attr
;
7688 wxSafeIncRef(m_attrCache
.attr
);
7690 #ifdef DEBUG_ATTR_CACHE
7691 gs_nAttrCacheHits
++;
7698 #ifdef DEBUG_ATTR_CACHE
7699 gs_nAttrCacheMisses
++;
7706 wxGridCellAttr
*wxGrid::GetCellAttr(int row
, int col
) const
7708 wxGridCellAttr
*attr
= NULL
;
7709 // Additional test to avoid looking at the cache e.g. for
7710 // wxNoCellCoords, as this will confuse memory management.
7713 if ( !LookupAttr(row
, col
, &attr
) )
7715 attr
= m_table
? m_table
->GetAttr(row
, col
, wxGridCellAttr::Any
)
7717 CacheAttr(row
, col
, attr
);
7723 attr
->SetDefAttr(m_defaultCellAttr
);
7727 attr
= m_defaultCellAttr
;
7734 wxGridCellAttr
*wxGrid::GetOrCreateCellAttr(int row
, int col
) const
7736 wxGridCellAttr
*attr
= NULL
;
7737 bool canHave
= ((wxGrid
*)this)->CanHaveAttributes();
7739 wxCHECK_MSG( canHave
, attr
, wxT("Cell attributes not allowed"));
7740 wxCHECK_MSG( m_table
, attr
, wxT("must have a table") );
7742 attr
= m_table
->GetAttr(row
, col
, wxGridCellAttr::Cell
);
7745 attr
= new wxGridCellAttr(m_defaultCellAttr
);
7747 // artificially inc the ref count to match DecRef() in caller
7749 m_table
->SetAttr(attr
, row
, col
);
7755 // ----------------------------------------------------------------------------
7756 // setting column attributes (wrappers around SetColAttr)
7757 // ----------------------------------------------------------------------------
7759 void wxGrid::SetColFormatBool(int col
)
7761 SetColFormatCustom(col
, wxGRID_VALUE_BOOL
);
7764 void wxGrid::SetColFormatNumber(int col
)
7766 SetColFormatCustom(col
, wxGRID_VALUE_NUMBER
);
7769 void wxGrid::SetColFormatFloat(int col
, int width
, int precision
)
7771 wxString typeName
= wxGRID_VALUE_FLOAT
;
7772 if ( (width
!= -1) || (precision
!= -1) )
7774 typeName
<< wxT(':') << width
<< wxT(',') << precision
;
7777 SetColFormatCustom(col
, typeName
);
7780 void wxGrid::SetColFormatCustom(int col
, const wxString
& typeName
)
7782 wxGridCellAttr
*attr
= m_table
->GetAttr(-1, col
, wxGridCellAttr::Col
);
7784 attr
= new wxGridCellAttr
;
7785 wxGridCellRenderer
*renderer
= GetDefaultRendererForType(typeName
);
7786 attr
->SetRenderer(renderer
);
7787 wxGridCellEditor
*editor
= GetDefaultEditorForType(typeName
);
7788 attr
->SetEditor(editor
);
7790 SetColAttr(col
, attr
);
7794 // ----------------------------------------------------------------------------
7795 // setting cell attributes: this is forwarded to the table
7796 // ----------------------------------------------------------------------------
7798 void wxGrid::SetAttr(int row
, int col
, wxGridCellAttr
*attr
)
7800 if ( CanHaveAttributes() )
7802 m_table
->SetAttr(attr
, row
, col
);
7811 void wxGrid::SetRowAttr(int row
, wxGridCellAttr
*attr
)
7813 if ( CanHaveAttributes() )
7815 m_table
->SetRowAttr(attr
, row
);
7824 void wxGrid::SetColAttr(int col
, wxGridCellAttr
*attr
)
7826 if ( CanHaveAttributes() )
7828 m_table
->SetColAttr(attr
, col
);
7837 void wxGrid::SetCellBackgroundColour( int row
, int col
, const wxColour
& colour
)
7839 if ( CanHaveAttributes() )
7841 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7842 attr
->SetBackgroundColour(colour
);
7847 void wxGrid::SetCellTextColour( int row
, int col
, const wxColour
& colour
)
7849 if ( CanHaveAttributes() )
7851 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7852 attr
->SetTextColour(colour
);
7857 void wxGrid::SetCellFont( int row
, int col
, const wxFont
& font
)
7859 if ( CanHaveAttributes() )
7861 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7862 attr
->SetFont(font
);
7867 void wxGrid::SetCellAlignment( int row
, int col
, int horiz
, int vert
)
7869 if ( CanHaveAttributes() )
7871 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7872 attr
->SetAlignment(horiz
, vert
);
7877 void wxGrid::SetCellOverflow( int row
, int col
, bool allow
)
7879 if ( CanHaveAttributes() )
7881 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7882 attr
->SetOverflow(allow
);
7887 void wxGrid::SetCellSize( int row
, int col
, int num_rows
, int num_cols
)
7889 if ( CanHaveAttributes() )
7891 int cell_rows
, cell_cols
;
7893 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7894 attr
->GetSize(&cell_rows
, &cell_cols
);
7895 attr
->SetSize(num_rows
, num_cols
);
7898 // Cannot set the size of a cell to 0 or negative values
7899 // While it is perfectly legal to do that, this function cannot
7900 // handle all the possibilies, do it by hand by getting the CellAttr.
7901 // You can only set the size of a cell to 1,1 or greater with this fn
7902 wxASSERT_MSG( !((cell_rows
< 1) || (cell_cols
< 1)),
7903 wxT("wxGrid::SetCellSize setting cell size that is already part of another cell"));
7904 wxASSERT_MSG( !((num_rows
< 1) || (num_cols
< 1)),
7905 wxT("wxGrid::SetCellSize setting cell size to < 1"));
7907 // if this was already a multicell then "turn off" the other cells first
7908 if ((cell_rows
> 1) || (cell_cols
> 1))
7911 for (j
=row
; j
< row
+ cell_rows
; j
++)
7913 for (i
=col
; i
< col
+ cell_cols
; i
++)
7915 if ((i
!= col
) || (j
!= row
))
7917 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
7918 attr_stub
->SetSize( 1, 1 );
7919 attr_stub
->DecRef();
7925 // mark the cells that will be covered by this cell to
7926 // negative or zero values to point back at this cell
7927 if (((num_rows
> 1) || (num_cols
> 1)) && (num_rows
>= 1) && (num_cols
>= 1))
7930 for (j
=row
; j
< row
+ num_rows
; j
++)
7932 for (i
=col
; i
< col
+ num_cols
; i
++)
7934 if ((i
!= col
) || (j
!= row
))
7936 wxGridCellAttr
*attr_stub
= GetOrCreateCellAttr(j
, i
);
7937 attr_stub
->SetSize( row
- j
, col
- i
);
7938 attr_stub
->DecRef();
7946 void wxGrid::SetCellRenderer(int row
, int col
, wxGridCellRenderer
*renderer
)
7948 if ( CanHaveAttributes() )
7950 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7951 attr
->SetRenderer(renderer
);
7956 void wxGrid::SetCellEditor(int row
, int col
, wxGridCellEditor
* editor
)
7958 if ( CanHaveAttributes() )
7960 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7961 attr
->SetEditor(editor
);
7966 void wxGrid::SetReadOnly(int row
, int col
, bool isReadOnly
)
7968 if ( CanHaveAttributes() )
7970 wxGridCellAttr
*attr
= GetOrCreateCellAttr(row
, col
);
7971 attr
->SetReadOnly(isReadOnly
);
7976 // ----------------------------------------------------------------------------
7977 // Data type registration
7978 // ----------------------------------------------------------------------------
7980 void wxGrid::RegisterDataType(const wxString
& typeName
,
7981 wxGridCellRenderer
* renderer
,
7982 wxGridCellEditor
* editor
)
7984 m_typeRegistry
->RegisterDataType(typeName
, renderer
, editor
);
7988 wxGridCellEditor
* wxGrid::GetDefaultEditorForCell(int row
, int col
) const
7990 wxString typeName
= m_table
->GetTypeName(row
, col
);
7991 return GetDefaultEditorForType(typeName
);
7994 wxGridCellRenderer
* wxGrid::GetDefaultRendererForCell(int row
, int col
) const
7996 wxString typeName
= m_table
->GetTypeName(row
, col
);
7997 return GetDefaultRendererForType(typeName
);
8000 wxGridCellEditor
* wxGrid::GetDefaultEditorForType(const wxString
& typeName
) const
8002 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
8003 if ( index
== wxNOT_FOUND
)
8005 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName
.c_str()));
8010 return m_typeRegistry
->GetEditor(index
);
8013 wxGridCellRenderer
* wxGrid::GetDefaultRendererForType(const wxString
& typeName
) const
8015 int index
= m_typeRegistry
->FindOrCloneDataType(typeName
);
8016 if ( index
== wxNOT_FOUND
)
8018 wxFAIL_MSG(wxString::Format(wxT("Unknown data type name [%s]"), typeName
.c_str()));
8023 return m_typeRegistry
->GetRenderer(index
);
8026 // ----------------------------------------------------------------------------
8028 // ----------------------------------------------------------------------------
8030 void wxGrid::DoDisableLineResize(int line
, wxGridFixedIndicesSet
*& setFixed
)
8034 setFixed
= new wxGridFixedIndicesSet
;
8037 setFixed
->insert(line
);
8041 wxGrid::DoCanResizeLine(int line
, const wxGridFixedIndicesSet
*setFixed
) const
8043 return !setFixed
|| !setFixed
->count(line
);
8046 void wxGrid::EnableDragRowSize( bool enable
)
8048 m_canDragRowSize
= enable
;
8051 void wxGrid::EnableDragColSize( bool enable
)
8053 m_canDragColSize
= enable
;
8056 void wxGrid::EnableDragGridSize( bool enable
)
8058 m_canDragGridSize
= enable
;
8061 void wxGrid::EnableDragCell( bool enable
)
8063 m_canDragCell
= enable
;
8066 void wxGrid::SetDefaultRowSize( int height
, bool resizeExistingRows
)
8068 m_defaultRowHeight
= wxMax( height
, m_minAcceptableRowHeight
);
8070 if ( resizeExistingRows
)
8072 // since we are resizing all rows to the default row size,
8073 // we can simply clear the row heights and row bottoms
8074 // arrays (which also allows us to take advantage of
8075 // some speed optimisations)
8076 m_rowHeights
.Empty();
8077 m_rowBottoms
.Empty();
8078 if ( !GetBatchCount() )
8086 // This is a common part of SetRowSize() and SetColSize() which takes care of
8087 // updating the height/width of a row/column depending on its current value and
8090 // Returns the difference between the new and the old size.
8091 int UpdateRowOrColSize(int& sizeCurrent
, int sizeNew
)
8093 // On input here sizeCurrent can be negative if it's currently hidden (the
8094 // real size is its absolute value then). And sizeNew can be 0 to indicate
8095 // that the row/column should be hidden or -1 to indicate that it should be
8100 // We're showing back a previously hidden row/column.
8101 wxASSERT_MSG( sizeNew
== -1, wxS("New size must be positive or -1.") );
8103 wxASSERT_MSG( sizeCurrent
< 0, wxS("May only show back if hidden.") );
8105 sizeCurrent
= -sizeCurrent
;
8107 // This is positive which is correct.
8110 else if ( sizeNew
== 0 )
8112 // We're hiding a row/column.
8113 wxASSERT_MSG( sizeCurrent
> 0, wxS("Can't hide if already hidden.") );
8115 sizeCurrent
= -sizeCurrent
;
8117 // This is negative which is correct.
8120 else // We're just changing the row/column size.
8122 // Here it could have been hidden or not previously.
8123 const int sizeOld
= sizeCurrent
< 0 ? 0 : sizeCurrent
;
8125 sizeCurrent
= sizeNew
;
8127 return sizeCurrent
- sizeOld
;
8131 } // anonymous namespace
8133 void wxGrid::SetRowSize( int row
, int height
)
8135 // See comment in SetColSize
8136 if ( height
> 0 && height
< GetRowMinimalAcceptableHeight())
8139 // The value of -1 is special and means to fit the height to the row label.
8142 // As with the columns, ignore attempts to auto-size the hidden rows.
8143 if ( GetRowHeight(row
) == 0 )
8147 wxArrayString lines
;
8148 wxClientDC
dc(m_rowLabelWin
);
8149 dc
.SetFont(GetLabelFont());
8150 StringToLines(GetRowLabelValue( row
), lines
);
8151 GetTextBoxSize( dc
, lines
, &w
, &h
);
8152 //check that it is not less than the minimal height
8153 height
= wxMax(h
, GetRowMinimalAcceptableHeight());
8156 DoSetRowSize(row
, height
);
8159 void wxGrid::DoSetRowSize( int row
, int height
)
8161 wxCHECK_RET( row
>= 0 && row
< m_numRows
, wxT("invalid row index") );
8163 if ( m_rowHeights
.IsEmpty() )
8165 // need to really create the array
8169 const int diff
= UpdateRowOrColSize(m_rowHeights
[row
], height
);
8173 for ( int i
= row
; i
< m_numRows
; i
++ )
8175 m_rowBottoms
[i
] += diff
;
8178 if ( !GetBatchCount() )
8185 void wxGrid::SetDefaultColSize( int width
, bool resizeExistingCols
)
8187 // we dont allow zero default column width
8188 m_defaultColWidth
= wxMax( wxMax( width
, m_minAcceptableColWidth
), 1 );
8190 if ( resizeExistingCols
)
8192 // since we are resizing all columns to the default column size,
8193 // we can simply clear the col widths and col rights
8194 // arrays (which also allows us to take advantage of
8195 // some speed optimisations)
8196 m_colWidths
.Empty();
8197 m_colRights
.Empty();
8198 if ( !GetBatchCount() )
8203 void wxGrid::SetColSize( int col
, int width
)
8205 // we intentionally don't test whether the width is less than
8206 // GetColMinimalWidth() here but we do compare it with
8207 // GetColMinimalAcceptableWidth() as otherwise things currently break (see
8208 // #651) -- and we also always allow the width of 0 as it has the special
8209 // sense of hiding the column
8210 if ( width
> 0 && width
< GetColMinimalAcceptableWidth() )
8213 // The value of -1 is special and means to fit the width to the column label.
8216 // We currently don't support auto-sizing hidden columns. We could, but
8217 // it's not clear whether this is really needed and it would make the
8218 // code more complex.
8219 if ( GetColWidth(col
) == 0 )
8223 wxArrayString lines
;
8224 wxClientDC
dc(m_colWindow
);
8225 dc
.SetFont(GetLabelFont());
8226 StringToLines(GetColLabelValue(col
), lines
);
8227 if ( GetColLabelTextOrientation() == wxHORIZONTAL
)
8228 GetTextBoxSize( dc
, lines
, &w
, &h
);
8230 GetTextBoxSize( dc
, lines
, &h
, &w
);
8232 //check that it is not less than the minimal width
8233 width
= wxMax(width
, GetColMinimalAcceptableWidth());
8236 DoSetColSize(col
, width
);
8239 void wxGrid::DoSetColSize( int col
, int width
)
8241 wxCHECK_RET( col
>= 0 && col
< m_numCols
, wxT("invalid column index") );
8243 if ( m_colWidths
.IsEmpty() )
8245 // need to really create the array
8249 const int diff
= UpdateRowOrColSize(m_colWidths
[col
], width
);
8253 if ( m_useNativeHeader
)
8254 GetGridColHeader()->UpdateColumn(col
);
8255 //else: will be refreshed when the header is redrawn
8257 for ( int colPos
= GetColPos(col
); colPos
< m_numCols
; colPos
++ )
8259 m_colRights
[GetColAt(colPos
)] += diff
;
8262 if ( !GetBatchCount() )
8269 void wxGrid::SetColMinimalWidth( int col
, int width
)
8271 if (width
> GetColMinimalAcceptableWidth())
8273 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)col
;
8274 m_colMinWidths
[key
] = width
;
8278 void wxGrid::SetRowMinimalHeight( int row
, int width
)
8280 if (width
> GetRowMinimalAcceptableHeight())
8282 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)row
;
8283 m_rowMinHeights
[key
] = width
;
8287 int wxGrid::GetColMinimalWidth(int col
) const
8289 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)col
;
8290 wxLongToLongHashMap::const_iterator it
= m_colMinWidths
.find(key
);
8292 return it
!= m_colMinWidths
.end() ? (int)it
->second
: m_minAcceptableColWidth
;
8295 int wxGrid::GetRowMinimalHeight(int row
) const
8297 wxLongToLongHashMap::key_type key
= (wxLongToLongHashMap::key_type
)row
;
8298 wxLongToLongHashMap::const_iterator it
= m_rowMinHeights
.find(key
);
8300 return it
!= m_rowMinHeights
.end() ? (int)it
->second
: m_minAcceptableRowHeight
;
8303 void wxGrid::SetColMinimalAcceptableWidth( int width
)
8305 // We do allow a width of 0 since this gives us
8306 // an easy way to temporarily hiding columns.
8308 m_minAcceptableColWidth
= width
;
8311 void wxGrid::SetRowMinimalAcceptableHeight( int height
)
8313 // We do allow a height of 0 since this gives us
8314 // an easy way to temporarily hiding rows.
8316 m_minAcceptableRowHeight
= height
;
8319 int wxGrid::GetColMinimalAcceptableWidth() const
8321 return m_minAcceptableColWidth
;
8324 int wxGrid::GetRowMinimalAcceptableHeight() const
8326 return m_minAcceptableRowHeight
;
8329 // ----------------------------------------------------------------------------
8331 // ----------------------------------------------------------------------------
8334 wxGrid::AutoSizeColOrRow(int colOrRow
, bool setAsMin
, wxGridDirection direction
)
8336 const bool column
= direction
== wxGRID_COLUMN
;
8338 // We don't support auto-sizing hidden rows or columns, this doesn't seem
8339 // to make much sense.
8342 if ( GetColWidth(colOrRow
) == 0 )
8347 if ( GetRowHeight(colOrRow
) == 0 )
8351 wxClientDC
dc(m_gridWin
);
8353 // cancel editing of cell
8354 HideCellEditControl();
8355 SaveEditControlValue();
8357 // initialize both of them just to avoid compiler warnings even if only
8358 // really needs to be initialized here
8372 wxCoord extent
, extentMax
= 0;
8373 int max
= column
? m_numRows
: m_numCols
;
8374 for ( int rowOrCol
= 0; rowOrCol
< max
; rowOrCol
++ )
8387 // we need to account for the cells spanning multiple columns/rows:
8388 // while they may need a lot of space, they don't need all of it in
8390 int numRows
, numCols
;
8391 const CellSpan span
= GetCellSize(row
, col
, &numRows
, &numCols
);
8392 if ( span
== CellSpan_Inside
)
8394 // we need to get the size of the main cell, not of a cell hidden
8399 // get the size of the main cell too
8400 GetCellSize(row
, col
, &numRows
, &numCols
);
8403 // get cell ( main cell if CellSpan_Inside ) renderer best size
8404 wxGridCellAttr
*attr
= GetCellAttr(row
, col
);
8405 wxGridCellRenderer
*renderer
= attr
->GetRenderer(this, row
, col
);
8408 wxSize size
= renderer
->GetBestSize(*this, *attr
, dc
, row
, col
);
8409 extent
= column
? size
.x
: size
.y
;
8411 if ( span
!= CellSpan_None
)
8413 // we spread the size of a spanning cell over all the cells it
8414 // covers evenly -- this is probably not ideal but we can't
8415 // really do much better here
8417 // notice that numCols and numRows are never 0 as they
8418 // correspond to the size of the main cell of the span and not
8419 // of the cell inside it
8420 extent
/= column
? numCols
: numRows
;
8423 if ( extent
> extentMax
)
8432 // now also compare with the column label extent
8434 dc
.SetFont( GetLabelFont() );
8438 dc
.GetMultiLineTextExtent( GetColLabelValue(colOrRow
), &w
, &h
);
8439 if ( GetColLabelTextOrientation() == wxVERTICAL
)
8443 dc
.GetMultiLineTextExtent( GetRowLabelValue(colOrRow
), &w
, &h
);
8445 extent
= column
? w
: h
;
8446 if ( extent
> extentMax
)
8451 // empty column - give default extent (notice that if extentMax is less
8452 // than default extent but != 0, it's OK)
8453 extentMax
= column
? m_defaultColWidth
: m_defaultRowHeight
;
8458 // leave some space around text
8466 // Ensure automatic width is not less than minimal width. See the
8467 // comment in SetColSize() for explanation of why this isn't done
8470 extentMax
= wxMax(extentMax
, GetColMinimalWidth(colOrRow
));
8472 SetColSize( colOrRow
, extentMax
);
8473 if ( !GetBatchCount() )
8475 if ( m_useNativeHeader
)
8477 GetGridColHeader()->UpdateColumn(colOrRow
);
8482 m_gridWin
->GetClientSize( &cw
, &ch
);
8483 wxRect
rect ( CellToRect( 0, colOrRow
) );
8485 CalcScrolledPosition(rect
.x
, 0, &rect
.x
, &dummy
);
8486 rect
.width
= cw
- rect
.x
;
8487 rect
.height
= m_colLabelHeight
;
8488 GetColLabelWindow()->Refresh( true, &rect
);
8494 // Ensure automatic width is not less than minimal height. See the
8495 // comment in SetColSize() for explanation of why this isn't done
8498 extentMax
= wxMax(extentMax
, GetRowMinimalHeight(colOrRow
));
8500 SetRowSize(colOrRow
, extentMax
);
8501 if ( !GetBatchCount() )
8504 m_gridWin
->GetClientSize( &cw
, &ch
);
8505 wxRect
rect( CellToRect( colOrRow
, 0 ) );
8507 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
8508 rect
.width
= m_rowLabelWidth
;
8509 rect
.height
= ch
- rect
.y
;
8510 m_rowLabelWin
->Refresh( true, &rect
);
8517 SetColMinimalWidth(colOrRow
, extentMax
);
8519 SetRowMinimalHeight(colOrRow
, extentMax
);
8523 wxCoord
wxGrid::CalcColOrRowLabelAreaMinSize(wxGridDirection direction
)
8525 // calculate size for the rows or columns?
8526 const bool calcRows
= direction
== wxGRID_ROW
;
8528 wxClientDC
dc(calcRows
? GetGridRowLabelWindow()
8529 : GetGridColLabelWindow());
8530 dc
.SetFont(GetLabelFont());
8532 // which dimension should we take into account for calculations?
8534 // for columns, the text can be only horizontal so it's easy but for rows
8535 // we also have to take into account the text orientation
8537 useWidth
= calcRows
|| (GetColLabelTextOrientation() == wxVERTICAL
);
8539 wxArrayString lines
;
8540 wxCoord extentMax
= 0;
8542 const int numRowsOrCols
= calcRows
? m_numRows
: m_numCols
;
8543 for ( int rowOrCol
= 0; rowOrCol
< numRowsOrCols
; rowOrCol
++ )
8547 wxString label
= calcRows
? GetRowLabelValue(rowOrCol
)
8548 : GetColLabelValue(rowOrCol
);
8549 StringToLines(label
, lines
);
8552 GetTextBoxSize(dc
, lines
, &w
, &h
);
8554 const wxCoord extent
= useWidth
? w
: h
;
8555 if ( extent
> extentMax
)
8561 // empty column - give default extent (notice that if extentMax is less
8562 // than default extent but != 0, it's OK)
8563 extentMax
= calcRows
? GetDefaultRowLabelSize()
8564 : GetDefaultColLabelSize();
8567 // leave some space around text (taken from AutoSizeColOrRow)
8576 int wxGrid::SetOrCalcColumnSizes(bool calcOnly
, bool setAsMin
)
8578 int width
= m_rowLabelWidth
;
8580 wxGridUpdateLocker locker
;
8582 locker
.Create(this);
8584 for ( int col
= 0; col
< m_numCols
; col
++ )
8587 AutoSizeColumn(col
, setAsMin
);
8589 width
+= GetColWidth(col
);
8595 int wxGrid::SetOrCalcRowSizes(bool calcOnly
, bool setAsMin
)
8597 int height
= m_colLabelHeight
;
8599 wxGridUpdateLocker locker
;
8601 locker
.Create(this);
8603 for ( int row
= 0; row
< m_numRows
; row
++ )
8606 AutoSizeRow(row
, setAsMin
);
8608 height
+= GetRowHeight(row
);
8614 void wxGrid::AutoSize()
8616 wxGridUpdateLocker
locker(this);
8618 wxSize
size(SetOrCalcColumnSizes(false) - m_rowLabelWidth
+ m_extraWidth
,
8619 SetOrCalcRowSizes(false) - m_colLabelHeight
+ m_extraHeight
);
8621 // we know that we're not going to have scrollbars so disable them now to
8622 // avoid trouble in SetClientSize() which can otherwise set the correct
8623 // client size but also leave space for (not needed any more) scrollbars
8624 SetScrollbars(m_xScrollPixelsPerLine
, m_yScrollPixelsPerLine
,
8627 SetClientSize(size
.x
+ m_rowLabelWidth
, size
.y
+ m_colLabelHeight
);
8630 void wxGrid::AutoSizeRowLabelSize( int row
)
8632 // Hide the edit control, so it
8633 // won't interfere with drag-shrinking.
8634 if ( IsCellEditControlShown() )
8636 HideCellEditControl();
8637 SaveEditControlValue();
8640 // autosize row height depending on label text
8641 SetRowSize(row
, -1);
8646 void wxGrid::AutoSizeColLabelSize( int col
)
8648 // Hide the edit control, so it
8649 // won't interfere with drag-shrinking.
8650 if ( IsCellEditControlShown() )
8652 HideCellEditControl();
8653 SaveEditControlValue();
8656 // autosize column width depending on label text
8657 SetColSize(col
, -1);
8662 wxSize
wxGrid::DoGetBestSize() const
8664 wxGrid
* const self
= const_cast<wxGrid
*>(this);
8666 // we do the same as in AutoSize() here with the exception that we don't
8667 // change the column/row sizes, only calculate them
8668 wxSize
size(self
->SetOrCalcColumnSizes(true) - m_rowLabelWidth
+ m_extraWidth
,
8669 self
->SetOrCalcRowSizes(true) - m_colLabelHeight
+ m_extraHeight
);
8671 // NOTE: This size should be cached, but first we need to add calls to
8672 // InvalidateBestSize everywhere that could change the results of this
8674 // CacheBestSize(size);
8676 return wxSize(size
.x
+ m_rowLabelWidth
, size
.y
+ m_colLabelHeight
)
8677 + GetWindowBorderSize();
8685 #if WXWIN_COMPATIBILITY_2_8
8686 wxPen
& wxGrid::GetDividerPen() const
8690 #endif // WXWIN_COMPATIBILITY_2_8
8692 // ----------------------------------------------------------------------------
8693 // cell value accessor functions
8694 // ----------------------------------------------------------------------------
8696 void wxGrid::SetCellValue( int row
, int col
, const wxString
& s
)
8700 m_table
->SetValue( row
, col
, s
);
8701 if ( !GetBatchCount() )
8704 wxRect
rect( CellToRect( row
, col
) );
8706 rect
.width
= m_gridWin
->GetClientSize().GetWidth();
8707 CalcScrolledPosition(0, rect
.y
, &dummy
, &rect
.y
);
8708 m_gridWin
->Refresh( false, &rect
);
8711 if ( m_currentCellCoords
.GetRow() == row
&&
8712 m_currentCellCoords
.GetCol() == col
&&
8713 IsCellEditControlShown())
8714 // Note: If we are using IsCellEditControlEnabled,
8715 // this interacts badly with calling SetCellValue from
8716 // an EVT_GRID_CELL_CHANGE handler.
8718 HideCellEditControl();
8719 ShowCellEditControl(); // will reread data from table
8724 // ----------------------------------------------------------------------------
8725 // block, row and column selection
8726 // ----------------------------------------------------------------------------
8728 void wxGrid::SelectRow( int row
, bool addToSelected
)
8733 if ( !addToSelected
)
8736 m_selection
->SelectRow(row
);
8739 void wxGrid::SelectCol( int col
, bool addToSelected
)
8744 if ( !addToSelected
)
8747 m_selection
->SelectCol(col
);
8750 void wxGrid::SelectBlock(int topRow
, int leftCol
, int bottomRow
, int rightCol
,
8756 if ( !addToSelected
)
8759 m_selection
->SelectBlock(topRow
, leftCol
, bottomRow
, rightCol
);
8762 void wxGrid::SelectAll()
8764 if ( m_numRows
> 0 && m_numCols
> 0 )
8767 m_selection
->SelectBlock( 0, 0, m_numRows
- 1, m_numCols
- 1 );
8771 // ----------------------------------------------------------------------------
8772 // cell, row and col deselection
8773 // ----------------------------------------------------------------------------
8775 void wxGrid::DeselectLine(int line
, const wxGridOperations
& oper
)
8780 const wxGridSelectionModes mode
= m_selection
->GetSelectionMode();
8781 if ( mode
== oper
.GetSelectionMode() ||
8782 mode
== wxGrid::wxGridSelectRowsOrColumns
)
8784 const wxGridCellCoords
c(oper
.MakeCoords(line
, 0));
8785 if ( m_selection
->IsInSelection(c
) )
8786 m_selection
->ToggleCellSelection(c
);
8788 else if ( mode
!= oper
.Dual().GetSelectionMode() )
8790 const int nOther
= oper
.Dual().GetNumberOfLines(this);
8791 for ( int i
= 0; i
< nOther
; i
++ )
8793 const wxGridCellCoords
c(oper
.MakeCoords(line
, i
));
8794 if ( m_selection
->IsInSelection(c
) )
8795 m_selection
->ToggleCellSelection(c
);
8798 //else: can only select orthogonal lines so no lines in this direction
8799 // could have been selected anyhow
8802 void wxGrid::DeselectRow(int row
)
8804 DeselectLine(row
, wxGridRowOperations());
8807 void wxGrid::DeselectCol(int col
)
8809 DeselectLine(col
, wxGridColumnOperations());
8812 void wxGrid::DeselectCell( int row
, int col
)
8814 if ( m_selection
&& m_selection
->IsInSelection(row
, col
) )
8815 m_selection
->ToggleCellSelection(row
, col
);
8818 bool wxGrid::IsSelection() const
8820 return ( m_selection
&& (m_selection
->IsSelection() ||
8821 ( m_selectedBlockTopLeft
!= wxGridNoCellCoords
&&
8822 m_selectedBlockBottomRight
!= wxGridNoCellCoords
) ) );
8825 bool wxGrid::IsInSelection( int row
, int col
) const
8827 return ( m_selection
&& (m_selection
->IsInSelection( row
, col
) ||
8828 ( row
>= m_selectedBlockTopLeft
.GetRow() &&
8829 col
>= m_selectedBlockTopLeft
.GetCol() &&
8830 row
<= m_selectedBlockBottomRight
.GetRow() &&
8831 col
<= m_selectedBlockBottomRight
.GetCol() )) );
8834 wxGridCellCoordsArray
wxGrid::GetSelectedCells() const
8838 wxGridCellCoordsArray a
;
8842 return m_selection
->m_cellSelection
;
8845 wxGridCellCoordsArray
wxGrid::GetSelectionBlockTopLeft() const
8849 wxGridCellCoordsArray a
;
8853 return m_selection
->m_blockSelectionTopLeft
;
8856 wxGridCellCoordsArray
wxGrid::GetSelectionBlockBottomRight() const
8860 wxGridCellCoordsArray a
;
8864 return m_selection
->m_blockSelectionBottomRight
;
8867 wxArrayInt
wxGrid::GetSelectedRows() const
8875 return m_selection
->m_rowSelection
;
8878 wxArrayInt
wxGrid::GetSelectedCols() const
8886 return m_selection
->m_colSelection
;
8889 void wxGrid::ClearSelection()
8891 wxRect r1
= BlockToDeviceRect(m_selectedBlockTopLeft
,
8892 m_selectedBlockBottomRight
);
8893 wxRect r2
= BlockToDeviceRect(m_currentCellCoords
,
8894 m_selectedBlockCorner
);
8896 m_selectedBlockTopLeft
=
8897 m_selectedBlockBottomRight
=
8898 m_selectedBlockCorner
= wxGridNoCellCoords
;
8900 if ( !r1
.IsEmpty() )
8901 RefreshRect(r1
, false);
8902 if ( !r2
.IsEmpty() )
8903 RefreshRect(r2
, false);
8906 m_selection
->ClearSelection();
8909 // This function returns the rectangle that encloses the given block
8910 // in device coords clipped to the client size of the grid window.
8912 wxRect
wxGrid::BlockToDeviceRect( const wxGridCellCoords
& topLeft
,
8913 const wxGridCellCoords
& bottomRight
) const
8916 wxRect tempCellRect
= CellToRect(topLeft
);
8917 if ( tempCellRect
!= wxGridNoCellRect
)
8919 resultRect
= tempCellRect
;
8923 resultRect
= wxRect(0, 0, 0, 0);
8926 tempCellRect
= CellToRect(bottomRight
);
8927 if ( tempCellRect
!= wxGridNoCellRect
)
8929 resultRect
+= tempCellRect
;
8933 // If both inputs were "wxGridNoCellRect," then there's nothing to do.
8934 return wxGridNoCellRect
;
8937 // Ensure that left/right and top/bottom pairs are in order.
8938 int left
= resultRect
.GetLeft();
8939 int top
= resultRect
.GetTop();
8940 int right
= resultRect
.GetRight();
8941 int bottom
= resultRect
.GetBottom();
8943 int leftCol
= topLeft
.GetCol();
8944 int topRow
= topLeft
.GetRow();
8945 int rightCol
= bottomRight
.GetCol();
8946 int bottomRow
= bottomRight
.GetRow();
8970 // The following loop is ONLY necessary to detect and handle merged cells.
8972 m_gridWin
->GetClientSize( &cw
, &ch
);
8974 // Get the origin coordinates: notice that they will be negative if the
8975 // grid is scrolled downwards/to the right.
8976 int gridOriginX
= 0;
8977 int gridOriginY
= 0;
8978 CalcScrolledPosition(gridOriginX
, gridOriginY
, &gridOriginX
, &gridOriginY
);
8980 int onScreenLeftmostCol
= internalXToCol(-gridOriginX
);
8981 int onScreenUppermostRow
= internalYToRow(-gridOriginY
);
8983 int onScreenRightmostCol
= internalXToCol(-gridOriginX
+ cw
);
8984 int onScreenBottommostRow
= internalYToRow(-gridOriginY
+ ch
);
8986 // Bound our loop so that we only examine the portion of the selected block
8987 // that is shown on screen. Therefore, we compare the Top-Left block values
8988 // to the Top-Left screen values, and the Bottom-Right block values to the
8989 // Bottom-Right screen values, choosing appropriately.
8990 const int visibleTopRow
= wxMax(topRow
, onScreenUppermostRow
);
8991 const int visibleBottomRow
= wxMin(bottomRow
, onScreenBottommostRow
);
8992 const int visibleLeftCol
= wxMax(leftCol
, onScreenLeftmostCol
);
8993 const int visibleRightCol
= wxMin(rightCol
, onScreenRightmostCol
);
8995 for ( int j
= visibleTopRow
; j
<= visibleBottomRow
; j
++ )
8997 for ( int i
= visibleLeftCol
; i
<= visibleRightCol
; i
++ )
8999 if ( (j
== visibleTopRow
) || (j
== visibleBottomRow
) ||
9000 (i
== visibleLeftCol
) || (i
== visibleRightCol
) )
9002 tempCellRect
= CellToRect( j
, i
);
9004 if (tempCellRect
.x
< left
)
9005 left
= tempCellRect
.x
;
9006 if (tempCellRect
.y
< top
)
9007 top
= tempCellRect
.y
;
9008 if (tempCellRect
.x
+ tempCellRect
.width
> right
)
9009 right
= tempCellRect
.x
+ tempCellRect
.width
;
9010 if (tempCellRect
.y
+ tempCellRect
.height
> bottom
)
9011 bottom
= tempCellRect
.y
+ tempCellRect
.height
;
9015 i
= visibleRightCol
; // jump over inner cells.
9020 // Convert to scrolled coords
9021 CalcScrolledPosition( left
, top
, &left
, &top
);
9022 CalcScrolledPosition( right
, bottom
, &right
, &bottom
);
9024 if (right
< 0 || bottom
< 0 || left
> cw
|| top
> ch
)
9025 return wxRect(0,0,0,0);
9027 resultRect
.SetLeft( wxMax(0, left
) );
9028 resultRect
.SetTop( wxMax(0, top
) );
9029 resultRect
.SetRight( wxMin(cw
, right
) );
9030 resultRect
.SetBottom( wxMin(ch
, bottom
) );
9035 void wxGrid::DoSetSizes(const wxGridSizesInfo
& sizeInfo
,
9036 const wxGridOperations
& oper
)
9039 oper
.SetDefaultLineSize(this, sizeInfo
.m_sizeDefault
, true);
9040 const int numLines
= oper
.GetNumberOfLines(this);
9041 for ( int i
= 0; i
< numLines
; i
++ )
9043 int size
= sizeInfo
.GetSize(i
);
9044 if ( size
!= sizeInfo
.m_sizeDefault
)
9045 oper
.SetLineSize(this, i
, size
);
9050 void wxGrid::SetColSizes(const wxGridSizesInfo
& sizeInfo
)
9052 DoSetSizes(sizeInfo
, wxGridColumnOperations());
9055 void wxGrid::SetRowSizes(const wxGridSizesInfo
& sizeInfo
)
9057 DoSetSizes(sizeInfo
, wxGridRowOperations());
9060 wxGridSizesInfo::wxGridSizesInfo(int defSize
, const wxArrayInt
& allSizes
)
9062 m_sizeDefault
= defSize
;
9063 for ( size_t i
= 0; i
< allSizes
.size(); i
++ )
9065 if ( allSizes
[i
] != defSize
)
9066 m_customSizes
[i
] = allSizes
[i
];
9070 int wxGridSizesInfo::GetSize(unsigned pos
) const
9072 wxUnsignedToIntHashMap::const_iterator it
= m_customSizes
.find(pos
);
9074 // if it's not found return the default
9075 if ( it
== m_customSizes
.end() )
9076 return m_sizeDefault
;
9078 // otherwise return 0 if it's hidden, currently there is no way to get
9079 // its size before it had been hidden
9080 if ( it
->second
< 0 )
9086 // ----------------------------------------------------------------------------
9088 // ----------------------------------------------------------------------------
9090 #if wxUSE_DRAG_AND_DROP
9092 // this allow setting drop target directly on wxGrid
9093 void wxGrid::SetDropTarget(wxDropTarget
*dropTarget
)
9095 GetGridWindow()->SetDropTarget(dropTarget
);
9098 #endif // wxUSE_DRAG_AND_DROP
9100 // ----------------------------------------------------------------------------
9101 // grid event classes
9102 // ----------------------------------------------------------------------------
9104 IMPLEMENT_DYNAMIC_CLASS( wxGridEvent
, wxNotifyEvent
)
9106 wxGridEvent::wxGridEvent( int id
, wxEventType type
, wxObject
* obj
,
9107 int row
, int col
, int x
, int y
, bool sel
,
9108 bool control
, bool shift
, bool alt
, bool meta
)
9109 : wxNotifyEvent( type
, id
),
9110 wxKeyboardState(control
, shift
, alt
, meta
)
9112 Init(row
, col
, x
, y
, sel
);
9114 SetEventObject(obj
);
9117 IMPLEMENT_DYNAMIC_CLASS( wxGridSizeEvent
, wxNotifyEvent
)
9119 wxGridSizeEvent::wxGridSizeEvent( int id
, wxEventType type
, wxObject
* obj
,
9120 int rowOrCol
, int x
, int y
,
9121 bool control
, bool shift
, bool alt
, bool meta
)
9122 : wxNotifyEvent( type
, id
),
9123 wxKeyboardState(control
, shift
, alt
, meta
)
9125 Init(rowOrCol
, x
, y
);
9127 SetEventObject(obj
);
9131 IMPLEMENT_DYNAMIC_CLASS( wxGridRangeSelectEvent
, wxNotifyEvent
)
9133 wxGridRangeSelectEvent::wxGridRangeSelectEvent(int id
, wxEventType type
, wxObject
* obj
,
9134 const wxGridCellCoords
& topLeft
,
9135 const wxGridCellCoords
& bottomRight
,
9136 bool sel
, bool control
,
9137 bool shift
, bool alt
, bool meta
)
9138 : wxNotifyEvent( type
, id
),
9139 wxKeyboardState(control
, shift
, alt
, meta
)
9141 Init(topLeft
, bottomRight
, sel
);
9143 SetEventObject(obj
);
9147 IMPLEMENT_DYNAMIC_CLASS(wxGridEditorCreatedEvent
, wxCommandEvent
)
9149 wxGridEditorCreatedEvent::wxGridEditorCreatedEvent(int id
, wxEventType type
,
9150 wxObject
* obj
, int row
,
9151 int col
, wxControl
* ctrl
)
9152 : wxCommandEvent(type
, id
)
9154 SetEventObject(obj
);
9161 // ----------------------------------------------------------------------------
9162 // wxGridTypeRegistry
9163 // ----------------------------------------------------------------------------
9165 wxGridTypeRegistry::~wxGridTypeRegistry()
9167 size_t count
= m_typeinfo
.GetCount();
9168 for ( size_t i
= 0; i
< count
; i
++ )
9169 delete m_typeinfo
[i
];
9172 void wxGridTypeRegistry::RegisterDataType(const wxString
& typeName
,
9173 wxGridCellRenderer
* renderer
,
9174 wxGridCellEditor
* editor
)
9176 wxGridDataTypeInfo
* info
= new wxGridDataTypeInfo(typeName
, renderer
, editor
);
9178 // is it already registered?
9179 int loc
= FindRegisteredDataType(typeName
);
9180 if ( loc
!= wxNOT_FOUND
)
9182 delete m_typeinfo
[loc
];
9183 m_typeinfo
[loc
] = info
;
9187 m_typeinfo
.Add(info
);
9191 int wxGridTypeRegistry::FindRegisteredDataType(const wxString
& typeName
)
9193 size_t count
= m_typeinfo
.GetCount();
9194 for ( size_t i
= 0; i
< count
; i
++ )
9196 if ( typeName
== m_typeinfo
[i
]->m_typeName
)
9205 int wxGridTypeRegistry::FindDataType(const wxString
& typeName
)
9207 int index
= FindRegisteredDataType(typeName
);
9208 if ( index
== wxNOT_FOUND
)
9210 // check whether this is one of the standard ones, in which case
9211 // register it "on the fly"
9213 if ( typeName
== wxGRID_VALUE_STRING
)
9215 RegisterDataType(wxGRID_VALUE_STRING
,
9216 new wxGridCellStringRenderer
,
9217 new wxGridCellTextEditor
);
9220 #endif // wxUSE_TEXTCTRL
9222 if ( typeName
== wxGRID_VALUE_BOOL
)
9224 RegisterDataType(wxGRID_VALUE_BOOL
,
9225 new wxGridCellBoolRenderer
,
9226 new wxGridCellBoolEditor
);
9229 #endif // wxUSE_CHECKBOX
9231 if ( typeName
== wxGRID_VALUE_NUMBER
)
9233 RegisterDataType(wxGRID_VALUE_NUMBER
,
9234 new wxGridCellNumberRenderer
,
9235 new wxGridCellNumberEditor
);
9237 else if ( typeName
== wxGRID_VALUE_FLOAT
)
9239 RegisterDataType(wxGRID_VALUE_FLOAT
,
9240 new wxGridCellFloatRenderer
,
9241 new wxGridCellFloatEditor
);
9244 #endif // wxUSE_TEXTCTRL
9246 if ( typeName
== wxGRID_VALUE_CHOICE
)
9248 RegisterDataType(wxGRID_VALUE_CHOICE
,
9249 new wxGridCellStringRenderer
,
9250 new wxGridCellChoiceEditor
);
9253 #endif // wxUSE_COMBOBOX
9258 // we get here only if just added the entry for this type, so return
9260 index
= m_typeinfo
.GetCount() - 1;
9266 int wxGridTypeRegistry::FindOrCloneDataType(const wxString
& typeName
)
9268 int index
= FindDataType(typeName
);
9269 if ( index
== wxNOT_FOUND
)
9271 // the first part of the typename is the "real" type, anything after ':'
9272 // are the parameters for the renderer
9273 index
= FindDataType(typeName
.BeforeFirst(wxT(':')));
9274 if ( index
== wxNOT_FOUND
)
9279 wxGridCellRenderer
*renderer
= GetRenderer(index
);
9280 wxGridCellRenderer
*rendererOld
= renderer
;
9281 renderer
= renderer
->Clone();
9282 rendererOld
->DecRef();
9284 wxGridCellEditor
*editor
= GetEditor(index
);
9285 wxGridCellEditor
*editorOld
= editor
;
9286 editor
= editor
->Clone();
9287 editorOld
->DecRef();
9289 // do it even if there are no parameters to reset them to defaults
9290 wxString params
= typeName
.AfterFirst(wxT(':'));
9291 renderer
->SetParameters(params
);
9292 editor
->SetParameters(params
);
9294 // register the new typename
9295 RegisterDataType(typeName
, renderer
, editor
);
9297 // we just registered it, it's the last one
9298 index
= m_typeinfo
.GetCount() - 1;
9304 wxGridCellRenderer
* wxGridTypeRegistry::GetRenderer(int index
)
9306 wxGridCellRenderer
* renderer
= m_typeinfo
[index
]->m_renderer
;
9313 wxGridCellEditor
* wxGridTypeRegistry::GetEditor(int index
)
9315 wxGridCellEditor
* editor
= m_typeinfo
[index
]->m_editor
;
9322 #endif // wxUSE_GRID