]>
Commit | Line | Data |
---|---|---|
4ed7af08 | 1 | ///////////////////////////////////////////////////////////////////////////// |
f554a14b | 2 | // Name: src/generic/datavgen.cpp |
4ed7af08 RR |
3 | // Purpose: wxDataViewCtrl generic implementation |
4 | // Author: Robert Roebling | |
7274390f | 5 | // Modified by: Francesco Montorsi, Guru Kathiresan, Bo Yang |
4ed7af08 RR |
6 | // Id: $Id$ |
7 | // Copyright: (c) 1998 Robert Roebling | |
8 | // Licence: wxWindows licence | |
9 | ///////////////////////////////////////////////////////////////////////////// | |
10 | ||
11 | // For compilers that support precompilation, includes "wx.h". | |
12 | #include "wx/wxprec.h" | |
13 | ||
ed4b0fdc WS |
14 | #ifdef __BORLANDC__ |
15 | #pragma hdrstop | |
16 | #endif | |
17 | ||
4ed7af08 RR |
18 | #if wxUSE_DATAVIEWCTRL |
19 | ||
20 | #include "wx/dataview.h" | |
21 | ||
22 | #ifdef wxUSE_GENERICDATAVIEWCTRL | |
23 | ||
f554a14b | 24 | #ifndef WX_PRECOMP |
57bd4c60 | 25 | #ifdef __WXMSW__ |
87f0efe2 | 26 | #include "wx/msw/private.h" |
57bd4c60 | 27 | #include "wx/msw/wrapwin.h" |
87f0efe2 | 28 | #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly" |
57bd4c60 | 29 | #endif |
f554a14b WS |
30 | #include "wx/sizer.h" |
31 | #include "wx/log.h" | |
ed4b0fdc | 32 | #include "wx/dcclient.h" |
c0badb70 | 33 | #include "wx/timer.h" |
9eddec69 | 34 | #include "wx/settings.h" |
8d0ca292 | 35 | #include "wx/msgdlg.h" |
99d471a5 | 36 | #include "wx/dcscreen.h" |
818d91a9 | 37 | #include "wx/frame.h" |
f554a14b WS |
38 | #endif |
39 | ||
4ed7af08 | 40 | #include "wx/stockitem.h" |
4ed7af08 | 41 | #include "wx/popupwin.h" |
4ed7af08 | 42 | #include "wx/renderer.h" |
2e992e06 | 43 | #include "wx/dcbuffer.h" |
2586d4a1 | 44 | #include "wx/icon.h" |
351461fc RR |
45 | #include "wx/list.h" |
46 | #include "wx/listimpl.cpp" | |
0c8ed3eb | 47 | #include "wx/imaglist.h" |
e2bfe673 | 48 | #include "wx/headerctrl.h" |
592883ed | 49 | #include "wx/dnd.h" |
0645bd38 | 50 | #include "wx/stopwatch.h" |
64ac3db8 | 51 | #include "wx/weakref.h" |
4ed7af08 | 52 | |
4ed7af08 RR |
53 | //----------------------------------------------------------------------------- |
54 | // classes | |
55 | //----------------------------------------------------------------------------- | |
56 | ||
5d9e1605 RR |
57 | class wxDataViewColumn; |
58 | class wxDataViewHeaderWindow; | |
4ed7af08 RR |
59 | class wxDataViewCtrl; |
60 | ||
5d9e1605 RR |
61 | //----------------------------------------------------------------------------- |
62 | // classes | |
63 | //----------------------------------------------------------------------------- | |
64 | ||
9861f022 RR |
65 | static const int SCROLL_UNIT_X = 15; |
66 | ||
67 | // the cell padding on the left/right | |
68 | static const int PADDING_RIGHTLEFT = 3; | |
69 | ||
3b6280be RR |
70 | // the expander space margin |
71 | static const int EXPANDER_MARGIN = 4; | |
9861f022 | 72 | |
344ed1f3 RR |
73 | #ifdef __WXMSW__ |
74 | static const int EXPANDER_OFFSET = 4; | |
75 | #else | |
76 | static const int EXPANDER_OFFSET = 1; | |
77 | #endif | |
78 | ||
bc4f1ff2 | 79 | // Below is the compare stuff. |
4cef3873 | 80 | // For the generic implementation, both the leaf nodes and the nodes are sorted for |
bc4f1ff2 FM |
81 | // fast search when needed |
82 | static wxDataViewModel* g_model; | |
24c4a50f RR |
83 | static int g_column = -2; |
84 | static bool g_asending = true; | |
57f2a652 | 85 | |
1841f079 VZ |
86 | // ---------------------------------------------------------------------------- |
87 | // helper functions | |
88 | // ---------------------------------------------------------------------------- | |
89 | ||
90 | namespace | |
91 | { | |
92 | ||
93 | // Return the expander column or, if it is not set, the first column and also | |
94 | // set it as the expander one for the future. | |
95 | wxDataViewColumn* GetExpanderColumnOrFirstOne(wxDataViewCtrl* dataview) | |
96 | { | |
97 | wxDataViewColumn* expander = dataview->GetExpanderColumn(); | |
98 | if (!expander) | |
99 | { | |
100 | // TODO-RTL: last column for RTL support | |
101 | expander = dataview->GetColumnAt( 0 ); | |
102 | dataview->SetExpanderColumn(expander); | |
103 | } | |
104 | ||
105 | return expander; | |
106 | } | |
107 | ||
108 | } // anonymous namespace | |
109 | ||
5d9e1605 RR |
110 | //----------------------------------------------------------------------------- |
111 | // wxDataViewColumn | |
112 | //----------------------------------------------------------------------------- | |
113 | ||
114 | void wxDataViewColumn::Init(int width, wxAlignment align, int flags) | |
115 | { | |
d0154e3a | 116 | m_width = width; |
5d9e1605 RR |
117 | m_minWidth = 0; |
118 | m_align = align; | |
119 | m_flags = flags; | |
120 | m_sort = false; | |
121 | m_sortAscending = true; | |
122 | } | |
ce00f59b | 123 | |
d0154e3a VS |
124 | int wxDataViewColumn::GetWidth() const |
125 | { | |
126 | switch ( m_width ) | |
127 | { | |
128 | case wxCOL_WIDTH_DEFAULT: | |
129 | return wxDVC_DEFAULT_WIDTH; | |
130 | ||
131 | case wxCOL_WIDTH_AUTOSIZE: | |
132 | wxCHECK_MSG( m_owner, wxDVC_DEFAULT_WIDTH, "no owner control" ); | |
133 | return m_owner->GetBestColumnWidth(m_owner->GetColumnIndex(this)); | |
134 | ||
135 | default: | |
136 | return m_width; | |
137 | } | |
138 | } | |
139 | ||
5d9e1605 RR |
140 | void wxDataViewColumn::UpdateDisplay() |
141 | { | |
142 | if (m_owner) | |
143 | { | |
144 | int idx = m_owner->GetColumnIndex( this ); | |
145 | m_owner->OnColumnChange( idx ); | |
146 | } | |
147 | } | |
148 | ||
15b8afdc VZ |
149 | void wxDataViewColumn::SetSortOrder(bool ascending) |
150 | { | |
151 | if ( !m_owner ) | |
152 | return; | |
153 | ||
154 | // First unset the old sort column if any. | |
155 | int oldSortKey = m_owner->GetSortingColumnIndex(); | |
156 | if ( oldSortKey != wxNOT_FOUND ) | |
157 | { | |
158 | m_owner->GetColumn(oldSortKey)->UnsetAsSortKey(); | |
159 | } | |
160 | ||
161 | // Now set this one as the new sort column. | |
162 | const int idx = m_owner->GetColumnIndex(this); | |
163 | m_owner->SetSortingColumnIndex(idx); | |
164 | ||
165 | m_sort = true; | |
166 | m_sortAscending = ascending; | |
167 | ||
168 | // Call this directly instead of using UpdateDisplay() as we already have | |
169 | // the column index, no need to look it up again. | |
170 | m_owner->OnColumnChange(idx); | |
171 | } | |
172 | ||
fa3d4aaf VZ |
173 | //----------------------------------------------------------------------------- |
174 | // wxDataViewHeaderWindow | |
175 | //----------------------------------------------------------------------------- | |
176 | ||
e2bfe673 | 177 | class wxDataViewHeaderWindow : public wxHeaderCtrl |
87f0efe2 RR |
178 | { |
179 | public: | |
e2bfe673 VZ |
180 | wxDataViewHeaderWindow(wxDataViewCtrl *parent) |
181 | : wxHeaderCtrl(parent) | |
87f0efe2 | 182 | { |
87f0efe2 RR |
183 | } |
184 | ||
e2bfe673 VZ |
185 | wxDataViewCtrl *GetOwner() const |
186 | { return static_cast<wxDataViewCtrl *>(GetParent()); } | |
87f0efe2 | 187 | |
3bfaa5a7 VZ |
188 | protected: |
189 | // implement/override wxHeaderCtrl functions by forwarding them to the main | |
190 | // control | |
482d06f8 | 191 | virtual const wxHeaderColumn& GetColumn(unsigned int idx) const |
87f0efe2 | 192 | { |
e2bfe673 | 193 | return *(GetOwner()->GetColumn(idx)); |
87f0efe2 RR |
194 | } |
195 | ||
3bfaa5a7 VZ |
196 | virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle) |
197 | { | |
198 | wxDataViewCtrl * const owner = GetOwner(); | |
199 | ||
200 | int widthContents = owner->GetBestColumnWidth(idx); | |
201 | owner->GetColumn(idx)->SetWidth(wxMax(widthTitle, widthContents)); | |
aef252d9 | 202 | owner->OnColumnChange(idx); |
3bfaa5a7 VZ |
203 | |
204 | return true; | |
205 | } | |
206 | ||
207 | private: | |
fa3d4aaf VZ |
208 | bool SendEvent(wxEventType type, unsigned int n) |
209 | { | |
210 | wxDataViewCtrl * const owner = GetOwner(); | |
211 | wxDataViewEvent event(type, owner->GetId()); | |
212 | ||
213 | event.SetEventObject(owner); | |
214 | event.SetColumn(n); | |
215 | event.SetDataViewColumn(owner->GetColumn(n)); | |
216 | event.SetModel(owner->GetModel()); | |
217 | ||
218 | // for events created by wxDataViewHeaderWindow the | |
219 | // row / value fields are not valid | |
857f05e1 | 220 | return owner->ProcessWindowEvent(event); |
fa3d4aaf VZ |
221 | } |
222 | ||
223 | void OnClick(wxHeaderCtrlEvent& event) | |
224 | { | |
46234a03 VZ |
225 | const unsigned idx = event.GetColumn(); |
226 | ||
227 | if ( SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, idx) ) | |
228 | return; | |
229 | ||
230 | // default handling for the column click is to sort by this column or | |
231 | // toggle its sort order | |
232 | wxDataViewCtrl * const owner = GetOwner(); | |
233 | wxDataViewColumn * const col = owner->GetColumn(idx); | |
234 | if ( !col->IsSortable() ) | |
235 | { | |
236 | // no default handling for non-sortable columns | |
fa3d4aaf | 237 | event.Skip(); |
46234a03 VZ |
238 | return; |
239 | } | |
240 | ||
241 | if ( col->IsSortKey() ) | |
242 | { | |
243 | // already using this column for sorting, just change the order | |
244 | col->ToggleSortOrder(); | |
245 | } | |
246 | else // not using this column for sorting yet | |
247 | { | |
aadbdd16 | 248 | col->SetSortOrder(true); |
46234a03 VZ |
249 | } |
250 | ||
251 | wxDataViewModel * const model = owner->GetModel(); | |
252 | if ( model ) | |
253 | model->Resort(); | |
254 | ||
255 | owner->OnColumnChange(idx); | |
ff7bc95e VZ |
256 | |
257 | SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, idx); | |
fa3d4aaf VZ |
258 | } |
259 | ||
260 | void OnRClick(wxHeaderCtrlEvent& event) | |
261 | { | |
262 | if ( !SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, | |
263 | event.GetColumn()) ) | |
264 | event.Skip(); | |
265 | } | |
266 | ||
bc4f1ff2 | 267 | void OnResize(wxHeaderCtrlEvent& event) |
aef252d9 | 268 | { |
dcb6cbec VZ |
269 | wxDataViewCtrl * const owner = GetOwner(); |
270 | ||
565804f2 | 271 | const unsigned col = event.GetColumn(); |
dcb6cbec | 272 | owner->GetColumn(col)->SetWidth(event.GetWidth()); |
565804f2 | 273 | GetOwner()->OnColumnChange(col); |
aef252d9 VZ |
274 | } |
275 | ||
702f5349 VZ |
276 | void OnEndReorder(wxHeaderCtrlEvent& event) |
277 | { | |
278 | wxDataViewCtrl * const owner = GetOwner(); | |
279 | owner->ColumnMoved(owner->GetColumn(event.GetColumn()), | |
977a41ec | 280 | event.GetNewOrder()); |
702f5349 VZ |
281 | } |
282 | ||
fa3d4aaf | 283 | DECLARE_EVENT_TABLE() |
c0c133e1 | 284 | wxDECLARE_NO_COPY_CLASS(wxDataViewHeaderWindow); |
a0f3af5f | 285 | }; |
4ed7af08 | 286 | |
fa3d4aaf VZ |
287 | BEGIN_EVENT_TABLE(wxDataViewHeaderWindow, wxHeaderCtrl) |
288 | EVT_HEADER_CLICK(wxID_ANY, wxDataViewHeaderWindow::OnClick) | |
289 | EVT_HEADER_RIGHT_CLICK(wxID_ANY, wxDataViewHeaderWindow::OnRClick) | |
aef252d9 | 290 | |
bc4f1ff2 FM |
291 | EVT_HEADER_RESIZING(wxID_ANY, wxDataViewHeaderWindow::OnResize) |
292 | EVT_HEADER_END_RESIZE(wxID_ANY, wxDataViewHeaderWindow::OnResize) | |
702f5349 VZ |
293 | |
294 | EVT_HEADER_END_REORDER(wxID_ANY, wxDataViewHeaderWindow::OnEndReorder) | |
fa3d4aaf VZ |
295 | END_EVENT_TABLE() |
296 | ||
0fcce6b9 RR |
297 | //----------------------------------------------------------------------------- |
298 | // wxDataViewRenameTimer | |
299 | //----------------------------------------------------------------------------- | |
300 | ||
301 | class wxDataViewRenameTimer: public wxTimer | |
302 | { | |
303 | private: | |
304 | wxDataViewMainWindow *m_owner; | |
305 | ||
306 | public: | |
307 | wxDataViewRenameTimer( wxDataViewMainWindow *owner ); | |
308 | void Notify(); | |
309 | }; | |
310 | ||
aba9bfd0 RR |
311 | //----------------------------------------------------------------------------- |
312 | // wxDataViewTreeNode | |
313 | //----------------------------------------------------------------------------- | |
bc4f1ff2 | 314 | |
442c56e6 | 315 | class wxDataViewTreeNode; |
57f2a652 | 316 | WX_DEFINE_ARRAY( wxDataViewTreeNode *, wxDataViewTreeNodes ); |
d47db7e0 | 317 | |
4cef3873 | 318 | int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1, |
bc4f1ff2 | 319 | wxDataViewTreeNode ** node2); |
aba9bfd0 RR |
320 | |
321 | class wxDataViewTreeNode | |
322 | { | |
323 | public: | |
422aa8ec | 324 | wxDataViewTreeNode(wxDataViewTreeNode *parent, const wxDataViewItem& item) |
fb5f677b VZ |
325 | : m_parent(parent), |
326 | m_item(item), | |
d0cfefc4 | 327 | m_branchData(NULL) |
b5ec7dd6 | 328 | { |
438fb233 | 329 | } |
b5ec7dd6 | 330 | |
d0cfefc4 VS |
331 | ~wxDataViewTreeNode() |
332 | { | |
a2d3c415 VS |
333 | if ( m_branchData ) |
334 | { | |
335 | wxDataViewTreeNodes& nodes = m_branchData->children; | |
336 | for ( wxDataViewTreeNodes::iterator i = nodes.begin(); | |
337 | i != nodes.end(); | |
338 | ++i ) | |
339 | { | |
340 | delete *i; | |
341 | } | |
342 | ||
343 | delete m_branchData; | |
344 | } | |
d0cfefc4 VS |
345 | } |
346 | ||
422aa8ec | 347 | static wxDataViewTreeNode* CreateRootNode() |
d47db7e0 | 348 | { |
422aa8ec | 349 | wxDataViewTreeNode *n = new wxDataViewTreeNode(NULL, wxDataViewItem()); |
d0cfefc4 VS |
350 | n->SetHasChildren(true); |
351 | n->m_branchData->open = true; | |
422aa8ec | 352 | return n; |
d47db7e0 | 353 | } |
aba9bfd0 | 354 | |
344ed1f3 | 355 | wxDataViewTreeNode * GetParent() const { return m_parent; } |
422aa8ec | 356 | |
a2d3c415 | 357 | const wxDataViewTreeNodes& GetChildNodes() const |
d0cfefc4 VS |
358 | { |
359 | wxASSERT( m_branchData != NULL ); | |
ff3c5ad3 | 360 | return m_branchData->children; |
d0cfefc4 | 361 | } |
442c56e6 | 362 | |
35219832 | 363 | void InsertChild(wxDataViewTreeNode *node, unsigned index) |
d47db7e0 | 364 | { |
d0cfefc4 VS |
365 | if ( !m_branchData ) |
366 | m_branchData = new BranchNodeData; | |
367 | ||
35219832 VS |
368 | m_branchData->children.Insert(node, index); |
369 | ||
422aa8ec | 370 | // TODO: insert into sorted array directly in O(log n) instead of resorting in O(n log n) |
24c4a50f | 371 | if (g_column >= -1) |
ff3c5ad3 | 372 | m_branchData->children.Sort( &wxGenericTreeModelNodeCmp ); |
57f2a652 | 373 | } |
aba9bfd0 | 374 | |
a2d3c415 VS |
375 | void RemoveChild(wxDataViewTreeNode *node) |
376 | { | |
377 | wxCHECK_RET( m_branchData != NULL, "leaf node doesn't have children" ); | |
378 | m_branchData->children.Remove(node); | |
379 | } | |
380 | ||
5bb82ad4 VS |
381 | // returns position of child node for given item in children list or wxNOT_FOUND |
382 | int FindChildByItem(const wxDataViewItem& item) const | |
383 | { | |
384 | if ( !m_branchData ) | |
385 | return wxNOT_FOUND; | |
386 | ||
387 | const wxDataViewTreeNodes& nodes = m_branchData->children; | |
388 | const int len = nodes.size(); | |
389 | for ( int i = 0; i < len; i++ ) | |
390 | { | |
391 | if ( nodes[i]->m_item == item ) | |
392 | return i; | |
393 | } | |
394 | return wxNOT_FOUND; | |
395 | } | |
396 | ||
344ed1f3 | 397 | const wxDataViewItem & GetItem() const { return m_item; } |
438fb233 | 398 | void SetItem( const wxDataViewItem & item ) { m_item = item; } |
aba9bfd0 | 399 | |
344ed1f3 | 400 | int GetIndentLevel() const |
3b6280be | 401 | { |
59e60167 | 402 | int ret = 0; |
344ed1f3 | 403 | const wxDataViewTreeNode * node = this; |
438fb233 RR |
404 | while( node->GetParent()->GetParent() != NULL ) |
405 | { | |
406 | node = node->GetParent(); | |
407 | ret ++; | |
408 | } | |
409 | return ret; | |
3b6280be | 410 | } |
aba9bfd0 | 411 | |
344ed1f3 | 412 | bool IsOpen() const |
442c56e6 | 413 | { |
d0cfefc4 | 414 | return m_branchData && m_branchData->open; |
442c56e6 | 415 | } |
d47db7e0 RR |
416 | |
417 | void ToggleOpen() | |
442c56e6 | 418 | { |
d0cfefc4 VS |
419 | wxCHECK_RET( m_branchData != NULL, "can't open leaf node" ); |
420 | ||
d47db7e0 | 421 | int sum = 0; |
422aa8ec | 422 | |
ff3c5ad3 | 423 | const wxDataViewTreeNodes& nodes = m_branchData->children; |
d0cfefc4 | 424 | const int len = nodes.GetCount(); |
59e60167 | 425 | for ( int i = 0;i < len; i ++) |
d0cfefc4 | 426 | sum += 1 + nodes[i]->GetSubTreeCount(); |
d47db7e0 | 427 | |
d0cfefc4 | 428 | if (m_branchData->open) |
d47db7e0 RR |
429 | { |
430 | ChangeSubTreeCount(-sum); | |
d0cfefc4 | 431 | m_branchData->open = !m_branchData->open; |
d47db7e0 RR |
432 | } |
433 | else | |
434 | { | |
d0cfefc4 | 435 | m_branchData->open = !m_branchData->open; |
422aa8ec | 436 | ChangeSubTreeCount(+sum); |
d47db7e0 RR |
437 | } |
438 | } | |
422aa8ec VS |
439 | |
440 | // "HasChildren" property corresponds to model's IsContainer(). Note that it may be true | |
ff3c5ad3 | 441 | // even if GetChildNodes() is empty; see below. |
d0cfefc4 VS |
442 | bool HasChildren() const |
443 | { | |
444 | return m_branchData != NULL; | |
445 | } | |
446 | ||
447 | void SetHasChildren(bool has) | |
448 | { | |
449 | if ( !has ) | |
450 | { | |
451 | wxDELETE(m_branchData); | |
452 | } | |
453 | else if ( m_branchData == NULL ) | |
454 | { | |
455 | m_branchData = new BranchNodeData; | |
456 | } | |
457 | } | |
458 | ||
459 | int GetSubTreeCount() const | |
460 | { | |
461 | return m_branchData ? m_branchData->subTreeCount : 0; | |
462 | } | |
d47db7e0 | 463 | |
442c56e6 | 464 | void ChangeSubTreeCount( int num ) |
d47db7e0 | 465 | { |
d0cfefc4 VS |
466 | wxASSERT( m_branchData != NULL ); |
467 | ||
468 | if( !m_branchData->open ) | |
59e60167 | 469 | return; |
422aa8ec | 470 | |
d0cfefc4 VS |
471 | m_branchData->subTreeCount += num; |
472 | wxASSERT( m_branchData->subTreeCount >= 0 ); | |
422aa8ec | 473 | |
438fb233 RR |
474 | if( m_parent ) |
475 | m_parent->ChangeSubTreeCount(num); | |
d47db7e0 RR |
476 | } |
477 | ||
d3f00f59 VZ |
478 | void Resort() |
479 | { | |
d0cfefc4 VS |
480 | if ( !m_branchData ) |
481 | return; | |
482 | ||
24c4a50f | 483 | if (g_column >= -1) |
d3f00f59 | 484 | { |
ff3c5ad3 | 485 | wxDataViewTreeNodes& nodes = m_branchData->children; |
d0cfefc4 VS |
486 | |
487 | nodes.Sort( &wxGenericTreeModelNodeCmp ); | |
488 | int len = nodes.GetCount(); | |
57f2a652 | 489 | for (int i = 0; i < len; i ++) |
422aa8ec | 490 | { |
d0cfefc4 VS |
491 | if ( nodes[i]->HasChildren() ) |
492 | nodes[i]->Resort(); | |
422aa8ec | 493 | } |
57ab4546 | 494 | } |
57ab4546 VS |
495 | } |
496 | ||
497 | ||
aba9bfd0 | 498 | private: |
d0cfefc4 VS |
499 | wxDataViewTreeNode *m_parent; |
500 | ||
422aa8ec VS |
501 | // Corresponding model item. |
502 | wxDataViewItem m_item; | |
503 | ||
d0cfefc4 VS |
504 | // Data specific to non-leaf (branch, inner) nodes. They are kept in a |
505 | // separate struct in order to conserve memory. | |
506 | struct BranchNodeData | |
507 | { | |
508 | BranchNodeData() | |
509 | : open(false), | |
510 | subTreeCount(0) | |
511 | { | |
512 | } | |
422aa8ec | 513 | |
d0cfefc4 VS |
514 | // Child nodes. Note that this may be empty even if m_hasChildren in |
515 | // case this branch of the tree wasn't expanded and realized yet. | |
ff3c5ad3 | 516 | wxDataViewTreeNodes children; |
422aa8ec | 517 | |
d0cfefc4 VS |
518 | // Is the branch node currently open (expanded)? |
519 | bool open; | |
422aa8ec | 520 | |
d0cfefc4 VS |
521 | // Total count of expanded (i.e. visible with the help of some |
522 | // scrolling) items in the subtree, but excluding this node. I.e. it is | |
523 | // 0 for leaves and is the number of rows the subtree occupies for | |
524 | // branch nodes. | |
525 | int subTreeCount; | |
526 | }; | |
422aa8ec | 527 | |
d0cfefc4 | 528 | BranchNodeData *m_branchData; |
aba9bfd0 RR |
529 | }; |
530 | ||
422aa8ec | 531 | |
4cef3873 | 532 | int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1, |
bc4f1ff2 | 533 | wxDataViewTreeNode ** node2) |
d47db7e0 | 534 | { |
57f2a652 | 535 | return g_model->Compare( (*node1)->GetItem(), (*node2)->GetItem(), g_column, g_asending ); |
d47db7e0 RR |
536 | } |
537 | ||
d47db7e0 | 538 | |
a0f3af5f RR |
539 | //----------------------------------------------------------------------------- |
540 | // wxDataViewMainWindow | |
541 | //----------------------------------------------------------------------------- | |
4ed7af08 | 542 | |
c3b0247d | 543 | WX_DEFINE_SORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection); |
cab07038 | 544 | |
a0f3af5f | 545 | class wxDataViewMainWindow: public wxWindow |
4ed7af08 | 546 | { |
a0f3af5f RR |
547 | public: |
548 | wxDataViewMainWindow( wxDataViewCtrl *parent, | |
549 | wxWindowID id, | |
550 | const wxPoint &pos = wxDefaultPosition, | |
551 | const wxSize &size = wxDefaultSize, | |
552 | const wxString &name = wxT("wxdataviewctrlmainwindow") ); | |
d3c7fc99 | 553 | virtual ~wxDataViewMainWindow(); |
777f9cef | 554 | |
c2c89730 | 555 | bool IsList() const { return GetModel()->IsListModel(); } |
344ed1f3 | 556 | bool IsVirtualList() const { return m_root == NULL; } |
4ed7af08 | 557 | |
aba9bfd0 RR |
558 | // notifications from wxDataViewModel |
559 | bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item ); | |
32143117 | 560 | bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item ); |
aba9bfd0 | 561 | bool ItemChanged( const wxDataViewItem &item ); |
d93cc830 | 562 | bool ValueChanged( const wxDataViewItem &item, unsigned int model_column ); |
a0f3af5f | 563 | bool Cleared(); |
d3f00f59 | 564 | void Resort() |
b7fe2261 | 565 | { |
344ed1f3 | 566 | if (!IsVirtualList()) |
a3cc79d9 RR |
567 | { |
568 | SortPrepare(); | |
569 | m_root->Resort(); | |
570 | } | |
b7fe2261 | 571 | UpdateDisplay(); |
66e09788 | 572 | } |
4ed7af08 | 573 | |
66e09788 RR |
574 | void SortPrepare() |
575 | { | |
c2c89730 | 576 | g_model = GetModel(); |
57f2a652 | 577 | wxDataViewColumn* col = GetOwner()->GetSortingColumn(); |
66e09788 RR |
578 | if( !col ) |
579 | { | |
24c4a50f RR |
580 | if (g_model->HasDefaultCompare()) |
581 | g_column = -1; | |
582 | else | |
583 | g_column = -2; | |
584 | ||
66e09788 RR |
585 | g_asending = true; |
586 | return; | |
587 | } | |
57f2a652 | 588 | g_column = col->GetModelColumn(); |
b7fe2261 | 589 | g_asending = col->IsSortOrderAscending(); |
66e09788 | 590 | } |
b7fe2261 | 591 | |
a0f3af5f RR |
592 | void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; } |
593 | wxDataViewCtrl *GetOwner() { return m_owner; } | |
9861f022 | 594 | const wxDataViewCtrl *GetOwner() const { return m_owner; } |
4ed7af08 | 595 | |
c2c89730 VS |
596 | wxDataViewModel* GetModel() { return GetOwner()->GetModel(); } |
597 | const wxDataViewModel* GetModel() const { return GetOwner()->GetModel(); } | |
598 | ||
9adeb77a | 599 | #if wxUSE_DRAG_AND_DROP |
818d91a9 | 600 | wxBitmap CreateItemBitmap( unsigned int row, int &indent ); |
9adeb77a | 601 | #endif // wxUSE_DRAG_AND_DROP |
a0f3af5f | 602 | void OnPaint( wxPaintEvent &event ); |
64ac3db8 | 603 | void OnCharHook( wxKeyEvent &event ); |
cab07038 | 604 | void OnChar( wxKeyEvent &event ); |
1dc779fc | 605 | void OnVerticalNavigation(unsigned int newCurrent, const wxKeyEvent& event); |
cfc21881 VS |
606 | void OnLeftKey(); |
607 | void OnRightKey(); | |
a0f3af5f RR |
608 | void OnMouse( wxMouseEvent &event ); |
609 | void OnSetFocus( wxFocusEvent &event ); | |
cab07038 | 610 | void OnKillFocus( wxFocusEvent &event ); |
f554a14b | 611 | |
a0f3af5f RR |
612 | void UpdateDisplay(); |
613 | void RecalculateDisplay(); | |
614 | void OnInternalIdle(); | |
f554a14b | 615 | |
0fcce6b9 | 616 | void OnRenameTimer(); |
0fcce6b9 | 617 | |
9861f022 | 618 | void ScrollWindow( int dx, int dy, const wxRect *rect = NULL ); |
fbda518c | 619 | void ScrollTo( int rows, int column ); |
120b9b05 | 620 | |
80ce465c | 621 | unsigned GetCurrentRow() const { return m_currentRow; } |
0a71f9e9 RR |
622 | bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; } |
623 | void ChangeCurrentRow( unsigned int row ); | |
1c8e71c9 | 624 | bool TryAdvanceCurrentColumn(wxDataViewTreeNode *node, bool forward); |
120b9b05 | 625 | |
f52f3795 VS |
626 | wxDataViewColumn *GetCurrentColumn() const { return m_currentCol; } |
627 | void ClearCurrentColumn() { m_currentCol = NULL; } | |
628 | ||
47b378bd | 629 | bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); } |
cab07038 | 630 | bool IsEmpty() { return GetRowCount() == 0; } |
120b9b05 | 631 | |
9861f022 RR |
632 | int GetCountPerPage() const; |
633 | int GetEndOfLastCol() const; | |
634 | unsigned int GetFirstVisibleRow() const; | |
bc4f1ff2 | 635 | |
4cef3873 VZ |
636 | // I change this method to un const because in the tree view, |
637 | // the displaying number of the tree are changing along with the | |
bc4f1ff2 | 638 | // expanding/collapsing of the tree nodes |
3b6280be | 639 | unsigned int GetLastVisibleRow(); |
f2bf2d71 | 640 | unsigned int GetRowCount() const; |
120b9b05 | 641 | |
f23b8c0d | 642 | const wxDataViewSelection& GetSelections() const { return m_selection; } |
4cef3873 | 643 | void SetSelections( const wxDataViewSelection & sel ) |
bc4f1ff2 | 644 | { m_selection = sel; UpdateDisplay(); } |
87f0efe2 | 645 | void Select( const wxArrayInt& aSelections ); |
cab07038 | 646 | void SelectAllRows( bool on ); |
0a71f9e9 RR |
647 | void SelectRow( unsigned int row, bool on ); |
648 | void SelectRows( unsigned int from, unsigned int to, bool on ); | |
649 | void ReverseRowSelection( unsigned int row ); | |
650 | bool IsRowSelected( unsigned int row ); | |
526e19e2 | 651 | void SendSelectionChangedEvent( const wxDataViewItem& item); |
120b9b05 | 652 | |
0a71f9e9 RR |
653 | void RefreshRow( unsigned int row ); |
654 | void RefreshRows( unsigned int from, unsigned int to ); | |
655 | void RefreshRowsAfter( unsigned int firstRow ); | |
120b9b05 | 656 | |
9861f022 RR |
657 | // returns the colour to be used for drawing the rules |
658 | wxColour GetRuleColour() const | |
659 | { | |
660 | return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT); | |
661 | } | |
662 | ||
9861f022 | 663 | wxRect GetLineRect( unsigned int row ) const; |
777f9cef | 664 | |
344ed1f3 RR |
665 | int GetLineStart( unsigned int row ) const; // row * m_lineHeight in fixed mode |
666 | int GetLineHeight( unsigned int row ) const; // m_lineHeight in fixed mode | |
667 | int GetLineAt( unsigned int y ) const; // y / m_lineHeight in fixed mode | |
9861f022 | 668 | |
bbfd4548 | 669 | void SetRowHeight( int lineHeight ) { m_lineHeight = lineHeight; } |
0fdeaabe | 670 | int GetRowHeight() const { return m_lineHeight; } |
bbfd4548 | 671 | |
bc4f1ff2 | 672 | // Some useful functions for row and item mapping |
fbda518c | 673 | wxDataViewItem GetItemByRow( unsigned int row ) const; |
344ed1f3 | 674 | int GetRowByItem( const wxDataViewItem & item ) const; |
777f9cef | 675 | |
0fdeaabe VS |
676 | wxDataViewTreeNode * GetTreeNodeByRow( unsigned int row ) const; |
677 | // We did not need this temporarily | |
678 | // wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item ); | |
679 | ||
bc4f1ff2 | 680 | // Methods for building the mapping tree |
aba9bfd0 RR |
681 | void BuildTree( wxDataViewModel * model ); |
682 | void DestroyTree(); | |
a87b466d | 683 | void HitTest( const wxPoint & point, wxDataViewItem & item, wxDataViewColumn* &column ); |
fbda518c | 684 | wxRect GetItemRect( const wxDataViewItem & item, const wxDataViewColumn* column ); |
afebb87b | 685 | |
235d5f88 RR |
686 | void Expand( unsigned int row ); |
687 | void Collapse( unsigned int row ); | |
739a8399 | 688 | bool IsExpanded( unsigned int row ) const; |
235d5f88 | 689 | bool HasChildren( unsigned int row ) const; |
821baf7d | 690 | |
9adeb77a | 691 | #if wxUSE_DRAG_AND_DROP |
a653c966 RR |
692 | bool EnableDragSource( const wxDataFormat &format ); |
693 | bool EnableDropTarget( const wxDataFormat &format ); | |
694 | ||
9deec111 | 695 | void RemoveDropHint(); |
a653c966 RR |
696 | wxDragResult OnDragOver( wxDataFormat format, wxCoord x, wxCoord y, wxDragResult def ); |
697 | bool OnDrop( wxDataFormat format, wxCoord x, wxCoord y ); | |
698 | wxDragResult OnData( wxDataFormat format, wxCoord x, wxCoord y, wxDragResult def ); | |
699 | void OnLeave(); | |
9adeb77a | 700 | #endif // wxUSE_DRAG_AND_DROP |
821baf7d | 701 | |
1c8e71c9 VS |
702 | void OnColumnsCountChanged(); |
703 | ||
64ac3db8 VZ |
704 | // Called by wxDataViewCtrl and our own OnRenameTimer() to start edit the |
705 | // specified item in the given column. | |
706 | void StartEditing(const wxDataViewItem& item, const wxDataViewColumn* col); | |
707 | ||
3b6280be | 708 | private: |
f2bf2d71 | 709 | int RecalculateCount() const; |
3b6280be | 710 | |
fd48fe89 VZ |
711 | // Return false only if the event was vetoed by its handler. |
712 | bool SendExpanderEvent(wxEventType type, const wxDataViewItem& item); | |
aba9bfd0 | 713 | |
442c56e6 | 714 | wxDataViewTreeNode * FindNode( const wxDataViewItem & item ); |
351461fc | 715 | |
1c8e71c9 VS |
716 | wxDataViewColumn *FindColumnForEditing(const wxDataViewItem& item, wxDataViewCellMode mode); |
717 | ||
cf5d4c76 VS |
718 | bool IsCellEditableInMode(const wxDataViewItem& item, const wxDataViewColumn *col, wxDataViewCellMode mode) const; |
719 | ||
1c959a62 VZ |
720 | void DrawCellBackground( wxDataViewRenderer* cell, wxDC& dc, const wxRect& rect ); |
721 | ||
a0f3af5f | 722 | private: |
0fcce6b9 RR |
723 | wxDataViewCtrl *m_owner; |
724 | int m_lineHeight; | |
725 | bool m_dirty; | |
120b9b05 | 726 | |
0fcce6b9 | 727 | wxDataViewColumn *m_currentCol; |
99d471a5 | 728 | unsigned int m_currentRow; |
cab07038 | 729 | wxDataViewSelection m_selection; |
120b9b05 | 730 | |
0fcce6b9 | 731 | wxDataViewRenameTimer *m_renameTimer; |
0fcce6b9 | 732 | bool m_lastOnSame; |
f554a14b | 733 | |
cab07038 | 734 | bool m_hasFocus; |
1c8e71c9 VS |
735 | bool m_useCellFocus; |
736 | bool m_currentColSetByKeyboard; | |
cab07038 | 737 | |
9adeb77a | 738 | #if wxUSE_DRAG_AND_DROP |
e21f75bd RR |
739 | int m_dragCount; |
740 | wxPoint m_dragStart; | |
9adeb77a | 741 | |
821baf7d RR |
742 | bool m_dragEnabled; |
743 | wxDataFormat m_dragFormat; | |
9adeb77a | 744 | |
821baf7d RR |
745 | bool m_dropEnabled; |
746 | wxDataFormat m_dropFormat; | |
9deec111 RR |
747 | bool m_dropHint; |
748 | unsigned int m_dropHintLine; | |
9adeb77a | 749 | #endif // wxUSE_DRAG_AND_DROP |
e21f75bd RR |
750 | |
751 | // for double click logic | |
0a71f9e9 | 752 | unsigned int m_lineLastClicked, |
977a41ec FM |
753 | m_lineBeforeLastClicked, |
754 | m_lineSelectSingleOnUp; | |
cab07038 | 755 | |
9861f022 RR |
756 | // the pen used to draw horiz/vertical rules |
757 | wxPen m_penRule; | |
758 | ||
3b6280be RR |
759 | // the pen used to draw the expander and the lines |
760 | wxPen m_penExpander; | |
761 | ||
bc4f1ff2 | 762 | // This is the tree structure of the model |
442c56e6 | 763 | wxDataViewTreeNode * m_root; |
3b6280be | 764 | int m_count; |
bc4f1ff2 FM |
765 | |
766 | // This is the tree node under the cursor | |
24c4a50f | 767 | wxDataViewTreeNode * m_underMouse; |
bc4f1ff2 | 768 | |
64ac3db8 VZ |
769 | // The control used for editing or NULL. |
770 | wxWeakRef<wxWindow> m_editorCtrl; | |
771 | ||
772 | // Id m_editorCtrl is non-NULL, pointer to the associated renderer. | |
773 | wxDataViewRenderer* m_editorRenderer; | |
774 | ||
a0f3af5f RR |
775 | private: |
776 | DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow) | |
777 | DECLARE_EVENT_TABLE() | |
778 | }; | |
4ed7af08 | 779 | |
f554a14b | 780 | // --------------------------------------------------------- |
aba9bfd0 | 781 | // wxGenericDataViewModelNotifier |
f554a14b | 782 | // --------------------------------------------------------- |
a0f3af5f | 783 | |
aba9bfd0 | 784 | class wxGenericDataViewModelNotifier: public wxDataViewModelNotifier |
4ed7af08 | 785 | { |
a0f3af5f | 786 | public: |
aba9bfd0 | 787 | wxGenericDataViewModelNotifier( wxDataViewMainWindow *mainWindow ) |
a0f3af5f | 788 | { m_mainWindow = mainWindow; } |
f554a14b | 789 | |
aba9bfd0 RR |
790 | virtual bool ItemAdded( const wxDataViewItem & parent, const wxDataViewItem & item ) |
791 | { return m_mainWindow->ItemAdded( parent , item ); } | |
442c56e6 | 792 | virtual bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item ) |
071691a0 | 793 | { return m_mainWindow->ItemDeleted( parent, item ); } |
aba9bfd0 RR |
794 | virtual bool ItemChanged( const wxDataViewItem & item ) |
795 | { return m_mainWindow->ItemChanged(item); } | |
796 | virtual bool ValueChanged( const wxDataViewItem & item , unsigned int col ) | |
797 | { return m_mainWindow->ValueChanged( item, col ); } | |
a0f3af5f RR |
798 | virtual bool Cleared() |
799 | { return m_mainWindow->Cleared(); } | |
d3f00f59 | 800 | virtual void Resort() |
977a41ec | 801 | { m_mainWindow->Resort(); } |
f554a14b | 802 | |
a0f3af5f RR |
803 | wxDataViewMainWindow *m_mainWindow; |
804 | }; | |
4ed7af08 | 805 | |
f554a14b | 806 | // --------------------------------------------------------- |
baa9ebc4 | 807 | // wxDataViewRenderer |
f554a14b | 808 | // --------------------------------------------------------- |
4ed7af08 | 809 | |
baa9ebc4 | 810 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase) |
4ed7af08 | 811 | |
c741d33f | 812 | wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, |
9861f022 RR |
813 | wxDataViewCellMode mode, |
814 | int align) : | |
6eec70b9 | 815 | wxDataViewCustomRendererBase( varianttype, mode, align ) |
4ed7af08 | 816 | { |
9861f022 RR |
817 | m_align = align; |
818 | m_mode = mode; | |
c937bcac | 819 | m_ellipsizeMode = wxELLIPSIZE_MIDDLE; |
6eec70b9 | 820 | m_dc = NULL; |
4ed7af08 RR |
821 | } |
822 | ||
baa9ebc4 | 823 | wxDataViewRenderer::~wxDataViewRenderer() |
3d9d7cc4 | 824 | { |
6eec70b9 VZ |
825 | delete m_dc; |
826 | } | |
827 | ||
828 | wxDC *wxDataViewRenderer::GetDC() | |
829 | { | |
830 | if (m_dc == NULL) | |
831 | { | |
832 | if (GetOwner() == NULL) | |
833 | return NULL; | |
834 | if (GetOwner()->GetOwner() == NULL) | |
835 | return NULL; | |
836 | m_dc = new wxClientDC( GetOwner()->GetOwner() ); | |
837 | } | |
838 | ||
839 | return m_dc; | |
840 | } | |
841 | ||
842 | void wxDataViewRenderer::SetAlignment( int align ) | |
843 | { | |
844 | m_align=align; | |
845 | } | |
846 | ||
847 | int wxDataViewRenderer::GetAlignment() const | |
848 | { | |
849 | return m_align; | |
850 | } | |
851 | ||
6eec70b9 VZ |
852 | // --------------------------------------------------------- |
853 | // wxDataViewCustomRenderer | |
854 | // --------------------------------------------------------- | |
855 | ||
856 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer) | |
857 | ||
858 | wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype, | |
859 | wxDataViewCellMode mode, int align ) : | |
860 | wxDataViewRenderer( varianttype, mode, align ) | |
861 | { | |
862 | } | |
863 | ||
f554a14b | 864 | // --------------------------------------------------------- |
baa9ebc4 | 865 | // wxDataViewTextRenderer |
f554a14b | 866 | // --------------------------------------------------------- |
4ed7af08 | 867 | |
6eec70b9 | 868 | IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewRenderer) |
4ed7af08 | 869 | |
c741d33f | 870 | wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype, |
9861f022 | 871 | wxDataViewCellMode mode, int align ) : |
6eec70b9 | 872 | wxDataViewRenderer( varianttype, mode, align ) |
4ed7af08 RR |
873 | { |
874 | } | |
875 | ||
baa9ebc4 | 876 | bool wxDataViewTextRenderer::SetValue( const wxVariant &value ) |
4ed7af08 | 877 | { |
90675b95 | 878 | m_text = value.GetString(); |
f554a14b | 879 | |
90675b95 | 880 | return true; |
4ed7af08 RR |
881 | } |
882 | ||
9861f022 | 883 | bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) ) const |
4ed7af08 RR |
884 | { |
885 | return false; | |
886 | } | |
887 | ||
bc4f1ff2 | 888 | bool wxDataViewTextRenderer::HasEditorCtrl() const |
442c56e6 | 889 | { |
99d471a5 RR |
890 | return true; |
891 | } | |
892 | ||
64c70359 | 893 | wxWindow* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent, |
99d471a5 RR |
894 | wxRect labelRect, const wxVariant &value ) |
895 | { | |
0a807957 RR |
896 | wxTextCtrl* ctrl = new wxTextCtrl( parent, wxID_ANY, value, |
897 | wxPoint(labelRect.x,labelRect.y), | |
dd90475f VS |
898 | wxSize(labelRect.width,labelRect.height), |
899 | wxTE_PROCESS_ENTER ); | |
0a807957 RR |
900 | |
901 | // select the text in the control an place the cursor at the end | |
902 | ctrl->SetInsertionPointEnd(); | |
903 | ctrl->SelectAll(); | |
904 | ||
905 | return ctrl; | |
99d471a5 RR |
906 | } |
907 | ||
64c70359 | 908 | bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant &value ) |
99d471a5 RR |
909 | { |
910 | wxTextCtrl *text = (wxTextCtrl*) editor; | |
911 | value = text->GetValue(); | |
912 | return true; | |
913 | } | |
914 | ||
62265c2c | 915 | bool wxDataViewTextRenderer::Render(wxRect rect, wxDC *dc, int state) |
3d9d7cc4 | 916 | { |
62265c2c | 917 | RenderText(m_text, 0, rect, dc, state); |
90675b95 | 918 | return true; |
3d9d7cc4 RR |
919 | } |
920 | ||
9861f022 | 921 | wxSize wxDataViewTextRenderer::GetSize() const |
3d9d7cc4 | 922 | { |
87f0efe2 | 923 | if (!m_text.empty()) |
86755098 VS |
924 | return GetTextExtent(m_text); |
925 | else | |
926 | return wxSize(wxDVC_DEFAULT_RENDERER_SIZE,wxDVC_DEFAULT_RENDERER_SIZE); | |
3d9d7cc4 RR |
927 | } |
928 | ||
2586d4a1 | 929 | // --------------------------------------------------------- |
baa9ebc4 | 930 | // wxDataViewBitmapRenderer |
2586d4a1 RR |
931 | // --------------------------------------------------------- |
932 | ||
6eec70b9 | 933 | IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewRenderer) |
2586d4a1 | 934 | |
c741d33f | 935 | wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype, |
9861f022 | 936 | wxDataViewCellMode mode, int align ) : |
6eec70b9 | 937 | wxDataViewRenderer( varianttype, mode, align ) |
2586d4a1 RR |
938 | { |
939 | } | |
940 | ||
baa9ebc4 | 941 | bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value ) |
2586d4a1 RR |
942 | { |
943 | if (value.GetType() == wxT("wxBitmap")) | |
944 | m_bitmap << value; | |
945 | if (value.GetType() == wxT("wxIcon")) | |
946 | m_icon << value; | |
947 | ||
948 | return true; | |
949 | } | |
950 | ||
9861f022 | 951 | bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) ) const |
2586d4a1 RR |
952 | { |
953 | return false; | |
954 | } | |
955 | ||
baa9ebc4 | 956 | bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) ) |
2586d4a1 | 957 | { |
a1b806b9 | 958 | if (m_bitmap.IsOk()) |
2586d4a1 | 959 | dc->DrawBitmap( m_bitmap, cell.x, cell.y ); |
a1b806b9 | 960 | else if (m_icon.IsOk()) |
2586d4a1 RR |
961 | dc->DrawIcon( m_icon, cell.x, cell.y ); |
962 | ||
963 | return true; | |
964 | } | |
965 | ||
9861f022 | 966 | wxSize wxDataViewBitmapRenderer::GetSize() const |
2586d4a1 | 967 | { |
a1b806b9 | 968 | if (m_bitmap.IsOk()) |
2586d4a1 | 969 | return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() ); |
a1b806b9 | 970 | else if (m_icon.IsOk()) |
2586d4a1 RR |
971 | return wxSize( m_icon.GetWidth(), m_icon.GetHeight() ); |
972 | ||
ce468dc2 | 973 | return wxSize(wxDVC_DEFAULT_RENDERER_SIZE,wxDVC_DEFAULT_RENDERER_SIZE); |
2586d4a1 RR |
974 | } |
975 | ||
f554a14b | 976 | // --------------------------------------------------------- |
baa9ebc4 | 977 | // wxDataViewToggleRenderer |
f554a14b | 978 | // --------------------------------------------------------- |
4ed7af08 | 979 | |
6eec70b9 | 980 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer, wxDataViewRenderer) |
4ed7af08 | 981 | |
baa9ebc4 | 982 | wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype, |
9861f022 | 983 | wxDataViewCellMode mode, int align ) : |
6eec70b9 | 984 | wxDataViewRenderer( varianttype, mode, align ) |
4ed7af08 | 985 | { |
90675b95 | 986 | m_toggle = false; |
4ed7af08 RR |
987 | } |
988 | ||
baa9ebc4 | 989 | bool wxDataViewToggleRenderer::SetValue( const wxVariant &value ) |
4ed7af08 | 990 | { |
90675b95 | 991 | m_toggle = value.GetBool(); |
f554a14b | 992 | |
a8461d31 | 993 | return true; |
4ed7af08 RR |
994 | } |
995 | ||
9861f022 | 996 | bool wxDataViewToggleRenderer::GetValue( wxVariant &WXUNUSED(value) ) const |
4ed7af08 RR |
997 | { |
998 | return false; | |
999 | } | |
f554a14b | 1000 | |
baa9ebc4 | 1001 | bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) ) |
4ed7af08 | 1002 | { |
862d8041 | 1003 | int flags = 0; |
90675b95 | 1004 | if (m_toggle) |
862d8041 | 1005 | flags |= wxCONTROL_CHECKED; |
98f8e666 VZ |
1006 | if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE || |
1007 | GetEnabled() == false) | |
862d8041 RR |
1008 | flags |= wxCONTROL_DISABLED; |
1009 | ||
45a04dd3 VZ |
1010 | // Ensure that the check boxes always have at least the minimal required |
1011 | // size, otherwise DrawCheckBox() doesn't really work well. If this size is | |
1012 | // greater than the cell size, the checkbox will be truncated but this is a | |
1013 | // lesser evil. | |
1014 | wxSize size = cell.GetSize(); | |
1015 | size.IncTo(GetSize()); | |
1016 | cell.SetSize(size); | |
68d7680d | 1017 | |
90b903c2 | 1018 | wxRendererNative::Get().DrawCheckBox( |
862d8041 RR |
1019 | GetOwner()->GetOwner(), |
1020 | *dc, | |
de4bf0b3 | 1021 | cell, |
862d8041 | 1022 | flags ); |
f554a14b | 1023 | |
90675b95 | 1024 | return true; |
4ed7af08 RR |
1025 | } |
1026 | ||
dc73d7f5 VS |
1027 | bool wxDataViewToggleRenderer::WXActivateCell(const wxRect& WXUNUSED(cell), |
1028 | wxDataViewModel *model, | |
1029 | const wxDataViewItem& item, | |
1030 | unsigned int col, | |
1031 | const wxMouseEvent *mouseEvent) | |
0fdc2321 | 1032 | { |
dc73d7f5 | 1033 | if ( mouseEvent ) |
98f8e666 | 1034 | { |
dc73d7f5 VS |
1035 | // only react to clicks directly on the checkbox, not elsewhere in the same cell: |
1036 | if ( !wxRect(GetSize()).Contains(mouseEvent->GetPosition()) ) | |
1037 | return false; | |
98f8e666 | 1038 | } |
dbc3aec1 | 1039 | |
dc73d7f5 VS |
1040 | model->ChangeValue(!m_toggle, item, col); |
1041 | return true; | |
0fdc2321 RR |
1042 | } |
1043 | ||
9861f022 | 1044 | wxSize wxDataViewToggleRenderer::GetSize() const |
4ed7af08 | 1045 | { |
de4bf0b3 FM |
1046 | // the window parameter is not used by GetCheckBoxSize() so it's |
1047 | // safe to pass NULL | |
1048 | return wxRendererNative::Get().GetCheckBoxSize(NULL); | |
4ed7af08 RR |
1049 | } |
1050 | ||
f554a14b | 1051 | // --------------------------------------------------------- |
baa9ebc4 | 1052 | // wxDataViewProgressRenderer |
f554a14b | 1053 | // --------------------------------------------------------- |
4ed7af08 | 1054 | |
6eec70b9 | 1055 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer, wxDataViewRenderer) |
4ed7af08 | 1056 | |
baa9ebc4 | 1057 | wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label, |
9861f022 | 1058 | const wxString &varianttype, wxDataViewCellMode mode, int align ) : |
6eec70b9 | 1059 | wxDataViewRenderer( varianttype, mode, align ) |
4ed7af08 RR |
1060 | { |
1061 | m_label = label; | |
1062 | m_value = 0; | |
1063 | } | |
1064 | ||
baa9ebc4 | 1065 | bool wxDataViewProgressRenderer::SetValue( const wxVariant &value ) |
4ed7af08 RR |
1066 | { |
1067 | m_value = (long) value; | |
f554a14b | 1068 | |
4ed7af08 RR |
1069 | if (m_value < 0) m_value = 0; |
1070 | if (m_value > 100) m_value = 100; | |
f554a14b | 1071 | |
4ed7af08 RR |
1072 | return true; |
1073 | } | |
f554a14b | 1074 | |
9861f022 RR |
1075 | bool wxDataViewProgressRenderer::GetValue( wxVariant &value ) const |
1076 | { | |
1077 | value = (long) m_value; | |
1078 | return true; | |
1079 | } | |
1080 | ||
62265c2c VZ |
1081 | bool |
1082 | wxDataViewProgressRenderer::Render(wxRect rect, wxDC *dc, int WXUNUSED(state)) | |
4ed7af08 | 1083 | { |
62265c2c | 1084 | // deflate the rect to leave a small border between bars in adjacent rows |
3e60a3c1 VZ |
1085 | wxRect bar = rect.Deflate(0, 1); |
1086 | ||
62265c2c VZ |
1087 | dc->SetBrush( *wxTRANSPARENT_BRUSH ); |
1088 | dc->SetPen( *wxBLACK_PEN ); | |
1089 | dc->DrawRectangle( bar ); | |
4ed7af08 | 1090 | |
3e60a3c1 | 1091 | bar.width = (int)(bar.width * m_value / 100.); |
62265c2c VZ |
1092 | dc->SetPen( *wxTRANSPARENT_PEN ); |
1093 | ||
1094 | const wxDataViewItemAttr& attr = GetAttr(); | |
1095 | dc->SetBrush( attr.HasColour() ? wxBrush(attr.GetColour()) | |
1096 | : *wxBLUE_BRUSH ); | |
1097 | dc->DrawRectangle( bar ); | |
f554a14b | 1098 | |
4ed7af08 RR |
1099 | return true; |
1100 | } | |
1101 | ||
9861f022 | 1102 | wxSize wxDataViewProgressRenderer::GetSize() const |
4ed7af08 RR |
1103 | { |
1104 | return wxSize(40,12); | |
1105 | } | |
f554a14b | 1106 | |
b7fe2261 | 1107 | // --------------------------------------------------------- |
24c4a50f | 1108 | // wxDataViewIconTextRenderer |
b7fe2261 | 1109 | // --------------------------------------------------------- |
24c4a50f | 1110 | |
6eec70b9 | 1111 | IMPLEMENT_CLASS(wxDataViewIconTextRenderer, wxDataViewRenderer) |
24c4a50f | 1112 | |
b7fe2261 | 1113 | wxDataViewIconTextRenderer::wxDataViewIconTextRenderer( |
977a41ec | 1114 | const wxString &varianttype, wxDataViewCellMode mode, int align ) : |
6eec70b9 | 1115 | wxDataViewRenderer( varianttype, mode, align ) |
24c4a50f RR |
1116 | { |
1117 | SetMode(mode); | |
1118 | SetAlignment(align); | |
1119 | } | |
1120 | ||
24c4a50f RR |
1121 | bool wxDataViewIconTextRenderer::SetValue( const wxVariant &value ) |
1122 | { | |
1123 | m_value << value; | |
1124 | return true; | |
1125 | } | |
1126 | ||
b5ec7dd6 | 1127 | bool wxDataViewIconTextRenderer::GetValue( wxVariant& WXUNUSED(value) ) const |
24c4a50f RR |
1128 | { |
1129 | return false; | |
1130 | } | |
b7fe2261 | 1131 | |
62265c2c | 1132 | bool wxDataViewIconTextRenderer::Render(wxRect rect, wxDC *dc, int state) |
24c4a50f | 1133 | { |
52e750fc | 1134 | int xoffset = 0; |
38c34918 VZ |
1135 | |
1136 | const wxIcon& icon = m_value.GetIcon(); | |
1137 | if ( icon.IsOk() ) | |
24c4a50f | 1138 | { |
62265c2c | 1139 | dc->DrawIcon(icon, rect.x, rect.y + (rect.height - icon.GetHeight())/2); |
38c34918 | 1140 | xoffset = icon.GetWidth()+4; |
24c4a50f | 1141 | } |
b5ec7dd6 | 1142 | |
62265c2c | 1143 | RenderText(m_value.GetText(), xoffset, rect, dc, state); |
24c4a50f RR |
1144 | |
1145 | return true; | |
1146 | } | |
1147 | ||
1148 | wxSize wxDataViewIconTextRenderer::GetSize() const | |
1149 | { | |
e44ac7bc RR |
1150 | if (!m_value.GetText().empty()) |
1151 | { | |
86755098 | 1152 | wxSize size = GetTextExtent(m_value.GetText()); |
b5ec7dd6 | 1153 | |
e44ac7bc | 1154 | if (m_value.GetIcon().IsOk()) |
86755098 VS |
1155 | size.x += m_value.GetIcon().GetWidth() + 4; |
1156 | return size; | |
e44ac7bc RR |
1157 | } |
1158 | return wxSize(80,20); | |
24c4a50f RR |
1159 | } |
1160 | ||
64c70359 | 1161 | wxWindow* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow *parent, wxRect labelRect, const wxVariant& value) |
24c4a50f | 1162 | { |
c937344c RR |
1163 | wxDataViewIconText iconText; |
1164 | iconText << value; | |
1165 | ||
1166 | wxString text = iconText.GetText(); | |
1167 | ||
1168 | // adjust the label rect to take the width of the icon into account | |
1169 | if (iconText.GetIcon().IsOk()) | |
1170 | { | |
1171 | int w = iconText.GetIcon().GetWidth() + 4; | |
1172 | labelRect.x += w; | |
1173 | labelRect.width -= w; | |
1174 | } | |
1175 | ||
0a807957 RR |
1176 | wxTextCtrl* ctrl = new wxTextCtrl( parent, wxID_ANY, text, |
1177 | wxPoint(labelRect.x,labelRect.y), | |
dd90475f VS |
1178 | wxSize(labelRect.width,labelRect.height), |
1179 | wxTE_PROCESS_ENTER ); | |
0a807957 RR |
1180 | |
1181 | // select the text in the control an place the cursor at the end | |
1182 | ctrl->SetInsertionPointEnd(); | |
1183 | ctrl->SelectAll(); | |
1184 | ||
1185 | return ctrl; | |
24c4a50f RR |
1186 | } |
1187 | ||
64c70359 | 1188 | bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxWindow *editor, wxVariant& value ) |
24c4a50f | 1189 | { |
c937344c RR |
1190 | wxTextCtrl *text = (wxTextCtrl*) editor; |
1191 | ||
cdacccae VZ |
1192 | // The icon can't be edited so get its old value and reuse it. |
1193 | wxVariant valueOld; | |
1194 | wxDataViewColumn* const col = GetOwner(); | |
1195 | GetView()->GetModel()->GetValue(valueOld, m_item, col->GetModelColumn()); | |
1196 | ||
1197 | wxDataViewIconText iconText; | |
1198 | iconText << valueOld; | |
1199 | ||
1200 | // But replace the text with the value entered by user. | |
1201 | iconText.SetText(text->GetValue()); | |
1202 | ||
c937344c RR |
1203 | value << iconText; |
1204 | return true; | |
24c4a50f RR |
1205 | } |
1206 | ||
a653c966 RR |
1207 | //----------------------------------------------------------------------------- |
1208 | // wxDataViewDropTarget | |
1209 | //----------------------------------------------------------------------------- | |
1210 | ||
9adeb77a VZ |
1211 | #if wxUSE_DRAG_AND_DROP |
1212 | ||
818d91a9 RR |
1213 | class wxBitmapCanvas: public wxWindow |
1214 | { | |
1215 | public: | |
1216 | wxBitmapCanvas( wxWindow *parent, const wxBitmap &bitmap, const wxSize &size ) : | |
977a41ec | 1217 | wxWindow( parent, wxID_ANY, wxPoint(0,0), size ) |
818d91a9 RR |
1218 | { |
1219 | m_bitmap = bitmap; | |
1220 | Connect( wxEVT_PAINT, wxPaintEventHandler(wxBitmapCanvas::OnPaint) ); | |
1221 | } | |
9adeb77a | 1222 | |
818d91a9 RR |
1223 | void OnPaint( wxPaintEvent &WXUNUSED(event) ) |
1224 | { | |
1225 | wxPaintDC dc(this); | |
1226 | dc.DrawBitmap( m_bitmap, 0, 0); | |
1227 | } | |
9adeb77a | 1228 | |
818d91a9 RR |
1229 | wxBitmap m_bitmap; |
1230 | }; | |
1231 | ||
1232 | class wxDataViewDropSource: public wxDropSource | |
1233 | { | |
1234 | public: | |
1235 | wxDataViewDropSource( wxDataViewMainWindow *win, unsigned int row ) : | |
977a41ec | 1236 | wxDropSource( win ) |
818d91a9 RR |
1237 | { |
1238 | m_win = win; | |
1239 | m_row = row; | |
1240 | m_hint = NULL; | |
1241 | } | |
9adeb77a | 1242 | |
818d91a9 RR |
1243 | ~wxDataViewDropSource() |
1244 | { | |
1245 | delete m_hint; | |
1246 | } | |
9adeb77a | 1247 | |
818d91a9 RR |
1248 | virtual bool GiveFeedback( wxDragResult WXUNUSED(effect) ) |
1249 | { | |
1250 | wxPoint pos = wxGetMousePosition(); | |
9adeb77a | 1251 | |
818d91a9 RR |
1252 | if (!m_hint) |
1253 | { | |
1254 | int liney = m_win->GetLineStart( m_row ); | |
1255 | int linex = 0; | |
1256 | m_win->GetOwner()->CalcUnscrolledPosition( 0, liney, NULL, &liney ); | |
1257 | m_win->ClientToScreen( &linex, &liney ); | |
1258 | m_dist_x = pos.x - linex; | |
1259 | m_dist_y = pos.y - liney; | |
9adeb77a | 1260 | |
818d91a9 RR |
1261 | int indent = 0; |
1262 | wxBitmap ib = m_win->CreateItemBitmap( m_row, indent ); | |
1263 | m_dist_x -= indent; | |
9adeb77a | 1264 | m_hint = new wxFrame( m_win->GetParent(), wxID_ANY, wxEmptyString, |
977a41ec FM |
1265 | wxPoint(pos.x - m_dist_x, pos.y + 5 ), |
1266 | ib.GetSize(), | |
1267 | wxFRAME_TOOL_WINDOW | | |
1268 | wxFRAME_FLOAT_ON_PARENT | | |
1269 | wxFRAME_NO_TASKBAR | | |
1270 | wxNO_BORDER ); | |
818d91a9 RR |
1271 | new wxBitmapCanvas( m_hint, ib, ib.GetSize() ); |
1272 | m_hint->Show(); | |
1273 | } | |
1274 | else | |
1275 | { | |
1276 | m_hint->Move( pos.x - m_dist_x, pos.y + 5 ); | |
1277 | m_hint->SetTransparent( 128 ); | |
1278 | } | |
9adeb77a | 1279 | |
818d91a9 RR |
1280 | return false; |
1281 | } | |
9adeb77a | 1282 | |
818d91a9 RR |
1283 | wxDataViewMainWindow *m_win; |
1284 | unsigned int m_row; | |
1285 | wxFrame *m_hint; | |
1286 | int m_dist_x,m_dist_y; | |
1287 | }; | |
1288 | ||
1289 | ||
a653c966 RR |
1290 | class wxDataViewDropTarget: public wxDropTarget |
1291 | { | |
1292 | public: | |
1293 | wxDataViewDropTarget( wxDataObject *obj, wxDataViewMainWindow *win ) : | |
1294 | wxDropTarget( obj ) | |
1295 | { | |
1296 | m_win = win; | |
1297 | } | |
1298 | ||
1299 | virtual wxDragResult OnDragOver( wxCoord x, wxCoord y, wxDragResult def ) | |
ce468dc2 | 1300 | { |
977a41ec FM |
1301 | wxDataFormat format = GetMatchingPair(); |
1302 | if (format == wxDF_INVALID) | |
1303 | return wxDragNone; | |
1304 | return m_win->OnDragOver( format, x, y, def); | |
ce468dc2 | 1305 | } |
9adeb77a | 1306 | |
a653c966 | 1307 | virtual bool OnDrop( wxCoord x, wxCoord y ) |
ce468dc2 | 1308 | { |
977a41ec FM |
1309 | wxDataFormat format = GetMatchingPair(); |
1310 | if (format == wxDF_INVALID) | |
1311 | return false; | |
1312 | return m_win->OnDrop( format, x, y ); | |
ce468dc2 | 1313 | } |
9adeb77a | 1314 | |
a653c966 | 1315 | virtual wxDragResult OnData( wxCoord x, wxCoord y, wxDragResult def ) |
ce468dc2 | 1316 | { |
977a41ec FM |
1317 | wxDataFormat format = GetMatchingPair(); |
1318 | if (format == wxDF_INVALID) | |
1319 | return wxDragNone; | |
1320 | if (!GetData()) | |
1321 | return wxDragNone; | |
1322 | return m_win->OnData( format, x, y, def ); | |
ce468dc2 | 1323 | } |
9adeb77a | 1324 | |
a653c966 RR |
1325 | virtual void OnLeave() |
1326 | { m_win->OnLeave(); } | |
1327 | ||
1328 | wxDataViewMainWindow *m_win; | |
1329 | }; | |
1330 | ||
9adeb77a VZ |
1331 | #endif // wxUSE_DRAG_AND_DROP |
1332 | ||
0fcce6b9 RR |
1333 | //----------------------------------------------------------------------------- |
1334 | // wxDataViewRenameTimer | |
1335 | //----------------------------------------------------------------------------- | |
1336 | ||
1337 | wxDataViewRenameTimer::wxDataViewRenameTimer( wxDataViewMainWindow *owner ) | |
1338 | { | |
1339 | m_owner = owner; | |
1340 | } | |
1341 | ||
1342 | void wxDataViewRenameTimer::Notify() | |
1343 | { | |
1344 | m_owner->OnRenameTimer(); | |
1345 | } | |
1346 | ||
4ed7af08 RR |
1347 | //----------------------------------------------------------------------------- |
1348 | // wxDataViewMainWindow | |
1349 | //----------------------------------------------------------------------------- | |
1350 | ||
bc4f1ff2 | 1351 | // The tree building helper, declared firstly |
10875c13 | 1352 | static void BuildTreeHelper( const wxDataViewModel * model, const wxDataViewItem & item, |
bc4f1ff2 | 1353 | wxDataViewTreeNode * node); |
704c3490 | 1354 | |
0a71f9e9 | 1355 | int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 ) |
cab07038 RR |
1356 | { |
1357 | if (row1 > row2) return 1; | |
1358 | if (row1 == row2) return 0; | |
1359 | return -1; | |
1360 | } | |
1361 | ||
45778c96 | 1362 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow) |
4ed7af08 RR |
1363 | |
1364 | BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow) | |
1365 | EVT_PAINT (wxDataViewMainWindow::OnPaint) | |
1366 | EVT_MOUSE_EVENTS (wxDataViewMainWindow::OnMouse) | |
1367 | EVT_SET_FOCUS (wxDataViewMainWindow::OnSetFocus) | |
cab07038 | 1368 | EVT_KILL_FOCUS (wxDataViewMainWindow::OnKillFocus) |
64ac3db8 | 1369 | EVT_CHAR_HOOK (wxDataViewMainWindow::OnCharHook) |
cab07038 | 1370 | EVT_CHAR (wxDataViewMainWindow::OnChar) |
4ed7af08 RR |
1371 | END_EVENT_TABLE() |
1372 | ||
1373 | wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id, | |
1374 | const wxPoint &pos, const wxSize &size, const wxString &name ) : | |
d81ad1f0 | 1375 | wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE, name ), |
cab07038 | 1376 | m_selection( wxDataViewSelectionCmp ) |
120b9b05 | 1377 | |
4ed7af08 RR |
1378 | { |
1379 | SetOwner( parent ); | |
f554a14b | 1380 | |
64ac3db8 VZ |
1381 | m_editorRenderer = NULL; |
1382 | ||
0fcce6b9 RR |
1383 | m_lastOnSame = false; |
1384 | m_renameTimer = new wxDataViewRenameTimer( this ); | |
120b9b05 | 1385 | |
0fcce6b9 RR |
1386 | // TODO: user better initial values/nothing selected |
1387 | m_currentCol = NULL; | |
1c8e71c9 VS |
1388 | m_currentColSetByKeyboard = false; |
1389 | m_useCellFocus = false; | |
0fcce6b9 RR |
1390 | m_currentRow = 0; |
1391 | ||
eb7df491 VS |
1392 | #ifdef __WXMSW__ |
1393 | // We would like to use the same line height that Explorer uses. This is | |
1394 | // different from standard ListView control since Vista. | |
1395 | if ( wxGetWinVersion() >= wxWinVersion_Vista ) | |
1396 | m_lineHeight = wxMax(16, GetCharHeight()) + 6; // 16 = mini icon height | |
1397 | else | |
1398 | #endif // __WXMSW__ | |
1399 | m_lineHeight = wxMax(16, GetCharHeight()) + 1; // 16 = mini icon height | |
e21f75bd | 1400 | |
9adeb77a | 1401 | #if wxUSE_DRAG_AND_DROP |
e21f75bd RR |
1402 | m_dragCount = 0; |
1403 | m_dragStart = wxPoint(0,0); | |
120b9b05 | 1404 | |
821baf7d RR |
1405 | m_dragEnabled = false; |
1406 | m_dropEnabled = false; | |
9deec111 RR |
1407 | m_dropHint = false; |
1408 | m_dropHintLine = (unsigned int) -1; | |
9adeb77a VZ |
1409 | #endif // wxUSE_DRAG_AND_DROP |
1410 | ||
1411 | m_lineLastClicked = (unsigned int) -1; | |
1412 | m_lineBeforeLastClicked = (unsigned int) -1; | |
1413 | m_lineSelectSingleOnUp = (unsigned int) -1; | |
821baf7d | 1414 | |
cab07038 | 1415 | m_hasFocus = false; |
f554a14b | 1416 | |
72664514 RR |
1417 | SetBackgroundColour( *wxWHITE ); |
1418 | ||
cfa42cb8 JS |
1419 | SetBackgroundStyle(wxBG_STYLE_CUSTOM); |
1420 | ||
069b2e59 | 1421 | m_penRule = wxPen(GetRuleColour()); |
9861f022 | 1422 | |
bc4f1ff2 FM |
1423 | // compose a pen whichcan draw black lines |
1424 | // TODO: maybe there is something system colour to use | |
069b2e59 | 1425 | m_penExpander = wxPen(wxColour(0,0,0)); |
bc4f1ff2 | 1426 | |
422aa8ec | 1427 | m_root = wxDataViewTreeNode::CreateRootNode(); |
704c3490 | 1428 | |
bc4f1ff2 | 1429 | // Make m_count = -1 will cause the class recaculate the real displaying number of rows. |
59e60167 | 1430 | m_count = -1; |
24c4a50f | 1431 | m_underMouse = NULL; |
4b3feaa7 | 1432 | UpdateDisplay(); |
4ed7af08 RR |
1433 | } |
1434 | ||
1435 | wxDataViewMainWindow::~wxDataViewMainWindow() | |
1436 | { | |
aba9bfd0 | 1437 | DestroyTree(); |
0fcce6b9 RR |
1438 | delete m_renameTimer; |
1439 | } | |
1440 | ||
9adeb77a VZ |
1441 | |
1442 | #if wxUSE_DRAG_AND_DROP | |
a653c966 RR |
1443 | bool wxDataViewMainWindow::EnableDragSource( const wxDataFormat &format ) |
1444 | { | |
1445 | m_dragFormat = format; | |
1446 | m_dragEnabled = format != wxDF_INVALID; | |
9adeb77a | 1447 | |
a653c966 RR |
1448 | return true; |
1449 | } | |
9adeb77a | 1450 | |
a653c966 RR |
1451 | bool wxDataViewMainWindow::EnableDropTarget( const wxDataFormat &format ) |
1452 | { | |
1453 | m_dropFormat = format; | |
1454 | m_dropEnabled = format != wxDF_INVALID; | |
9adeb77a | 1455 | |
a653c966 RR |
1456 | if (m_dropEnabled) |
1457 | SetDropTarget( new wxDataViewDropTarget( new wxCustomDataObject( format ), this ) ); | |
9adeb77a | 1458 | |
a653c966 RR |
1459 | return true; |
1460 | } | |
1461 | ||
9deec111 RR |
1462 | void wxDataViewMainWindow::RemoveDropHint() |
1463 | { | |
1464 | if (m_dropHint) | |
1465 | { | |
1466 | m_dropHint = false; | |
1467 | RefreshRow( m_dropHintLine ); | |
1468 | m_dropHintLine = (unsigned int) -1; | |
1469 | } | |
1470 | } | |
1471 | ||
4cef3873 | 1472 | wxDragResult wxDataViewMainWindow::OnDragOver( wxDataFormat format, wxCoord x, |
bc4f1ff2 | 1473 | wxCoord y, wxDragResult def ) |
a653c966 RR |
1474 | { |
1475 | int xx = x; | |
1476 | int yy = y; | |
1477 | m_owner->CalcUnscrolledPosition( xx, yy, &xx, &yy ); | |
1478 | unsigned int row = GetLineAt( yy ); | |
1479 | ||
aecf930c | 1480 | if ((row >= GetRowCount()) || (xx > GetEndOfLastCol())) |
9adeb77a | 1481 | { |
9deec111 | 1482 | RemoveDropHint(); |
a653c966 | 1483 | return wxDragNone; |
9deec111 | 1484 | } |
a653c966 RR |
1485 | |
1486 | wxDataViewItem item = GetItemByRow( row ); | |
9adeb77a | 1487 | |
c2c89730 | 1488 | wxDataViewModel *model = GetModel(); |
9adeb77a | 1489 | |
a653c966 RR |
1490 | wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() ); |
1491 | event.SetEventObject( m_owner ); | |
1492 | event.SetItem( item ); | |
1493 | event.SetModel( model ); | |
1494 | event.SetDataFormat( format ); | |
c04be1a2 | 1495 | event.SetDropEffect( def ); |
a653c966 | 1496 | if (!m_owner->HandleWindowEvent( event )) |
9deec111 RR |
1497 | { |
1498 | RemoveDropHint(); | |
a653c966 | 1499 | return wxDragNone; |
9deec111 | 1500 | } |
a653c966 RR |
1501 | |
1502 | if (!event.IsAllowed()) | |
9deec111 RR |
1503 | { |
1504 | RemoveDropHint(); | |
a653c966 | 1505 | return wxDragNone; |
9deec111 RR |
1506 | } |
1507 | ||
9adeb77a | 1508 | |
9deec111 RR |
1509 | if (m_dropHint && (row != m_dropHintLine)) |
1510 | RefreshRow( m_dropHintLine ); | |
1511 | m_dropHint = true; | |
1512 | m_dropHintLine = row; | |
1513 | RefreshRow( row ); | |
9adeb77a | 1514 | |
a653c966 RR |
1515 | return def; |
1516 | } | |
1517 | ||
1518 | bool wxDataViewMainWindow::OnDrop( wxDataFormat format, wxCoord x, wxCoord y ) | |
1519 | { | |
9deec111 RR |
1520 | RemoveDropHint(); |
1521 | ||
a653c966 RR |
1522 | int xx = x; |
1523 | int yy = y; | |
1524 | m_owner->CalcUnscrolledPosition( xx, yy, &xx, &yy ); | |
1525 | unsigned int row = GetLineAt( yy ); | |
1526 | ||
aecf930c | 1527 | if ((row >= GetRowCount()) || (xx > GetEndOfLastCol())) |
a653c966 RR |
1528 | return false; |
1529 | ||
1530 | wxDataViewItem item = GetItemByRow( row ); | |
9adeb77a | 1531 | |
c2c89730 | 1532 | wxDataViewModel *model = GetModel(); |
9adeb77a | 1533 | |
a653c966 RR |
1534 | wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE, m_owner->GetId() ); |
1535 | event.SetEventObject( m_owner ); | |
1536 | event.SetItem( item ); | |
1537 | event.SetModel( model ); | |
1538 | event.SetDataFormat( format ); | |
1539 | if (!m_owner->HandleWindowEvent( event )) | |
1540 | return false; | |
1541 | ||
1542 | if (!event.IsAllowed()) | |
1543 | return false; | |
9deec111 | 1544 | |
a653c966 RR |
1545 | return true; |
1546 | } | |
1547 | ||
4cef3873 | 1548 | wxDragResult wxDataViewMainWindow::OnData( wxDataFormat format, wxCoord x, wxCoord y, |
bc4f1ff2 | 1549 | wxDragResult def ) |
a653c966 RR |
1550 | { |
1551 | int xx = x; | |
1552 | int yy = y; | |
1553 | m_owner->CalcUnscrolledPosition( xx, yy, &xx, &yy ); | |
1554 | unsigned int row = GetLineAt( yy ); | |
1555 | ||
aecf930c | 1556 | if ((row >= GetRowCount()) || (xx > GetEndOfLastCol())) |
a653c966 RR |
1557 | return wxDragNone; |
1558 | ||
1559 | wxDataViewItem item = GetItemByRow( row ); | |
9adeb77a | 1560 | |
c2c89730 | 1561 | wxDataViewModel *model = GetModel(); |
9adeb77a | 1562 | |
a653c966 RR |
1563 | wxCustomDataObject *obj = (wxCustomDataObject *) GetDropTarget()->GetDataObject(); |
1564 | ||
1565 | wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP, m_owner->GetId() ); | |
1566 | event.SetEventObject( m_owner ); | |
1567 | event.SetItem( item ); | |
1568 | event.SetModel( model ); | |
1569 | event.SetDataFormat( format ); | |
1570 | event.SetDataSize( obj->GetSize() ); | |
1571 | event.SetDataBuffer( obj->GetData() ); | |
c04be1a2 | 1572 | event.SetDropEffect( def ); |
a653c966 RR |
1573 | if (!m_owner->HandleWindowEvent( event )) |
1574 | return wxDragNone; | |
1575 | ||
1576 | if (!event.IsAllowed()) | |
1577 | return wxDragNone; | |
1578 | ||
1579 | return def; | |
1580 | } | |
1581 | ||
1582 | void wxDataViewMainWindow::OnLeave() | |
1583 | { | |
9deec111 | 1584 | RemoveDropHint(); |
a653c966 RR |
1585 | } |
1586 | ||
818d91a9 RR |
1587 | wxBitmap wxDataViewMainWindow::CreateItemBitmap( unsigned int row, int &indent ) |
1588 | { | |
1589 | int height = GetLineHeight( row ); | |
1590 | int width = 0; | |
1591 | unsigned int cols = GetOwner()->GetColumnCount(); | |
1592 | unsigned int col; | |
1593 | for (col = 0; col < cols; col++) | |
1594 | { | |
1595 | wxDataViewColumn *column = GetOwner()->GetColumnAt(col); | |
1596 | if (column->IsHidden()) | |
1597 | continue; // skip it! | |
1598 | width += column->GetWidth(); | |
1599 | } | |
1600 | ||
1601 | indent = 0; | |
ce5abbf9 | 1602 | if (!IsList()) |
818d91a9 RR |
1603 | { |
1604 | wxDataViewTreeNode *node = GetTreeNodeByRow(row); | |
1605 | indent = GetOwner()->GetIndent() * node->GetIndentLevel(); | |
4cef3873 | 1606 | indent = indent + m_lineHeight; |
bc4f1ff2 | 1607 | // try to use the m_lineHeight as the expander space |
818d91a9 RR |
1608 | } |
1609 | width -= indent; | |
1610 | ||
1611 | wxBitmap bitmap( width, height ); | |
1612 | wxMemoryDC dc( bitmap ); | |
1613 | dc.SetFont( GetFont() ); | |
1614 | dc.SetPen( *wxBLACK_PEN ); | |
1615 | dc.SetBrush( *wxWHITE_BRUSH ); | |
1616 | dc.DrawRectangle( 0,0,width,height ); | |
9adeb77a | 1617 | |
818d91a9 | 1618 | wxDataViewModel *model = m_owner->GetModel(); |
9adeb77a | 1619 | |
1841f079 VZ |
1620 | wxDataViewColumn * const |
1621 | expander = GetExpanderColumnOrFirstOne(GetOwner()); | |
9adeb77a | 1622 | |
818d91a9 RR |
1623 | int x = 0; |
1624 | for (col = 0; col < cols; col++) | |
1625 | { | |
1626 | wxDataViewColumn *column = GetOwner()->GetColumnAt( col ); | |
1627 | wxDataViewRenderer *cell = column->GetRenderer(); | |
1628 | ||
1629 | if (column->IsHidden()) | |
1630 | continue; // skip it! | |
1631 | ||
1632 | width = column->GetWidth(); | |
9adeb77a | 1633 | |
818d91a9 RR |
1634 | if (column == expander) |
1635 | width -= indent; | |
9adeb77a | 1636 | |
818d91a9 | 1637 | wxDataViewItem item = GetItemByRow( row ); |
f0ccd2cb | 1638 | cell->PrepareForItem(model, item, column->GetModelColumn()); |
62265c2c | 1639 | |
a6f1201f VZ |
1640 | wxRect item_rect(x, 0, width, height); |
1641 | item_rect.Deflate(PADDING_RIGHTLEFT, 0); | |
818d91a9 | 1642 | |
bc4f1ff2 | 1643 | // dc.SetClippingRegion( item_rect ); |
62265c2c | 1644 | cell->WXCallRender(item_rect, &dc, 0); |
bc4f1ff2 | 1645 | // dc.DestroyClippingRegion(); |
9adeb77a | 1646 | |
818d91a9 RR |
1647 | x += width; |
1648 | } | |
9adeb77a | 1649 | |
818d91a9 RR |
1650 | return bitmap; |
1651 | } | |
1652 | ||
9adeb77a VZ |
1653 | #endif // wxUSE_DRAG_AND_DROP |
1654 | ||
1655 | ||
1c8e71c9 VS |
1656 | // Draw focus rect for individual cell. Unlike native focus rect, we render |
1657 | // this in foreground text color (typically white) to enhance contrast and | |
1658 | // make it visible. | |
1659 | static void DrawSelectedCellFocusRect(wxDC& dc, const wxRect& rect) | |
1660 | { | |
1661 | // (This code is based on wxRendererGeneric::DrawFocusRect and modified.) | |
1662 | ||
1663 | // draw the pixels manually because the "dots" in wxPen with wxDOT style | |
1664 | // may be short traits and not really dots | |
1665 | // | |
1666 | // note that to behave in the same manner as DrawRect(), we must exclude | |
1667 | // the bottom and right borders from the rectangle | |
1668 | wxCoord x1 = rect.GetLeft(), | |
1669 | y1 = rect.GetTop(), | |
1670 | x2 = rect.GetRight(), | |
1671 | y2 = rect.GetBottom(); | |
1672 | ||
1673 | wxDCPenChanger pen(dc, wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT)); | |
1674 | ||
1675 | wxCoord z; | |
1676 | for ( z = x1 + 1; z < x2; z += 2 ) | |
1677 | dc.DrawPoint(z, rect.GetTop()); | |
1678 | ||
1679 | wxCoord shift = z == x2 ? 0 : 1; | |
1680 | for ( z = y1 + shift; z < y2; z += 2 ) | |
1681 | dc.DrawPoint(x2, z); | |
1682 | ||
1683 | shift = z == y2 ? 0 : 1; | |
1684 | for ( z = x2 - shift; z > x1; z -= 2 ) | |
1685 | dc.DrawPoint(z, y2); | |
1686 | ||
1687 | shift = z == x1 ? 0 : 1; | |
1688 | for ( z = y2 - shift; z > y1; z -= 2 ) | |
1689 | dc.DrawPoint(x1, z); | |
1690 | } | |
1691 | ||
1692 | ||
1117d56f | 1693 | void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) ) |
0fcce6b9 | 1694 | { |
c2c89730 | 1695 | wxDataViewModel *model = GetModel(); |
1117d56f | 1696 | wxAutoBufferedPaintDC dc( this ); |
0fcce6b9 | 1697 | |
1117d56f | 1698 | #ifdef __WXMSW__ |
bb58fa37 | 1699 | dc.SetBrush(GetOwner()->GetBackgroundColour()); |
1117d56f | 1700 | dc.SetPen( *wxTRANSPARENT_PEN ); |
bb58fa37 | 1701 | dc.DrawRectangle(GetClientSize()); |
1117d56f RR |
1702 | #endif |
1703 | ||
da87ce5a VZ |
1704 | if ( IsEmpty() ) |
1705 | { | |
1706 | // No items to draw. | |
1707 | return; | |
1708 | } | |
1709 | ||
1117d56f RR |
1710 | // prepare the DC |
1711 | GetOwner()->PrepareDC( dc ); | |
1712 | dc.SetFont( GetFont() ); | |
1713 | ||
1714 | wxRect update = GetUpdateRegion().GetBox(); | |
1715 | m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y ); | |
1716 | ||
1717 | // compute which items needs to be redrawn | |
344ed1f3 | 1718 | unsigned int item_start = GetLineAt( wxMax(0,update.y) ); |
1117d56f | 1719 | unsigned int item_count = |
344ed1f3 | 1720 | wxMin( (int)( GetLineAt( wxMax(0,update.y+update.height) ) - item_start + 1), |
977a41ec | 1721 | (int)(GetRowCount( ) - item_start)); |
1117d56f | 1722 | unsigned int item_last = item_start + item_count; |
99f44d97 VZ |
1723 | |
1724 | // Send the event to wxDataViewCtrl itself. | |
1725 | wxWindow * const parent = GetParent(); | |
47a8b1e1 | 1726 | wxDataViewEvent cache_event(wxEVT_COMMAND_DATAVIEW_CACHE_HINT, parent->GetId()); |
99f44d97 | 1727 | cache_event.SetEventObject(parent); |
47a8b1e1 VZ |
1728 | cache_event.SetCache(item_start, item_last - 1); |
1729 | parent->ProcessWindowEvent(cache_event); | |
1117d56f RR |
1730 | |
1731 | // compute which columns needs to be redrawn | |
9861f022 | 1732 | unsigned int cols = GetOwner()->GetColumnCount(); |
f03c22f9 VZ |
1733 | if ( !cols ) |
1734 | { | |
1735 | // we assume that we have at least one column below and painting an | |
1736 | // empty control is unnecessary anyhow | |
1737 | return; | |
1738 | } | |
1739 | ||
1117d56f | 1740 | unsigned int col_start = 0; |
e822d1bd | 1741 | unsigned int x_start; |
1117d56f | 1742 | for (x_start = 0; col_start < cols; col_start++) |
0fcce6b9 | 1743 | { |
702f5349 | 1744 | wxDataViewColumn *col = GetOwner()->GetColumnAt(col_start); |
1117d56f | 1745 | if (col->IsHidden()) |
9861f022 RR |
1746 | continue; // skip it! |
1747 | ||
1117d56f RR |
1748 | unsigned int w = col->GetWidth(); |
1749 | if (x_start+w >= (unsigned int)update.x) | |
0fcce6b9 | 1750 | break; |
0fcce6b9 | 1751 | |
1117d56f RR |
1752 | x_start += w; |
1753 | } | |
1e510b1e | 1754 | |
1117d56f RR |
1755 | unsigned int col_last = col_start; |
1756 | unsigned int x_last = x_start; | |
1757 | for (; col_last < cols; col_last++) | |
1758 | { | |
702f5349 | 1759 | wxDataViewColumn *col = GetOwner()->GetColumnAt(col_last); |
1117d56f RR |
1760 | if (col->IsHidden()) |
1761 | continue; // skip it! | |
afebb87b | 1762 | |
1117d56f RR |
1763 | if (x_last > (unsigned int)update.GetRight()) |
1764 | break; | |
4ed7af08 | 1765 | |
1117d56f RR |
1766 | x_last += col->GetWidth(); |
1767 | } | |
d5025dc0 | 1768 | |
4bdc891f VZ |
1769 | // Draw background of alternate rows specially if required |
1770 | if ( m_owner->HasFlag(wxDV_ROW_LINES) ) | |
1771 | { | |
1772 | wxColour altRowColour = m_owner->m_alternateRowColour; | |
1773 | if ( !altRowColour.IsOk() ) | |
1774 | { | |
1775 | // Determine the alternate rows colour automatically from the | |
1776 | // background colour. | |
1777 | const wxColour bgColour = m_owner->GetBackgroundColour(); | |
1778 | ||
1779 | // Depending on the background, alternate row color | |
1780 | // will be 3% more dark or 50% brighter. | |
1781 | int alpha = bgColour.GetRGB() > 0x808080 ? 97 : 150; | |
1782 | altRowColour = bgColour.ChangeLightness(alpha); | |
1783 | } | |
1784 | ||
1785 | dc.SetPen(*wxTRANSPARENT_PEN); | |
1786 | dc.SetBrush(wxBrush(altRowColour)); | |
1787 | ||
1788 | for (unsigned int item = item_start; item < item_last; item++) | |
1789 | { | |
1790 | if ( item % 2 ) | |
1791 | { | |
1792 | dc.DrawRectangle(x_start, | |
1793 | GetLineStart(item), | |
1794 | GetClientSize().GetWidth(), | |
1795 | GetLineHeight(item)); | |
1796 | } | |
1797 | } | |
1798 | } | |
1799 | ||
1117d56f RR |
1800 | // Draw horizontal rules if required |
1801 | if ( m_owner->HasFlag(wxDV_HORIZ_RULES) ) | |
1802 | { | |
1803 | dc.SetPen(m_penRule); | |
1804 | dc.SetBrush(*wxTRANSPARENT_BRUSH); | |
aba9bfd0 | 1805 | |
de4bf0b3 | 1806 | for (unsigned int i = item_start; i <= item_last; i++) |
1117d56f | 1807 | { |
344ed1f3 | 1808 | int y = GetLineStart( i ); |
1117d56f RR |
1809 | dc.DrawLine(x_start, y, x_last, y); |
1810 | } | |
1811 | } | |
aba9bfd0 | 1812 | |
1117d56f RR |
1813 | // Draw vertical rules if required |
1814 | if ( m_owner->HasFlag(wxDV_VERT_RULES) ) | |
b7e9f8b1 | 1815 | { |
1117d56f RR |
1816 | dc.SetPen(m_penRule); |
1817 | dc.SetBrush(*wxTRANSPARENT_BRUSH); | |
b7e9f8b1 | 1818 | |
3999336c VS |
1819 | // NB: Vertical rules are drawn in the last pixel of a column so that |
1820 | // they align perfectly with native MSW wxHeaderCtrl as well as for | |
1821 | // consistency with MSW native list control. There's no vertical | |
1822 | // rule at the most-left side of the control. | |
1823 | ||
1824 | int x = x_start - 1; | |
1117d56f RR |
1825 | for (unsigned int i = col_start; i < col_last; i++) |
1826 | { | |
702f5349 | 1827 | wxDataViewColumn *col = GetOwner()->GetColumnAt(i); |
1117d56f RR |
1828 | if (col->IsHidden()) |
1829 | continue; // skip it | |
d47db7e0 | 1830 | |
3999336c VS |
1831 | x += col->GetWidth(); |
1832 | ||
344ed1f3 RR |
1833 | dc.DrawLine(x, GetLineStart( item_start ), |
1834 | x, GetLineStart( item_last ) ); | |
1117d56f | 1835 | } |
1117d56f RR |
1836 | } |
1837 | ||
1838 | // redraw the background for the items which are selected/current | |
1839 | for (unsigned int item = item_start; item < item_last; item++) | |
aba9bfd0 | 1840 | { |
1117d56f | 1841 | bool selected = m_selection.Index( item ) != wxNOT_FOUND; |
1c8e71c9 | 1842 | |
1117d56f | 1843 | if (selected || item == m_currentRow) |
d5025dc0 | 1844 | { |
e3dbeaaf VZ |
1845 | wxRect rect( x_start, GetLineStart( item ), |
1846 | x_last - x_start, GetLineHeight( item ) ); | |
1c8e71c9 VS |
1847 | |
1848 | // draw selection and whole-item focus: | |
1849 | if ( selected ) | |
1850 | { | |
1851 | int flags = wxCONTROL_SELECTED; | |
1852 | if (m_hasFocus) | |
1853 | flags |= wxCONTROL_FOCUSED; | |
1854 | ||
1855 | wxRendererNative::Get().DrawItemSelectionRect | |
1856 | ( | |
1857 | this, | |
1858 | dc, | |
1859 | rect, | |
1860 | flags | |
1861 | ); | |
1862 | } | |
1863 | ||
1864 | // draw keyboard focus rect if applicable | |
1865 | if ( item == m_currentRow && m_hasFocus ) | |
1866 | { | |
1867 | bool renderColumnFocus = false; | |
1868 | ||
1869 | if ( m_useCellFocus && m_currentCol && m_currentColSetByKeyboard ) | |
1870 | { | |
1871 | renderColumnFocus = true; | |
1872 | ||
1873 | // If this is container node without columns, render full-row focus: | |
1874 | if ( !IsList() ) | |
1875 | { | |
1876 | wxDataViewTreeNode *node = GetTreeNodeByRow(item); | |
1877 | if ( node->HasChildren() && !model->HasContainerColumns(node->GetItem()) ) | |
1878 | renderColumnFocus = false; | |
1879 | } | |
1880 | } | |
1881 | ||
1882 | if ( renderColumnFocus ) | |
1883 | { | |
1884 | for ( unsigned int i = col_start; i < col_last; i++ ) | |
1885 | { | |
1886 | wxDataViewColumn *col = GetOwner()->GetColumnAt(i); | |
1887 | if ( col->IsHidden() ) | |
1888 | continue; | |
1889 | ||
1890 | rect.width = col->GetWidth(); | |
1891 | ||
1892 | if ( col == m_currentCol ) | |
1893 | { | |
1894 | // make the rect more visible by adding a small | |
1895 | // margin around it: | |
1896 | rect.Deflate(1, 1); | |
1897 | ||
1898 | if ( selected ) | |
1899 | { | |
1900 | // DrawFocusRect() uses XOR and is all but | |
1901 | // invisible against dark-blue background. Use | |
1902 | // the same color used for selected text. | |
1903 | DrawSelectedCellFocusRect(dc, rect); | |
1904 | } | |
1905 | else | |
1906 | { | |
1907 | wxRendererNative::Get().DrawFocusRect | |
1908 | ( | |
1909 | this, | |
1910 | dc, | |
1911 | rect, | |
1912 | 0 | |
1913 | ); | |
1914 | } | |
1915 | break; | |
1916 | } | |
1917 | ||
1918 | rect.x += rect.width; | |
1919 | } | |
1920 | } | |
1921 | else | |
1922 | { | |
1923 | // render focus rectangle for the whole row | |
1924 | wxRendererNative::Get().DrawFocusRect | |
1925 | ( | |
1926 | this, | |
1927 | dc, | |
1928 | rect, | |
1929 | selected ? (int)wxCONTROL_SELECTED : 0 | |
1930 | ); | |
1931 | } | |
1932 | } | |
d47db7e0 | 1933 | } |
aba9bfd0 | 1934 | } |
9adeb77a VZ |
1935 | |
1936 | #if wxUSE_DRAG_AND_DROP | |
9deec111 | 1937 | if (m_dropHint) |
9adeb77a VZ |
1938 | { |
1939 | wxRect rect( x_start, GetLineStart( m_dropHintLine ), | |
e3dbeaaf | 1940 | x_last - x_start, GetLineHeight( m_dropHintLine ) ); |
9deec111 RR |
1941 | dc.SetPen( *wxBLACK_PEN ); |
1942 | dc.SetBrush( *wxTRANSPARENT_BRUSH ); | |
1943 | dc.DrawRectangle( rect ); | |
1944 | } | |
9adeb77a | 1945 | #endif // wxUSE_DRAG_AND_DROP |
a0f3af5f | 1946 | |
1841f079 VZ |
1947 | wxDataViewColumn * const |
1948 | expander = GetExpanderColumnOrFirstOne(GetOwner()); | |
d47db7e0 | 1949 | |
344ed1f3 | 1950 | // redraw all cells for all rows which must be repainted and all columns |
1117d56f RR |
1951 | wxRect cell_rect; |
1952 | cell_rect.x = x_start; | |
1117d56f | 1953 | for (unsigned int i = col_start; i < col_last; i++) |
d47db7e0 | 1954 | { |
702f5349 | 1955 | wxDataViewColumn *col = GetOwner()->GetColumnAt( i ); |
1117d56f RR |
1956 | wxDataViewRenderer *cell = col->GetRenderer(); |
1957 | cell_rect.width = col->GetWidth(); | |
d47db7e0 | 1958 | |
b10c4089 | 1959 | if ( col->IsHidden() || cell_rect.width <= 0 ) |
344ed1f3 | 1960 | continue; // skip it! |
fbda518c | 1961 | |
1117d56f RR |
1962 | for (unsigned int item = item_start; item < item_last; item++) |
1963 | { | |
1964 | // get the cell value and set it into the renderer | |
1117d56f RR |
1965 | wxDataViewTreeNode *node = NULL; |
1966 | wxDataViewItem dataitem; | |
cfa42cb8 | 1967 | |
344ed1f3 | 1968 | if (!IsVirtualList()) |
1117d56f RR |
1969 | { |
1970 | node = GetTreeNodeByRow(item); | |
1971 | if( node == NULL ) | |
1972 | continue; | |
a0f3af5f | 1973 | |
1117d56f | 1974 | dataitem = node->GetItem(); |
704c3490 | 1975 | |
311c4a7a VZ |
1976 | // Skip all columns of "container" rows except the expander |
1977 | // column itself unless HasContainerColumns() overrides this. | |
1841f079 | 1978 | if ( col != expander && |
311c4a7a VZ |
1979 | model->IsContainer(dataitem) && |
1980 | !model->HasContainerColumns(dataitem) ) | |
1117d56f RR |
1981 | continue; |
1982 | } | |
1983 | else | |
1984 | { | |
86ba79ed | 1985 | dataitem = wxDataViewItem( wxUIntToPtr(item+1) ); |
1117d56f | 1986 | } |
8b6cf9bf | 1987 | |
f0ccd2cb | 1988 | cell->PrepareForItem(model, dataitem, col->GetModelColumn()); |
62265c2c | 1989 | |
c9287446 | 1990 | // update cell_rect |
344ed1f3 | 1991 | cell_rect.y = GetLineStart( item ); |
bc4f1ff2 | 1992 | cell_rect.height = GetLineHeight( item ); |
8b6cf9bf | 1993 | |
1c959a62 VZ |
1994 | // draw the background |
1995 | bool selected = m_selection.Index( item ) != wxNOT_FOUND; | |
1996 | if ( !selected ) | |
1997 | DrawCellBackground( cell, dc, cell_rect ); | |
1998 | ||
b10c4089 | 1999 | // deal with the expander |
1117d56f | 2000 | int indent = 0; |
ce5abbf9 | 2001 | if ((!IsList()) && (col == expander)) |
1117d56f | 2002 | { |
bc4f1ff2 | 2003 | // Calculate the indent first |
b10c4089 | 2004 | indent = GetOwner()->GetIndent() * node->GetIndentLevel(); |
bc4f1ff2 | 2005 | |
b10c4089 VZ |
2006 | // we reserve m_lineHeight of horizontal space for the expander |
2007 | // but leave EXPANDER_MARGIN around the expander itself | |
2008 | int exp_x = cell_rect.x + indent + EXPANDER_MARGIN; | |
bc4f1ff2 | 2009 | |
b10c4089 | 2010 | indent += m_lineHeight; |
bc4f1ff2 | 2011 | |
b10c4089 VZ |
2012 | // draw expander if needed and visible |
2013 | if ( node->HasChildren() && exp_x < cell_rect.GetRight() ) | |
1117d56f | 2014 | { |
b10c4089 VZ |
2015 | dc.SetPen( m_penExpander ); |
2016 | dc.SetBrush( wxNullBrush ); | |
2017 | ||
2018 | int exp_size = m_lineHeight - 2*EXPANDER_MARGIN; | |
2019 | int exp_y = cell_rect.y + (cell_rect.height - exp_size)/2 | |
2020 | + EXPANDER_MARGIN - EXPANDER_OFFSET; | |
2021 | ||
2022 | const wxRect rect(exp_x, exp_y, exp_size, exp_size); | |
2023 | ||
1117d56f | 2024 | int flag = 0; |
b10c4089 | 2025 | if ( m_underMouse == node ) |
1117d56f | 2026 | flag |= wxCONTROL_CURRENT; |
b10c4089 VZ |
2027 | if ( node->IsOpen() ) |
2028 | flag |= wxCONTROL_EXPANDED; | |
2029 | ||
2030 | // ensure that we don't overflow the cell (which might | |
2031 | // happen if the column is very narrow) | |
2032 | wxDCClipper clip(dc, cell_rect); | |
2033 | ||
2034 | wxRendererNative::Get().DrawTreeItemButton( this, dc, rect, flag); | |
1117d56f | 2035 | } |
bc4f1ff2 FM |
2036 | |
2037 | // force the expander column to left-center align | |
977a41ec | 2038 | cell->SetAlignment( wxALIGN_CENTER_VERTICAL ); |
1117d56f | 2039 | } |
1117d56f | 2040 | |
a6f1201f VZ |
2041 | wxRect item_rect = cell_rect; |
2042 | item_rect.Deflate(PADDING_RIGHTLEFT, 0); | |
2043 | ||
2044 | // account for the tree indent (harmless if we're not indented) | |
1117d56f | 2045 | item_rect.x += indent; |
a6f1201f | 2046 | item_rect.width -= indent; |
1117d56f | 2047 | |
b10c4089 VZ |
2048 | if ( item_rect.width <= 0 ) |
2049 | continue; | |
2050 | ||
1117d56f | 2051 | int state = 0; |
1c959a62 | 2052 | if (m_hasFocus && selected) |
1117d56f RR |
2053 | state |= wxDATAVIEW_CELL_SELECTED; |
2054 | ||
2055 | // TODO: it would be much more efficient to create a clipping | |
2056 | // region for the entire column being rendered (in the OnPaint | |
2057 | // of wxDataViewMainWindow) instead of a single clip region for | |
2058 | // each cell. However it would mean that each renderer should | |
2059 | // respect the given wxRect's top & bottom coords, eventually | |
2060 | // violating only the left & right coords - however the user can | |
2061 | // make its own renderer and thus we cannot be sure of that. | |
a6f1201f | 2062 | wxDCClipper clip(dc, item_rect); |
2d0d7813 | 2063 | |
62265c2c | 2064 | cell->WXCallRender(item_rect, &dc, state); |
1117d56f RR |
2065 | } |
2066 | ||
2067 | cell_rect.x += cell_rect.width; | |
2068 | } | |
2069 | } | |
2070 | ||
1c959a62 VZ |
2071 | |
2072 | void wxDataViewMainWindow::DrawCellBackground( wxDataViewRenderer* cell, wxDC& dc, const wxRect& rect ) | |
2073 | { | |
2074 | wxRect rectBg( rect ); | |
2075 | ||
2076 | // don't overlap the horizontal rules | |
2077 | if ( m_owner->HasFlag(wxDV_HORIZ_RULES) ) | |
2078 | { | |
2079 | rectBg.x++; | |
2080 | rectBg.width--; | |
2081 | } | |
2082 | ||
2083 | // don't overlap the vertical rules | |
2084 | if ( m_owner->HasFlag(wxDV_VERT_RULES) ) | |
2085 | { | |
2086 | rectBg.y++; | |
2087 | rectBg.height--; | |
2088 | } | |
2089 | ||
2090 | cell->RenderBackground(&dc, rectBg); | |
2091 | } | |
2092 | ||
1117d56f RR |
2093 | void wxDataViewMainWindow::OnRenameTimer() |
2094 | { | |
2095 | // We have to call this here because changes may just have | |
2096 | // been made and no screen update taken place. | |
2097 | if ( m_dirty ) | |
977a41ec FM |
2098 | { |
2099 | // TODO: use wxTheApp->SafeYieldFor(NULL, wxEVT_CATEGORY_UI) instead | |
2100 | // (needs to be tested!) | |
1117d56f | 2101 | wxSafeYield(); |
977a41ec | 2102 | } |
1117d56f | 2103 | |
0a807957 | 2104 | wxDataViewItem item = GetItemByRow( m_currentRow ); |
1117d56f | 2105 | |
64ac3db8 VZ |
2106 | StartEditing( item, m_currentCol ); |
2107 | } | |
1117d56f | 2108 | |
64ac3db8 VZ |
2109 | void |
2110 | wxDataViewMainWindow::StartEditing(const wxDataViewItem& item, | |
2111 | const wxDataViewColumn* col) | |
2112 | { | |
2113 | wxDataViewRenderer* renderer = col->GetRenderer(); | |
cf5d4c76 | 2114 | if ( !IsCellEditableInMode(item, col, wxDATAVIEW_CELL_EDITABLE) ) |
64ac3db8 VZ |
2115 | return; |
2116 | ||
2117 | const wxRect itemRect = GetItemRect(item, col); | |
2118 | if ( renderer->StartEditing(item, itemRect) ) | |
2119 | { | |
2120 | // Save the renderer to be able to finish/cancel editing it later and | |
2121 | // save the control to be able to detect if we're still editing it. | |
2122 | m_editorRenderer = renderer; | |
2123 | m_editorCtrl = renderer->GetEditorCtrl(); | |
2124 | } | |
1117d56f RR |
2125 | } |
2126 | ||
bc4f1ff2 | 2127 | //----------------------------------------------------------------------------- |
1117d56f | 2128 | // Helper class for do operation on the tree node |
bc4f1ff2 | 2129 | //----------------------------------------------------------------------------- |
1117d56f RR |
2130 | class DoJob |
2131 | { | |
2132 | public: | |
59e60167 VZ |
2133 | DoJob() { } |
2134 | virtual ~DoJob() { } | |
1117d56f | 2135 | |
bc4f1ff2 | 2136 | // The return value control how the tree-walker tranverse the tree |
d54f0605 VS |
2137 | enum |
2138 | { | |
2139 | DONE, // Job done, stop traversing and return | |
2140 | SKIP_SUBTREE, // Ignore the current node's subtree and continue | |
2141 | CONTINUE // Job not done, continue | |
2142 | }; | |
2143 | ||
59e60167 | 2144 | virtual int operator() ( wxDataViewTreeNode * node ) = 0; |
1117d56f RR |
2145 | }; |
2146 | ||
2147 | bool Walker( wxDataViewTreeNode * node, DoJob & func ) | |
2148 | { | |
422aa8ec | 2149 | wxCHECK_MSG( node, false, "can't walk NULL node" ); |
1117d56f RR |
2150 | |
2151 | switch( func( node ) ) | |
2152 | { | |
d54f0605 | 2153 | case DoJob::DONE: |
59e60167 | 2154 | return true; |
d54f0605 | 2155 | case DoJob::SKIP_SUBTREE: |
1117d56f | 2156 | return false; |
d54f0605 | 2157 | case DoJob::CONTINUE: |
422aa8ec | 2158 | break; |
1117d56f RR |
2159 | } |
2160 | ||
d0cfefc4 | 2161 | if ( node->HasChildren() ) |
1117d56f | 2162 | { |
ff3c5ad3 | 2163 | const wxDataViewTreeNodes& nodes = node->GetChildNodes(); |
d0cfefc4 VS |
2164 | |
2165 | for ( wxDataViewTreeNodes::const_iterator i = nodes.begin(); | |
2166 | i != nodes.end(); | |
2167 | ++i ) | |
2168 | { | |
2169 | if ( Walker(*i, func) ) | |
2170 | return true; | |
2171 | } | |
1117d56f | 2172 | } |
422aa8ec | 2173 | |
1117d56f RR |
2174 | return false; |
2175 | } | |
2176 | ||
2177 | bool wxDataViewMainWindow::ItemAdded(const wxDataViewItem & parent, const wxDataViewItem & item) | |
2178 | { | |
86ba79ed | 2179 | if (IsVirtualList()) |
1117d56f | 2180 | { |
49d2b75d | 2181 | wxDataViewVirtualListModel *list_model = |
c2c89730 | 2182 | (wxDataViewVirtualListModel*) GetModel(); |
49d2b75d | 2183 | m_count = list_model->GetCount(); |
1117d56f | 2184 | } |
0b93babd VS |
2185 | else |
2186 | { | |
2187 | SortPrepare(); | |
cfa42cb8 | 2188 | |
422aa8ec | 2189 | wxDataViewTreeNode *parentNode = FindNode(parent); |
1117d56f | 2190 | |
422aa8ec | 2191 | if ( !parentNode ) |
0b93babd | 2192 | return false; |
1117d56f | 2193 | |
5bb82ad4 VS |
2194 | wxDataViewItemArray modelSiblings; |
2195 | GetModel()->GetChildren(parent, modelSiblings); | |
2196 | const int modelSiblingsSize = modelSiblings.size(); | |
2197 | ||
2198 | int posInModel = modelSiblings.Index(item, /*fromEnd=*/true); | |
2199 | wxCHECK_MSG( posInModel != wxNOT_FOUND, false, "adding non-existent item?" ); | |
35219832 | 2200 | |
422aa8ec | 2201 | wxDataViewTreeNode *itemNode = new wxDataViewTreeNode(parentNode, item); |
c2c89730 | 2202 | itemNode->SetHasChildren(GetModel()->IsContainer(item)); |
1117d56f | 2203 | |
422aa8ec | 2204 | parentNode->SetHasChildren(true); |
5bb82ad4 VS |
2205 | |
2206 | const wxDataViewTreeNodes& nodeSiblings = parentNode->GetChildNodes(); | |
2207 | const int nodeSiblingsSize = nodeSiblings.size(); | |
2208 | ||
2209 | int nodePos = 0; | |
2210 | ||
2211 | if ( posInModel == modelSiblingsSize - 1 ) | |
2212 | { | |
2213 | nodePos = nodeSiblingsSize; | |
2214 | } | |
2215 | else if ( modelSiblingsSize == nodeSiblingsSize + 1 ) | |
2216 | { | |
2217 | // This is the simple case when our node tree already matches the | |
2218 | // model and only this one item is missing. | |
2219 | nodePos = posInModel; | |
2220 | } | |
2221 | else | |
2222 | { | |
2223 | // It's possible that a larger discrepancy between the model and | |
2224 | // our realization exists. This can happen e.g. when adding a bunch | |
2225 | // of items to the model and then calling ItemsAdded() just once | |
2226 | // afterwards. In this case, we must find the right position by | |
2227 | // looking at sibling items. | |
2228 | ||
2229 | // append to the end if we won't find a better position: | |
2230 | nodePos = nodeSiblingsSize; | |
2231 | ||
2232 | for ( int nextItemPos = posInModel + 1; | |
2233 | nextItemPos < modelSiblingsSize; | |
2234 | nextItemPos++ ) | |
2235 | { | |
2236 | int nextNodePos = parentNode->FindChildByItem(modelSiblings[nextItemPos]); | |
2237 | if ( nextNodePos != wxNOT_FOUND ) | |
2238 | { | |
2239 | nodePos = nextNodePos; | |
2240 | break; | |
2241 | } | |
2242 | } | |
2243 | } | |
2244 | ||
422aa8ec | 2245 | parentNode->ChangeSubTreeCount(+1); |
5bb82ad4 | 2246 | parentNode->InsertChild(itemNode, nodePos); |
1117d56f | 2247 | |
0b93babd | 2248 | m_count = -1; |
1117d56f | 2249 | } |
1117d56f | 2250 | |
bed74e48 | 2251 | GetOwner()->InvalidateColBestWidths(); |
1117d56f RR |
2252 | UpdateDisplay(); |
2253 | ||
2254 | return true; | |
2255 | } | |
2256 | ||
1117d56f | 2257 | bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent, |
86ba79ed | 2258 | const wxDataViewItem& item) |
1117d56f | 2259 | { |
86ba79ed | 2260 | if (IsVirtualList()) |
1117d56f | 2261 | { |
49d2b75d | 2262 | wxDataViewVirtualListModel *list_model = |
c2c89730 | 2263 | (wxDataViewVirtualListModel*) GetModel(); |
49d2b75d | 2264 | m_count = list_model->GetCount(); |
03647350 | 2265 | |
57ab4546 VS |
2266 | if ( !m_selection.empty() ) |
2267 | { | |
2268 | const int row = GetRowByItem(item); | |
2269 | ||
f6410588 VS |
2270 | int rowIndexInSelection = wxNOT_FOUND; |
2271 | ||
57ab4546 VS |
2272 | const size_t selCount = m_selection.size(); |
2273 | for ( size_t i = 0; i < selCount; i++ ) | |
2274 | { | |
f6410588 VS |
2275 | if ( m_selection[i] == (unsigned)row ) |
2276 | rowIndexInSelection = i; | |
2277 | else if ( m_selection[i] > (unsigned)row ) | |
57ab4546 VS |
2278 | m_selection[i]--; |
2279 | } | |
2280 | ||
f6410588 VS |
2281 | if ( rowIndexInSelection != wxNOT_FOUND ) |
2282 | m_selection.RemoveAt(rowIndexInSelection); | |
57ab4546 VS |
2283 | } |
2284 | ||
1117d56f | 2285 | } |
b6252949 VS |
2286 | else // general case |
2287 | { | |
422aa8ec | 2288 | wxDataViewTreeNode *parentNode = FindNode(parent); |
1117d56f | 2289 | |
b6252949 VS |
2290 | // Notice that it is possible that the item being deleted is not in the |
2291 | // tree at all, for example we could be deleting a never shown (because | |
2292 | // collapsed) item in a tree model. So it's not an error if we don't know | |
2293 | // about this item, just return without doing anything then. | |
b632efe0 | 2294 | if ( !parentNode ) |
28fefd45 | 2295 | return true; |
b23de238 | 2296 | |
d0cfefc4 | 2297 | wxCHECK_MSG( parentNode->HasChildren(), false, "parent node doesn't have children?" ); |
ff3c5ad3 | 2298 | const wxDataViewTreeNodes& parentsChildren = parentNode->GetChildNodes(); |
351461fc | 2299 | |
422aa8ec VS |
2300 | // We can't use FindNode() to find 'item', because it was already |
2301 | // removed from the model by the time ItemDeleted() is called, so we | |
2302 | // have to do it manually. We keep track of its position as well for | |
2303 | // later use. | |
2304 | int itemPosInNode = 0; | |
57ab4546 | 2305 | wxDataViewTreeNode *itemNode = NULL; |
422aa8ec VS |
2306 | for ( wxDataViewTreeNodes::const_iterator i = parentsChildren.begin(); |
2307 | i != parentsChildren.end(); | |
2308 | ++i, ++itemPosInNode ) | |
d47db7e0 | 2309 | { |
422aa8ec | 2310 | if( (*i)->GetItem() == item ) |
d47db7e0 | 2311 | { |
422aa8ec | 2312 | itemNode = *i; |
d47db7e0 RR |
2313 | break; |
2314 | } | |
2315 | } | |
57ab4546 | 2316 | |
422aa8ec VS |
2317 | // If the parent wasn't expanded, it's possible that we didn't have a |
2318 | // node corresponding to 'item' and so there's nothing left to do. | |
2319 | if ( !itemNode ) | |
b6252949 | 2320 | { |
422aa8ec VS |
2321 | // If this was the last child to be removed, it's possible the parent |
2322 | // node became a leaf. Let's ask the model about it. | |
ff3c5ad3 | 2323 | if ( parentNode->GetChildNodes().empty() ) |
c2c89730 | 2324 | parentNode->SetHasChildren(GetModel()->IsContainer(parent)); |
a8505db0 | 2325 | |
28fefd45 | 2326 | return true; |
b6252949 | 2327 | } |
57ab4546 | 2328 | |
422aa8ec VS |
2329 | // Delete the item from wxDataViewTreeNode representation: |
2330 | const int itemsDeleted = 1 + itemNode->GetSubTreeCount(); | |
2331 | ||
a2d3c415 VS |
2332 | parentNode->RemoveChild(itemNode); |
2333 | delete itemNode; | |
422aa8ec VS |
2334 | parentNode->ChangeSubTreeCount(-itemsDeleted); |
2335 | ||
b6252949 VS |
2336 | // Make the row number invalid and get a new valid one when user call GetRowCount |
2337 | m_count = -1; | |
422aa8ec VS |
2338 | |
2339 | // If this was the last child to be removed, it's possible the parent | |
2340 | // node became a leaf. Let's ask the model about it. | |
ff3c5ad3 | 2341 | if ( parentNode->GetChildNodes().empty() ) |
c3b504ad VZ |
2342 | { |
2343 | bool isContainer = GetModel()->IsContainer(parent); | |
2344 | parentNode->SetHasChildren(isContainer); | |
2345 | if ( isContainer ) | |
2346 | { | |
2347 | // If it's still a container, make sure we show "+" icon for it | |
2348 | // and not "-" one as there is nothing to collapse any more. | |
2349 | if ( parentNode->IsOpen() ) | |
2350 | parentNode->ToggleOpen(); | |
2351 | } | |
2352 | } | |
57ab4546 VS |
2353 | |
2354 | // Update selection by removing 'item' and its entire children tree from the selection. | |
2355 | if ( !m_selection.empty() ) | |
2356 | { | |
2357 | // we can't call GetRowByItem() on 'item', as it's already deleted, so compute it from | |
b632efe0 | 2358 | // the parent ('parentNode') and position in its list of children |
57ab4546 VS |
2359 | int itemRow; |
2360 | if ( itemPosInNode == 0 ) | |
2361 | { | |
b632efe0 VS |
2362 | // 1st child, row number is that of the parent parentNode + 1 |
2363 | itemRow = GetRowByItem(parentNode->GetItem()) + 1; | |
57ab4546 VS |
2364 | } |
2365 | else | |
2366 | { | |
2367 | // row number is that of the sibling above 'item' + its subtree if any + 1 | |
ff3c5ad3 | 2368 | const wxDataViewTreeNode *siblingNode = parentNode->GetChildNodes()[itemPosInNode - 1]; |
57ab4546 | 2369 | |
422aa8ec VS |
2370 | itemRow = GetRowByItem(siblingNode->GetItem()) + |
2371 | siblingNode->GetSubTreeCount() + | |
2372 | 1; | |
57ab4546 VS |
2373 | } |
2374 | ||
2375 | wxDataViewSelection newsel(wxDataViewSelectionCmp); | |
2376 | ||
3823a15e VZ |
2377 | const size_t numSelections = m_selection.size(); |
2378 | for ( size_t i = 0; i < numSelections; ++i ) | |
57ab4546 | 2379 | { |
3823a15e | 2380 | const int s = m_selection[i]; |
57ab4546 VS |
2381 | if ( s < itemRow ) |
2382 | newsel.push_back(s); | |
2383 | else if ( s >= itemRow + itemsDeleted ) | |
2384 | newsel.push_back(s - itemsDeleted); | |
2385 | // else: deleted item, remove from selection | |
2386 | } | |
2387 | ||
2388 | m_selection = newsel; | |
2389 | } | |
d47db7e0 | 2390 | } |
24c4a50f | 2391 | |
bc4f1ff2 | 2392 | // Change the current row to the last row if the current exceed the max row number |
d47db7e0 | 2393 | if( m_currentRow > GetRowCount() ) |
8c7b8711 | 2394 | ChangeCurrentRow(m_count - 1); |
351461fc | 2395 | |
bed74e48 | 2396 | GetOwner()->InvalidateColBestWidths(); |
99d471a5 | 2397 | UpdateDisplay(); |
b7fe2261 | 2398 | |
99d471a5 | 2399 | return true; |
a0f3af5f RR |
2400 | } |
2401 | ||
aba9bfd0 | 2402 | bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem & item) |
a0f3af5f | 2403 | { |
66e09788 | 2404 | SortPrepare(); |
b7e9f8b1 RR |
2405 | g_model->Resort(); |
2406 | ||
bed74e48 | 2407 | GetOwner()->InvalidateColBestWidths(); |
ac098108 | 2408 | |
bc4f1ff2 | 2409 | // Send event |
6608fdab RR |
2410 | wxWindow *parent = GetParent(); |
2411 | wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId()); | |
2412 | le.SetEventObject(parent); | |
c2c89730 | 2413 | le.SetModel(GetModel()); |
6608fdab | 2414 | le.SetItem(item); |
857f05e1 | 2415 | parent->ProcessWindowEvent(le); |
b5ec7dd6 | 2416 | |
99d471a5 | 2417 | return true; |
a0f3af5f RR |
2418 | } |
2419 | ||
d93cc830 | 2420 | bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int model_column ) |
a0f3af5f | 2421 | { |
d93cc830 RR |
2422 | int view_column = -1; |
2423 | unsigned int n_col = m_owner->GetColumnCount(); | |
2424 | for (unsigned i = 0; i < n_col; i++) | |
2425 | { | |
2426 | wxDataViewColumn *column = m_owner->GetColumn( i ); | |
2427 | if (column->GetModelColumn() == model_column) | |
2428 | { | |
2429 | view_column = (int) i; | |
2430 | break; | |
2431 | } | |
2432 | } | |
2433 | if (view_column == -1) | |
2434 | return false; | |
2435 | ||
9861f022 | 2436 | // NOTE: to be valid, we cannot use e.g. INT_MAX - 1 |
aba9bfd0 | 2437 | /*#define MAX_VIRTUAL_WIDTH 100000 |
9861f022 RR |
2438 | |
2439 | wxRect rect( 0, row*m_lineHeight, MAX_VIRTUAL_WIDTH, m_lineHeight ); | |
0fdc2321 RR |
2440 | m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y ); |
2441 | Refresh( true, &rect ); | |
2442 | ||
2443 | return true; | |
aba9bfd0 | 2444 | */ |
66e09788 | 2445 | SortPrepare(); |
b7e9f8b1 RR |
2446 | g_model->Resort(); |
2447 | ||
bed74e48 | 2448 | GetOwner()->InvalidateColBestWidth(view_column); |
ac098108 | 2449 | |
bc4f1ff2 | 2450 | // Send event |
b7e9f8b1 | 2451 | wxWindow *parent = GetParent(); |
6608fdab | 2452 | wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId()); |
b7e9f8b1 | 2453 | le.SetEventObject(parent); |
c2c89730 | 2454 | le.SetModel(GetModel()); |
b7e9f8b1 | 2455 | le.SetItem(item); |
d93cc830 RR |
2456 | le.SetColumn(view_column); |
2457 | le.SetDataViewColumn(GetOwner()->GetColumn(view_column)); | |
857f05e1 | 2458 | parent->ProcessWindowEvent(le); |
d47db7e0 | 2459 | |
0fcce6b9 | 2460 | return true; |
a0f3af5f RR |
2461 | } |
2462 | ||
2463 | bool wxDataViewMainWindow::Cleared() | |
2464 | { | |
704c3490 | 2465 | DestroyTree(); |
97e5b064 | 2466 | m_selection.Clear(); |
cfa42cb8 | 2467 | |
be416221 VZ |
2468 | if (GetModel()) |
2469 | { | |
2470 | SortPrepare(); | |
2471 | BuildTree( GetModel() ); | |
2472 | } | |
2473 | else | |
2474 | { | |
2475 | m_count = 0; | |
2476 | } | |
cfa42cb8 | 2477 | |
bed74e48 | 2478 | GetOwner()->InvalidateColBestWidths(); |
99d471a5 | 2479 | UpdateDisplay(); |
b7e9f8b1 | 2480 | |
99d471a5 | 2481 | return true; |
a0f3af5f RR |
2482 | } |
2483 | ||
4b3feaa7 RR |
2484 | void wxDataViewMainWindow::UpdateDisplay() |
2485 | { | |
2486 | m_dirty = true; | |
7d5d2f23 | 2487 | m_underMouse = NULL; |
4b3feaa7 RR |
2488 | } |
2489 | ||
2490 | void wxDataViewMainWindow::OnInternalIdle() | |
2491 | { | |
2492 | wxWindow::OnInternalIdle(); | |
f554a14b | 2493 | |
4b3feaa7 RR |
2494 | if (m_dirty) |
2495 | { | |
2496 | RecalculateDisplay(); | |
2497 | m_dirty = false; | |
2498 | } | |
2499 | } | |
2500 | ||
2501 | void wxDataViewMainWindow::RecalculateDisplay() | |
2502 | { | |
c2c89730 | 2503 | wxDataViewModel *model = GetModel(); |
4b3feaa7 RR |
2504 | if (!model) |
2505 | { | |
2506 | Refresh(); | |
2507 | return; | |
2508 | } | |
f554a14b | 2509 | |
9861f022 | 2510 | int width = GetEndOfLastCol(); |
344ed1f3 | 2511 | int height = GetLineStart( GetRowCount() ); |
4b3feaa7 RR |
2512 | |
2513 | SetVirtualSize( width, height ); | |
2514 | GetOwner()->SetScrollRate( 10, m_lineHeight ); | |
f554a14b | 2515 | |
4b3feaa7 RR |
2516 | Refresh(); |
2517 | } | |
2518 | ||
2519 | void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect ) | |
2520 | { | |
d93cc830 RR |
2521 | m_underMouse = NULL; |
2522 | ||
4b3feaa7 | 2523 | wxWindow::ScrollWindow( dx, dy, rect ); |
9861f022 RR |
2524 | |
2525 | if (GetOwner()->m_headerArea) | |
2526 | GetOwner()->m_headerArea->ScrollWindow( dx, 0 ); | |
4b3feaa7 RR |
2527 | } |
2528 | ||
fbda518c | 2529 | void wxDataViewMainWindow::ScrollTo( int rows, int column ) |
b7e9f8b1 | 2530 | { |
d93cc830 RR |
2531 | m_underMouse = NULL; |
2532 | ||
b7e9f8b1 RR |
2533 | int x, y; |
2534 | m_owner->GetScrollPixelsPerUnit( &x, &y ); | |
344ed1f3 | 2535 | int sy = GetLineStart( rows )/y; |
eff1c3e8 | 2536 | int sx = -1; |
fbda518c RR |
2537 | if( column != -1 ) |
2538 | { | |
2539 | wxRect rect = GetClientRect(); | |
67be459b | 2540 | int colnum = 0; |
dd639a4f | 2541 | int x_start, w = 0; |
fbda518c RR |
2542 | int xx, yy, xe; |
2543 | m_owner->CalcUnscrolledPosition( rect.x, rect.y, &xx, &yy ); | |
2544 | for (x_start = 0; colnum < column; colnum++) | |
2545 | { | |
702f5349 | 2546 | wxDataViewColumn *col = GetOwner()->GetColumnAt(colnum); |
fbda518c RR |
2547 | if (col->IsHidden()) |
2548 | continue; // skip it! | |
2549 | ||
2550 | w = col->GetWidth(); | |
2551 | x_start += w; | |
2552 | } | |
2553 | ||
e822d1bd | 2554 | int x_end = x_start + w; |
fbda518c RR |
2555 | xe = xx + rect.width; |
2556 | if( x_end > xe ) | |
2557 | { | |
2558 | sx = ( xx + x_end - xe )/x; | |
2559 | } | |
2560 | if( x_start < xx ) | |
2561 | { | |
b7fe2261 | 2562 | sx = x_start/x; |
fbda518c RR |
2563 | } |
2564 | } | |
2565 | m_owner->Scroll( sx, sy ); | |
b7e9f8b1 RR |
2566 | } |
2567 | ||
9861f022 | 2568 | int wxDataViewMainWindow::GetCountPerPage() const |
cab07038 RR |
2569 | { |
2570 | wxSize size = GetClientSize(); | |
2571 | return size.y / m_lineHeight; | |
2572 | } | |
2573 | ||
9861f022 | 2574 | int wxDataViewMainWindow::GetEndOfLastCol() const |
e21f75bd RR |
2575 | { |
2576 | int width = 0; | |
0a71f9e9 | 2577 | unsigned int i; |
9861f022 | 2578 | for (i = 0; i < GetOwner()->GetColumnCount(); i++) |
e21f75bd | 2579 | { |
c741d33f | 2580 | const wxDataViewColumn *c = |
702f5349 | 2581 | const_cast<wxDataViewCtrl*>(GetOwner())->GetColumnAt( i ); |
9861f022 RR |
2582 | |
2583 | if (!c->IsHidden()) | |
2584 | width += c->GetWidth(); | |
e21f75bd RR |
2585 | } |
2586 | return width; | |
2587 | } | |
2588 | ||
9861f022 | 2589 | unsigned int wxDataViewMainWindow::GetFirstVisibleRow() const |
72664514 RR |
2590 | { |
2591 | int x = 0; | |
2592 | int y = 0; | |
2593 | m_owner->CalcUnscrolledPosition( x, y, &x, &y ); | |
120b9b05 | 2594 | |
344ed1f3 | 2595 | return GetLineAt( y ); |
72664514 RR |
2596 | } |
2597 | ||
442c56e6 | 2598 | unsigned int wxDataViewMainWindow::GetLastVisibleRow() |
72664514 RR |
2599 | { |
2600 | wxSize client_size = GetClientSize(); | |
c741d33f | 2601 | m_owner->CalcUnscrolledPosition( client_size.x, client_size.y, |
977a41ec | 2602 | &client_size.x, &client_size.y ); |
72664514 | 2603 | |
bc4f1ff2 | 2604 | // we should deal with the pixel here |
344ed1f3 | 2605 | unsigned int row = GetLineAt(client_size.y) - 1; |
b7fe2261 | 2606 | |
fbda518c | 2607 | return wxMin( GetRowCount()-1, row ); |
72664514 RR |
2608 | } |
2609 | ||
f2bf2d71 | 2610 | unsigned int wxDataViewMainWindow::GetRowCount() const |
cab07038 | 2611 | { |
3b6280be RR |
2612 | if ( m_count == -1 ) |
2613 | { | |
f2bf2d71 VZ |
2614 | wxDataViewMainWindow* const |
2615 | self = const_cast<wxDataViewMainWindow*>(this); | |
2616 | self->m_count = RecalculateCount(); | |
2617 | self->UpdateDisplay(); | |
3b6280be | 2618 | } |
aba9bfd0 | 2619 | return m_count; |
cab07038 RR |
2620 | } |
2621 | ||
0a71f9e9 | 2622 | void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row ) |
e21f75bd RR |
2623 | { |
2624 | m_currentRow = row; | |
120b9b05 | 2625 | |
e21f75bd RR |
2626 | // send event |
2627 | } | |
2628 | ||
cab07038 RR |
2629 | void wxDataViewMainWindow::SelectAllRows( bool on ) |
2630 | { | |
4a851b11 VZ |
2631 | if (IsEmpty()) |
2632 | return; | |
120b9b05 | 2633 | |
cab07038 RR |
2634 | if (on) |
2635 | { | |
72664514 | 2636 | m_selection.Clear(); |
0a71f9e9 | 2637 | for (unsigned int i = 0; i < GetRowCount(); i++) |
cab07038 | 2638 | m_selection.Add( i ); |
72664514 RR |
2639 | Refresh(); |
2640 | } | |
2641 | else | |
2642 | { | |
0a71f9e9 RR |
2643 | unsigned int first_visible = GetFirstVisibleRow(); |
2644 | unsigned int last_visible = GetLastVisibleRow(); | |
2645 | unsigned int i; | |
72664514 | 2646 | for (i = 0; i < m_selection.GetCount(); i++) |
120b9b05 | 2647 | { |
0a71f9e9 | 2648 | unsigned int row = m_selection[i]; |
72664514 RR |
2649 | if ((row >= first_visible) && (row <= last_visible)) |
2650 | RefreshRow( row ); | |
2651 | } | |
2652 | m_selection.Clear(); | |
cab07038 | 2653 | } |
cab07038 RR |
2654 | } |
2655 | ||
0a71f9e9 | 2656 | void wxDataViewMainWindow::SelectRow( unsigned int row, bool on ) |
cab07038 RR |
2657 | { |
2658 | if (m_selection.Index( row ) == wxNOT_FOUND) | |
2659 | { | |
2660 | if (on) | |
2661 | { | |
2662 | m_selection.Add( row ); | |
2663 | RefreshRow( row ); | |
2664 | } | |
2665 | } | |
2666 | else | |
2667 | { | |
2668 | if (!on) | |
2669 | { | |
2670 | m_selection.Remove( row ); | |
2671 | RefreshRow( row ); | |
2672 | } | |
2673 | } | |
2674 | } | |
2675 | ||
0a71f9e9 | 2676 | void wxDataViewMainWindow::SelectRows( unsigned int from, unsigned int to, bool on ) |
cab07038 RR |
2677 | { |
2678 | if (from > to) | |
2679 | { | |
0a71f9e9 | 2680 | unsigned int tmp = from; |
cab07038 RR |
2681 | from = to; |
2682 | to = tmp; | |
2683 | } | |
2684 | ||
0a71f9e9 | 2685 | unsigned int i; |
cab07038 RR |
2686 | for (i = from; i <= to; i++) |
2687 | { | |
2688 | if (m_selection.Index( i ) == wxNOT_FOUND) | |
2689 | { | |
2690 | if (on) | |
2691 | m_selection.Add( i ); | |
2692 | } | |
2693 | else | |
2694 | { | |
2695 | if (!on) | |
2696 | m_selection.Remove( i ); | |
2697 | } | |
2698 | } | |
2699 | RefreshRows( from, to ); | |
2700 | } | |
2701 | ||
87f0efe2 RR |
2702 | void wxDataViewMainWindow::Select( const wxArrayInt& aSelections ) |
2703 | { | |
2704 | for (size_t i=0; i < aSelections.GetCount(); i++) | |
2705 | { | |
2706 | int n = aSelections[i]; | |
2707 | ||
2708 | m_selection.Add( n ); | |
2709 | RefreshRow( n ); | |
2710 | } | |
2711 | } | |
2712 | ||
0a71f9e9 | 2713 | void wxDataViewMainWindow::ReverseRowSelection( unsigned int row ) |
cab07038 RR |
2714 | { |
2715 | if (m_selection.Index( row ) == wxNOT_FOUND) | |
2716 | m_selection.Add( row ); | |
2717 | else | |
2718 | m_selection.Remove( row ); | |
120b9b05 | 2719 | RefreshRow( row ); |
cab07038 RR |
2720 | } |
2721 | ||
0a71f9e9 | 2722 | bool wxDataViewMainWindow::IsRowSelected( unsigned int row ) |
cab07038 RR |
2723 | { |
2724 | return (m_selection.Index( row ) != wxNOT_FOUND); | |
2725 | } | |
2726 | ||
526e19e2 RR |
2727 | void wxDataViewMainWindow::SendSelectionChangedEvent( const wxDataViewItem& item) |
2728 | { | |
2729 | wxWindow *parent = GetParent(); | |
2730 | wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, parent->GetId()); | |
2731 | ||
2732 | le.SetEventObject(parent); | |
c2c89730 | 2733 | le.SetModel(GetModel()); |
526e19e2 RR |
2734 | le.SetItem( item ); |
2735 | ||
857f05e1 | 2736 | parent->ProcessWindowEvent(le); |
526e19e2 RR |
2737 | } |
2738 | ||
0a71f9e9 | 2739 | void wxDataViewMainWindow::RefreshRow( unsigned int row ) |
cab07038 | 2740 | { |
344ed1f3 | 2741 | wxRect rect( 0, GetLineStart( row ), GetEndOfLastCol(), GetLineHeight( row ) ); |
cab07038 | 2742 | m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y ); |
120b9b05 | 2743 | |
cab07038 RR |
2744 | wxSize client_size = GetClientSize(); |
2745 | wxRect client_rect( 0, 0, client_size.x, client_size.y ); | |
2746 | wxRect intersect_rect = client_rect.Intersect( rect ); | |
2747 | if (intersect_rect.width > 0) | |
2748 | Refresh( true, &intersect_rect ); | |
2749 | } | |
2750 | ||
0a71f9e9 | 2751 | void wxDataViewMainWindow::RefreshRows( unsigned int from, unsigned int to ) |
cab07038 RR |
2752 | { |
2753 | if (from > to) | |
2754 | { | |
0a71f9e9 | 2755 | unsigned int tmp = to; |
cab07038 RR |
2756 | to = from; |
2757 | from = tmp; | |
2758 | } | |
2759 | ||
344ed1f3 | 2760 | wxRect rect( 0, GetLineStart( from ), GetEndOfLastCol(), GetLineStart( (to-from+1) ) ); |
cab07038 | 2761 | m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y ); |
120b9b05 | 2762 | |
cab07038 RR |
2763 | wxSize client_size = GetClientSize(); |
2764 | wxRect client_rect( 0, 0, client_size.x, client_size.y ); | |
2765 | wxRect intersect_rect = client_rect.Intersect( rect ); | |
2766 | if (intersect_rect.width > 0) | |
2767 | Refresh( true, &intersect_rect ); | |
2768 | } | |
2769 | ||
0a71f9e9 | 2770 | void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow ) |
cab07038 | 2771 | { |
cab07038 | 2772 | wxSize client_size = GetClientSize(); |
344ed1f3 RR |
2773 | int start = GetLineStart( firstRow ); |
2774 | m_owner->CalcScrolledPosition( start, 0, &start, NULL ); | |
2775 | if (start > client_size.y) return; | |
2776 | ||
2777 | wxRect rect( 0, start, client_size.x, client_size.y - start ); | |
777f9cef | 2778 | |
344ed1f3 | 2779 | Refresh( true, &rect ); |
cab07038 RR |
2780 | } |
2781 | ||
9861f022 RR |
2782 | wxRect wxDataViewMainWindow::GetLineRect( unsigned int row ) const |
2783 | { | |
2784 | wxRect rect; | |
2785 | rect.x = 0; | |
344ed1f3 | 2786 | rect.y = GetLineStart( row ); |
9861f022 | 2787 | rect.width = GetEndOfLastCol(); |
344ed1f3 | 2788 | rect.height = GetLineHeight( row ); |
9861f022 RR |
2789 | |
2790 | return rect; | |
cab07038 RR |
2791 | } |
2792 | ||
344ed1f3 RR |
2793 | int wxDataViewMainWindow::GetLineStart( unsigned int row ) const |
2794 | { | |
c2c89730 | 2795 | const wxDataViewModel *model = GetModel(); |
777f9cef | 2796 | |
344ed1f3 RR |
2797 | if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) |
2798 | { | |
2799 | // TODO make more efficient | |
777f9cef | 2800 | |
344ed1f3 | 2801 | int start = 0; |
777f9cef | 2802 | |
344ed1f3 RR |
2803 | unsigned int r; |
2804 | for (r = 0; r < row; r++) | |
2805 | { | |
e170469f RR |
2806 | const wxDataViewTreeNode* node = GetTreeNodeByRow(r); |
2807 | if (!node) return start; | |
777f9cef | 2808 | |
e170469f | 2809 | wxDataViewItem item = node->GetItem(); |
777f9cef | 2810 | |
e170469f RR |
2811 | unsigned int cols = GetOwner()->GetColumnCount(); |
2812 | unsigned int col; | |
2813 | int height = m_lineHeight; | |
2814 | for (col = 0; col < cols; col++) | |
2815 | { | |
344ed1f3 RR |
2816 | const wxDataViewColumn *column = GetOwner()->GetColumn(col); |
2817 | if (column->IsHidden()) | |
2818 | continue; // skip it! | |
777f9cef | 2819 | |
4cef3873 VZ |
2820 | if ((col != 0) && |
2821 | model->IsContainer(item) && | |
ce468dc2 | 2822 | !model->HasContainerColumns(item)) |
ba5f54e6 | 2823 | continue; // skip it! |
777f9cef | 2824 | |
4cef3873 | 2825 | wxDataViewRenderer *renderer = |
ce468dc2 | 2826 | const_cast<wxDataViewRenderer*>(column->GetRenderer()); |
f0ccd2cb | 2827 | renderer->PrepareForItem(model, item, column->GetModelColumn()); |
86755098 | 2828 | |
344ed1f3 | 2829 | height = wxMax( height, renderer->GetSize().y ); |
e170469f | 2830 | } |
777f9cef | 2831 | |
e170469f | 2832 | start += height; |
344ed1f3 | 2833 | } |
777f9cef | 2834 | |
344ed1f3 RR |
2835 | return start; |
2836 | } | |
2837 | else | |
2838 | { | |
2839 | return row * m_lineHeight; | |
2840 | } | |
2841 | } | |
2842 | ||
2843 | int wxDataViewMainWindow::GetLineAt( unsigned int y ) const | |
2844 | { | |
c2c89730 | 2845 | const wxDataViewModel *model = GetModel(); |
ba5f54e6 | 2846 | |
777f9cef VZ |
2847 | // check for the easy case first |
2848 | if ( !GetOwner()->HasFlag(wxDV_VARIABLE_LINE_HEIGHT) ) | |
2849 | return y / m_lineHeight; | |
2850 | ||
2851 | // TODO make more efficient | |
2852 | unsigned int row = 0; | |
2853 | unsigned int yy = 0; | |
2854 | for (;;) | |
344ed1f3 | 2855 | { |
ce468dc2 FM |
2856 | const wxDataViewTreeNode* node = GetTreeNodeByRow(row); |
2857 | if (!node) | |
2858 | { | |
2859 | // not really correct... | |
2860 | return row + ((y-yy) / m_lineHeight); | |
2861 | } | |
777f9cef | 2862 | |
ce468dc2 | 2863 | wxDataViewItem item = node->GetItem(); |
777f9cef | 2864 | |
ce468dc2 FM |
2865 | unsigned int cols = GetOwner()->GetColumnCount(); |
2866 | unsigned int col; | |
2867 | int height = m_lineHeight; | |
2868 | for (col = 0; col < cols; col++) | |
2869 | { | |
777f9cef VZ |
2870 | const wxDataViewColumn *column = GetOwner()->GetColumn(col); |
2871 | if (column->IsHidden()) | |
2872 | continue; // skip it! | |
2873 | ||
4cef3873 VZ |
2874 | if ((col != 0) && |
2875 | model->IsContainer(item) && | |
ce468dc2 | 2876 | !model->HasContainerColumns(item)) |
777f9cef VZ |
2877 | continue; // skip it! |
2878 | ||
4cef3873 | 2879 | wxDataViewRenderer *renderer = |
ce468dc2 | 2880 | const_cast<wxDataViewRenderer*>(column->GetRenderer()); |
f0ccd2cb | 2881 | renderer->PrepareForItem(model, item, column->GetModelColumn()); |
86755098 | 2882 | |
777f9cef | 2883 | height = wxMax( height, renderer->GetSize().y ); |
ce468dc2 | 2884 | } |
777f9cef | 2885 | |
ce468dc2 FM |
2886 | yy += height; |
2887 | if (y < yy) | |
2888 | return row; | |
777f9cef | 2889 | |
ce468dc2 | 2890 | row++; |
344ed1f3 RR |
2891 | } |
2892 | } | |
2893 | ||
2894 | int wxDataViewMainWindow::GetLineHeight( unsigned int row ) const | |
2895 | { | |
c2c89730 | 2896 | const wxDataViewModel *model = GetModel(); |
777f9cef | 2897 | |
344ed1f3 RR |
2898 | if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT) |
2899 | { | |
2900 | wxASSERT( !IsVirtualList() ); | |
777f9cef | 2901 | |
344ed1f3 RR |
2902 | const wxDataViewTreeNode* node = GetTreeNodeByRow(row); |
2903 | // wxASSERT( node ); | |
2904 | if (!node) return m_lineHeight; | |
2905 | ||
ba5f54e6 | 2906 | wxDataViewItem item = node->GetItem(); |
777f9cef | 2907 | |
981cd83e | 2908 | int height = m_lineHeight; |
777f9cef | 2909 | |
344ed1f3 RR |
2910 | unsigned int cols = GetOwner()->GetColumnCount(); |
2911 | unsigned int col; | |
2912 | for (col = 0; col < cols; col++) | |
2913 | { | |
2914 | const wxDataViewColumn *column = GetOwner()->GetColumn(col); | |
2915 | if (column->IsHidden()) | |
2916 | continue; // skip it! | |
ba5f54e6 | 2917 | |
4cef3873 VZ |
2918 | if ((col != 0) && |
2919 | model->IsContainer(item) && | |
ce468dc2 | 2920 | !model->HasContainerColumns(item)) |
ba5f54e6 | 2921 | continue; // skip it! |
777f9cef | 2922 | |
4cef3873 | 2923 | wxDataViewRenderer *renderer = |
ce468dc2 | 2924 | const_cast<wxDataViewRenderer*>(column->GetRenderer()); |
f0ccd2cb | 2925 | renderer->PrepareForItem(model, item, column->GetModelColumn()); |
86755098 | 2926 | |
344ed1f3 RR |
2927 | height = wxMax( height, renderer->GetSize().y ); |
2928 | } | |
2929 | ||
2930 | return height; | |
2931 | } | |
2932 | else | |
2933 | { | |
2934 | return m_lineHeight; | |
2935 | } | |
2936 | } | |
2937 | ||
aba9bfd0 | 2938 | |
3b6280be RR |
2939 | class RowToTreeNodeJob: public DoJob |
2940 | { | |
2941 | public: | |
442c56e6 VZ |
2942 | RowToTreeNodeJob( unsigned int row , int current, wxDataViewTreeNode * node ) |
2943 | { | |
2944 | this->row = row; | |
59e60167 VZ |
2945 | this->current = current; |
2946 | ret = NULL; | |
d47db7e0 RR |
2947 | parent = node; |
2948 | } | |
3b6280be RR |
2949 | |
2950 | virtual int operator() ( wxDataViewTreeNode * node ) | |
d5025dc0 | 2951 | { |
d47db7e0 | 2952 | current ++; |
704c3490 | 2953 | if( current == static_cast<int>(row)) |
977a41ec | 2954 | { |
59e60167 | 2955 | ret = node; |
d54f0605 | 2956 | return DoJob::DONE; |
3b6280be | 2957 | } |
d47db7e0 RR |
2958 | |
2959 | if( node->GetSubTreeCount() + current < static_cast<int>(row) ) | |
2960 | { | |
2961 | current += node->GetSubTreeCount(); | |
d54f0605 | 2962 | return DoJob::SKIP_SUBTREE; |
d47db7e0 | 2963 | } |
d5025dc0 | 2964 | else |
d47db7e0 RR |
2965 | { |
2966 | parent = node; | |
bc4f1ff2 | 2967 | |
422aa8ec VS |
2968 | // If the current node has only leaf children, we can find the |
2969 | // desired node directly. This can speed up finding the node | |
2970 | // in some cases, and will have a very good effect for list views. | |
d0cfefc4 | 2971 | if ( node->HasChildren() && |
ff3c5ad3 | 2972 | (int)node->GetChildNodes().size() == node->GetSubTreeCount() ) |
b7e9f8b1 | 2973 | { |
422aa8ec | 2974 | const int index = static_cast<int>(row) - current - 1; |
ff3c5ad3 | 2975 | ret = node->GetChildNodes()[index]; |
d54f0605 | 2976 | return DoJob::DONE; |
b7e9f8b1 | 2977 | } |
d0cfefc4 | 2978 | |
d54f0605 | 2979 | return DoJob::CONTINUE; |
d47db7e0 | 2980 | } |
d5025dc0 | 2981 | } |
3b6280be | 2982 | |
bc4f1ff2 FM |
2983 | wxDataViewTreeNode * GetResult() const |
2984 | { return ret; } | |
2985 | ||
3b6280be RR |
2986 | private: |
2987 | unsigned int row; | |
59e60167 | 2988 | int current; |
3b6280be | 2989 | wxDataViewTreeNode * ret; |
59e60167 | 2990 | wxDataViewTreeNode * parent; |
3b6280be RR |
2991 | }; |
2992 | ||
344ed1f3 | 2993 | wxDataViewTreeNode * wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row) const |
3b6280be | 2994 | { |
344ed1f3 | 2995 | wxASSERT( !IsVirtualList() ); |
777f9cef | 2996 | |
344ed1f3 RR |
2997 | RowToTreeNodeJob job( row , -2, m_root ); |
2998 | Walker( m_root , job ); | |
2999 | return job.GetResult(); | |
3b6280be RR |
3000 | } |
3001 | ||
422aa8ec VS |
3002 | wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) const |
3003 | { | |
b0272c60 | 3004 | wxDataViewItem item; |
422aa8ec VS |
3005 | if (IsVirtualList()) |
3006 | { | |
b0272c60 VZ |
3007 | if ( row < GetRowCount() ) |
3008 | item = wxDataViewItem(wxUIntToPtr(row+1)); | |
422aa8ec VS |
3009 | } |
3010 | else | |
3011 | { | |
3012 | wxDataViewTreeNode *node = GetTreeNodeByRow(row); | |
b0272c60 VZ |
3013 | if ( node ) |
3014 | item = node->GetItem(); | |
422aa8ec | 3015 | } |
b0272c60 VZ |
3016 | |
3017 | return item; | |
422aa8ec VS |
3018 | } |
3019 | ||
fd48fe89 VZ |
3020 | bool |
3021 | wxDataViewMainWindow::SendExpanderEvent(wxEventType type, | |
3022 | const wxDataViewItem& item) | |
66e09788 RR |
3023 | { |
3024 | wxWindow *parent = GetParent(); | |
3025 | wxDataViewEvent le(type, parent->GetId()); | |
3026 | ||
3027 | le.SetEventObject(parent); | |
c2c89730 | 3028 | le.SetModel(GetModel()); |
66e09788 RR |
3029 | le.SetItem( item ); |
3030 | ||
fd48fe89 | 3031 | return !parent->ProcessWindowEvent(le) || le.IsAllowed(); |
66e09788 RR |
3032 | } |
3033 | ||
739a8399 RR |
3034 | bool wxDataViewMainWindow::IsExpanded( unsigned int row ) const |
3035 | { | |
ce5abbf9 | 3036 | if (IsList()) |
bc4f1ff2 | 3037 | return false; |
9adeb77a | 3038 | |
739a8399 RR |
3039 | wxDataViewTreeNode * node = GetTreeNodeByRow(row); |
3040 | if (!node) | |
bc4f1ff2 | 3041 | return false; |
9adeb77a | 3042 | |
739a8399 | 3043 | if (!node->HasChildren()) |
bc4f1ff2 | 3044 | return false; |
9adeb77a | 3045 | |
739a8399 RR |
3046 | return node->IsOpen(); |
3047 | } | |
3048 | ||
235d5f88 RR |
3049 | bool wxDataViewMainWindow::HasChildren( unsigned int row ) const |
3050 | { | |
ce5abbf9 | 3051 | if (IsList()) |
235d5f88 RR |
3052 | return false; |
3053 | ||
3054 | wxDataViewTreeNode * node = GetTreeNodeByRow(row); | |
3055 | if (!node) | |
3056 | return false; | |
739a8399 | 3057 | |
235d5f88 | 3058 | if (!node->HasChildren()) |
235d5f88 | 3059 | return false; |
235d5f88 RR |
3060 | |
3061 | return true; | |
3062 | } | |
3063 | ||
3064 | void wxDataViewMainWindow::Expand( unsigned int row ) | |
3b6280be | 3065 | { |
ce5abbf9 | 3066 | if (IsList()) |
bc4f1ff2 | 3067 | return; |
9657c197 | 3068 | |
3b6280be | 3069 | wxDataViewTreeNode * node = GetTreeNodeByRow(row); |
235d5f88 RR |
3070 | if (!node) |
3071 | return; | |
4cef3873 | 3072 | |
235d5f88 | 3073 | if (!node->HasChildren()) |
235d5f88 | 3074 | return; |
4cef3873 | 3075 | |
235d5f88 | 3076 | if (!node->IsOpen()) |
3b6280be | 3077 | { |
fd48fe89 VZ |
3078 | if ( !SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING, node->GetItem()) ) |
3079 | { | |
3080 | // Vetoed by the event handler. | |
66e09788 | 3081 | return; |
fd48fe89 | 3082 | } |
b7fe2261 | 3083 | |
bc4f1ff2 | 3084 | node->ToggleOpen(); |
977a41ec | 3085 | |
bc4f1ff2 | 3086 | // build the children of current node |
ff3c5ad3 | 3087 | if( node->GetChildNodes().empty() ) |
bc4f1ff2 FM |
3088 | { |
3089 | SortPrepare(); | |
c2c89730 | 3090 | ::BuildTreeHelper(GetModel(), node->GetItem(), node); |
bc4f1ff2 | 3091 | } |
977a41ec | 3092 | |
bc4f1ff2 FM |
3093 | // By expanding the node all row indices that are currently in the selection list |
3094 | // and are greater than our node have become invalid. So we have to correct that now. | |
3095 | const unsigned rowAdjustment = node->GetSubTreeCount(); | |
3096 | for(unsigned i=0; i<m_selection.size(); ++i) | |
3097 | { | |
3098 | const unsigned testRow = m_selection[i]; | |
3099 | // all rows above us are not affected, so skip them | |
3100 | if(testRow <= row) | |
3101 | continue; | |
3102 | ||
3103 | m_selection[i] += rowAdjustment; | |
3104 | } | |
977a41ec | 3105 | |
bc4f1ff2 FM |
3106 | if(m_currentRow > row) |
3107 | ChangeCurrentRow(m_currentRow + rowAdjustment); | |
977a41ec | 3108 | |
bc4f1ff2 FM |
3109 | m_count = -1; |
3110 | UpdateDisplay(); | |
3111 | // Send the expanded event | |
3112 | SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,node->GetItem()); | |
351461fc | 3113 | } |
3b6280be RR |
3114 | } |
3115 | ||
235d5f88 | 3116 | void wxDataViewMainWindow::Collapse(unsigned int row) |
3b6280be | 3117 | { |
ce5abbf9 | 3118 | if (IsList()) |
bc4f1ff2 | 3119 | return; |
e822d1bd | 3120 | |
7d835958 RR |
3121 | wxDataViewTreeNode *node = GetTreeNodeByRow(row); |
3122 | if (!node) | |
3123 | return; | |
4cef3873 | 3124 | |
235d5f88 | 3125 | if (!node->HasChildren()) |
7d835958 | 3126 | return; |
d47db7e0 | 3127 | |
235d5f88 | 3128 | if (node->IsOpen()) |
3b6280be | 3129 | { |
fd48fe89 VZ |
3130 | if ( !SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,node->GetItem()) ) |
3131 | { | |
3132 | // Vetoed by the event handler. | |
66e09788 | 3133 | return; |
fd48fe89 | 3134 | } |
abdb8c18 | 3135 | |
977a41ec FM |
3136 | // Find out if there are selected items below the current node. |
3137 | bool selectCollapsingRow = false; | |
3138 | const unsigned rowAdjustment = node->GetSubTreeCount(); | |
3139 | unsigned maxRowToBeTested = row + rowAdjustment; | |
3140 | for(unsigned i=0; i<m_selection.size(); ++i) | |
3141 | { | |
3142 | const unsigned testRow = m_selection[i]; | |
3143 | if(testRow > row && testRow <= maxRowToBeTested) | |
3144 | { | |
3145 | selectCollapsingRow = true; | |
3146 | // get out as soon as we have found a node that is selected | |
3147 | break; | |
3148 | } | |
3149 | } | |
3150 | ||
3151 | node->ToggleOpen(); | |
3152 | ||
3153 | // If the node to be closed has selected items the user won't see those any longer. | |
3154 | // We select the collapsing node in this case. | |
3155 | if(selectCollapsingRow) | |
3156 | { | |
3157 | SelectAllRows(false); | |
3158 | ChangeCurrentRow(row); | |
3159 | SelectRow(row, true); | |
3160 | SendSelectionChangedEvent(GetItemByRow(row)); | |
3161 | } | |
3162 | else | |
3163 | { | |
3164 | // if there were no selected items below our node we still need to "fix" the | |
3165 | // selection list to adjust for the changing of the row indices. | |
235d5f88 | 3166 | // We actually do the opposite of what we are doing in Expand(). |
977a41ec FM |
3167 | for(unsigned i=0; i<m_selection.size(); ++i) |
3168 | { | |
3169 | const unsigned testRow = m_selection[i]; | |
3170 | // all rows above us are not affected, so skip them | |
3171 | if(testRow <= row) | |
3172 | continue; | |
3173 | ||
3174 | m_selection[i] -= rowAdjustment; | |
3175 | } | |
3176 | ||
3177 | // if the "current row" is being collapsed away we change it to the current row ;-) | |
3178 | if(m_currentRow > row && m_currentRow <= maxRowToBeTested) | |
3179 | ChangeCurrentRow(row); | |
3180 | else if(m_currentRow > row) | |
3181 | ChangeCurrentRow(m_currentRow - rowAdjustment); | |
3182 | } | |
abdb8c18 | 3183 | |
3b6280be | 3184 | m_count = -1; |
351461fc | 3185 | UpdateDisplay(); |
7d835958 | 3186 | SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,node->GetItem()); |
66e09788 | 3187 | } |
3b6280be RR |
3188 | } |
3189 | ||
351461fc RR |
3190 | wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item ) |
3191 | { | |
c2c89730 | 3192 | const wxDataViewModel * model = GetModel(); |
351461fc RR |
3193 | if( model == NULL ) |
3194 | return NULL; | |
9adeb77a | 3195 | |
ce2fe798 RR |
3196 | if (!item.IsOk()) |
3197 | return m_root; | |
351461fc | 3198 | |
10875c13 VZ |
3199 | // Compose the parent-chain for the item we are looking for |
3200 | wxVector<wxDataViewItem> parentChain; | |
351461fc RR |
3201 | wxDataViewItem it( item ); |
3202 | while( it.IsOk() ) | |
3203 | { | |
10875c13 VZ |
3204 | parentChain.push_back(it); |
3205 | it = model->GetParent(it); | |
351461fc RR |
3206 | } |
3207 | ||
bc4f1ff2 FM |
3208 | // Find the item along the parent-chain. |
3209 | // This algorithm is designed to speed up the node-finding method | |
10875c13 | 3210 | wxDataViewTreeNode* node = m_root; |
99ef4372 | 3211 | for( unsigned iter = parentChain.size()-1; ; --iter ) |
351461fc RR |
3212 | { |
3213 | if( node->HasChildren() ) | |
3214 | { | |
ff3c5ad3 | 3215 | if( node->GetChildNodes().empty() ) |
24c4a50f | 3216 | { |
422aa8ec VS |
3217 | // Even though the item is a container, it doesn't have any |
3218 | // child nodes in the control's representation yet. We have | |
3219 | // to realize its subtree now. | |
24c4a50f | 3220 | SortPrepare(); |
74123073 | 3221 | ::BuildTreeHelper(model, node->GetItem(), node); |
24c4a50f | 3222 | } |
351461fc | 3223 | |
ff3c5ad3 | 3224 | const wxDataViewTreeNodes& nodes = node->GetChildNodes(); |
d2c1ee8a | 3225 | bool found = false; |
777f9cef | 3226 | |
10875c13 | 3227 | for (unsigned i = 0; i < nodes.GetCount(); ++i) |
d92cb015 | 3228 | { |
10875c13 VZ |
3229 | wxDataViewTreeNode* currentNode = nodes[i]; |
3230 | if (currentNode->GetItem() == parentChain[iter]) | |
b7fe2261 | 3231 | { |
10875c13 VZ |
3232 | if (currentNode->GetItem() == item) |
3233 | return currentNode; | |
777f9cef | 3234 | |
10875c13 | 3235 | node = currentNode; |
d2c1ee8a | 3236 | found = true; |
d92cb015 RR |
3237 | break; |
3238 | } | |
3239 | } | |
d2c1ee8a | 3240 | if (!found) |
351461fc | 3241 | return NULL; |
351461fc RR |
3242 | } |
3243 | else | |
3244 | return NULL; | |
99ef4372 VZ |
3245 | |
3246 | if ( !iter ) | |
3247 | break; | |
351461fc | 3248 | } |
d2c1ee8a | 3249 | return NULL; |
351461fc RR |
3250 | } |
3251 | ||
4cef3873 | 3252 | void wxDataViewMainWindow::HitTest( const wxPoint & point, wxDataViewItem & item, |
bc4f1ff2 | 3253 | wxDataViewColumn* &column ) |
66e09788 | 3254 | { |
fbda518c | 3255 | wxDataViewColumn *col = NULL; |
66e09788 RR |
3256 | unsigned int cols = GetOwner()->GetColumnCount(); |
3257 | unsigned int colnum = 0; | |
66e09788 RR |
3258 | int x, y; |
3259 | m_owner->CalcUnscrolledPosition( point.x, point.y, &x, &y ); | |
e822d1bd | 3260 | for (unsigned x_start = 0; colnum < cols; colnum++) |
66e09788 | 3261 | { |
702f5349 | 3262 | col = GetOwner()->GetColumnAt(colnum); |
66e09788 RR |
3263 | if (col->IsHidden()) |
3264 | continue; // skip it! | |
3265 | ||
3266 | unsigned int w = col->GetWidth(); | |
3267 | if (x_start+w >= (unsigned int)x) | |
3268 | break; | |
3269 | ||
3270 | x_start += w; | |
3271 | } | |
3272 | ||
fbda518c | 3273 | column = col; |
344ed1f3 | 3274 | item = GetItemByRow( GetLineAt( y ) ); |
66e09788 RR |
3275 | } |
3276 | ||
4cef3873 | 3277 | wxRect wxDataViewMainWindow::GetItemRect( const wxDataViewItem & item, |
bc4f1ff2 | 3278 | const wxDataViewColumn* column ) |
66e09788 | 3279 | { |
c937344c RR |
3280 | int xpos = 0; |
3281 | int width = 0; | |
4cef3873 | 3282 | |
c937344c RR |
3283 | unsigned int cols = GetOwner()->GetColumnCount(); |
3284 | // If column is null the loop will compute the combined width of all columns. | |
3285 | // Otherwise, it will compute the x position of the column we are looking for. | |
3286 | for (unsigned int i = 0; i < cols; i++) | |
3287 | { | |
3288 | wxDataViewColumn* col = GetOwner()->GetColumnAt( i ); | |
3289 | ||
3290 | if (col == column) | |
3291 | break; | |
3292 | ||
3293 | if (col->IsHidden()) | |
3294 | continue; // skip it! | |
3295 | ||
3296 | xpos += col->GetWidth(); | |
3297 | width += col->GetWidth(); | |
3298 | } | |
3299 | ||
3300 | if(column != 0) | |
3301 | { | |
3302 | // If we have a column, we need can get its width directly. | |
3303 | if(column->IsHidden()) | |
3304 | width = 0; | |
3305 | else | |
3306 | width = column->GetWidth(); | |
3307 | ||
3308 | } | |
3309 | else | |
3310 | { | |
3311 | // If we have no column, we reset the x position back to zero. | |
3312 | xpos = 0; | |
3313 | } | |
3314 | ||
3315 | // we have to take an expander column into account and compute its indentation | |
3316 | // to get the correct x position where the actual text is | |
3317 | int indent = 0; | |
66e09788 | 3318 | int row = GetRowByItem(item); |
1841f079 VZ |
3319 | if (!IsList() && |
3320 | (column == 0 || GetExpanderColumnOrFirstOne(GetOwner()) == column) ) | |
66e09788 | 3321 | { |
c937344c RR |
3322 | wxDataViewTreeNode* node = GetTreeNodeByRow(row); |
3323 | indent = GetOwner()->GetIndent() * node->GetIndentLevel(); | |
03647350 | 3324 | indent = indent + m_lineHeight; // use m_lineHeight as the width of the expander |
66e09788 | 3325 | } |
c937344c RR |
3326 | |
3327 | wxRect itemRect( xpos + indent, | |
3328 | GetLineStart( row ), | |
3329 | width - indent, | |
3330 | GetLineHeight( row ) ); | |
3331 | ||
3332 | GetOwner()->CalcScrolledPosition( itemRect.x, itemRect.y, | |
3333 | &itemRect.x, &itemRect.y ); | |
3334 | ||
3335 | return itemRect; | |
66e09788 RR |
3336 | } |
3337 | ||
f2bf2d71 | 3338 | int wxDataViewMainWindow::RecalculateCount() const |
3b6280be | 3339 | { |
86ba79ed | 3340 | if (IsVirtualList()) |
a3cc79d9 | 3341 | { |
9330d5af | 3342 | wxDataViewVirtualListModel *list_model = |
c2c89730 | 3343 | (wxDataViewVirtualListModel*) GetModel(); |
03647350 | 3344 | |
9330d5af | 3345 | return list_model->GetCount(); |
a3cc79d9 RR |
3346 | } |
3347 | else | |
3348 | { | |
3349 | return m_root->GetSubTreeCount(); | |
3350 | } | |
3b6280be RR |
3351 | } |
3352 | ||
aba9bfd0 RR |
3353 | class ItemToRowJob : public DoJob |
3354 | { | |
3355 | public: | |
10875c13 | 3356 | ItemToRowJob(const wxDataViewItem& item_, wxVector<wxDataViewItem>::reverse_iterator iter) |
59e60167 | 3357 | : m_iter(iter), |
977a41ec | 3358 | item(item_) |
59e60167 VZ |
3359 | { |
3360 | ret = -1; | |
3361 | } | |
aba9bfd0 | 3362 | |
bc4f1ff2 | 3363 | // Maybe binary search will help to speed up this process |
d5025dc0 RR |
3364 | virtual int operator() ( wxDataViewTreeNode * node) |
3365 | { | |
977a41ec FM |
3366 | ret ++; |
3367 | if( node->GetItem() == item ) | |
3368 | { | |
d54f0605 | 3369 | return DoJob::DONE; |
977a41ec | 3370 | } |
d5025dc0 | 3371 | |
10875c13 | 3372 | if( node->GetItem() == *m_iter ) |
977a41ec FM |
3373 | { |
3374 | m_iter++; | |
d54f0605 | 3375 | return DoJob::CONTINUE; |
977a41ec FM |
3376 | } |
3377 | else | |
3378 | { | |
3379 | ret += node->GetSubTreeCount(); | |
d54f0605 | 3380 | return DoJob::SKIP_SUBTREE; |
977a41ec | 3381 | } |
442c56e6 | 3382 | |
d5025dc0 | 3383 | } |
aba9bfd0 | 3384 | |
bc4f1ff2 FM |
3385 | // the row number is begin from zero |
3386 | int GetResult() const | |
3387 | { return ret -1; } | |
59e60167 | 3388 | |
aba9bfd0 | 3389 | private: |
10875c13 | 3390 | wxVector<wxDataViewItem>::reverse_iterator m_iter; |
aba9bfd0 RR |
3391 | wxDataViewItem item; |
3392 | int ret; | |
442c56e6 | 3393 | |
aba9bfd0 RR |
3394 | }; |
3395 | ||
344ed1f3 | 3396 | int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) const |
aba9bfd0 | 3397 | { |
c2c89730 | 3398 | const wxDataViewModel * model = GetModel(); |
d47db7e0 | 3399 | if( model == NULL ) |
fbda518c | 3400 | return -1; |
d47db7e0 | 3401 | |
86ba79ed | 3402 | if (IsVirtualList()) |
d47db7e0 | 3403 | { |
86ba79ed | 3404 | return wxPtrToUInt( item.GetID() ) -1; |
d47db7e0 | 3405 | } |
a3cc79d9 RR |
3406 | else |
3407 | { | |
3408 | if( !item.IsOk() ) | |
3409 | return -1; | |
3410 | ||
10875c13 VZ |
3411 | // Compose the parent-chain of the item we are looking for |
3412 | wxVector<wxDataViewItem> parentChain; | |
a3cc79d9 RR |
3413 | wxDataViewItem it( item ); |
3414 | while( it.IsOk() ) | |
3415 | { | |
10875c13 VZ |
3416 | parentChain.push_back(it); |
3417 | it = model->GetParent(it); | |
a3cc79d9 | 3418 | } |
d47db7e0 | 3419 | |
10875c13 VZ |
3420 | // add an 'invalid' item to represent our 'invisible' root node |
3421 | parentChain.push_back(wxDataViewItem()); | |
3422 | ||
3423 | // the parent chain was created by adding the deepest parent first. | |
3424 | // so if we want to start at the root node, we have to iterate backwards through the vector | |
3425 | ItemToRowJob job( item, parentChain.rbegin() ); | |
3426 | Walker( m_root, job ); | |
a3cc79d9 RR |
3427 | return job.GetResult(); |
3428 | } | |
aba9bfd0 RR |
3429 | } |
3430 | ||
10875c13 | 3431 | static void BuildTreeHelper( const wxDataViewModel * model, const wxDataViewItem & item, |
bc4f1ff2 | 3432 | wxDataViewTreeNode * node) |
aba9bfd0 | 3433 | { |
351461fc | 3434 | if( !model->IsContainer( item ) ) |
59e60167 | 3435 | return; |
442c56e6 | 3436 | |
c899416d RR |
3437 | wxDataViewItemArray children; |
3438 | unsigned int num = model->GetChildren( item, children); | |
9adeb77a | 3439 | |
422aa8ec | 3440 | for ( unsigned int index = 0; index < num; index++ ) |
aba9bfd0 | 3441 | { |
422aa8ec VS |
3442 | wxDataViewTreeNode *n = new wxDataViewTreeNode(node, children[index]); |
3443 | ||
3444 | if( model->IsContainer(children[index]) ) | |
59e60167 | 3445 | n->SetHasChildren( true ); |
422aa8ec | 3446 | |
35219832 | 3447 | node->InsertChild(n, index); |
aba9bfd0 | 3448 | } |
d47db7e0 | 3449 | |
422aa8ec VS |
3450 | wxASSERT( node->IsOpen() ); |
3451 | node->ChangeSubTreeCount(+num); | |
aba9bfd0 RR |
3452 | } |
3453 | ||
3454 | void wxDataViewMainWindow::BuildTree(wxDataViewModel * model) | |
3455 | { | |
51bdecff RR |
3456 | DestroyTree(); |
3457 | ||
c2c89730 | 3458 | if (GetModel()->IsVirtualListModel()) |
a3cc79d9 | 3459 | { |
59e60167 | 3460 | m_count = -1; |
a3cc79d9 RR |
3461 | return; |
3462 | } | |
3463 | ||
422aa8ec | 3464 | m_root = wxDataViewTreeNode::CreateRootNode(); |
51bdecff | 3465 | |
bc4f1ff2 | 3466 | // First we define a invalid item to fetch the top-level elements |
aba9bfd0 | 3467 | wxDataViewItem item; |
66e09788 | 3468 | SortPrepare(); |
3b6280be | 3469 | BuildTreeHelper( model, item, m_root); |
59e60167 | 3470 | m_count = -1; |
aba9bfd0 RR |
3471 | } |
3472 | ||
aba9bfd0 RR |
3473 | void wxDataViewMainWindow::DestroyTree() |
3474 | { | |
344ed1f3 | 3475 | if (!IsVirtualList()) |
51bdecff | 3476 | { |
a2d3c415 VS |
3477 | wxDELETE(m_root); |
3478 | m_count = 0; | |
51bdecff | 3479 | } |
aba9bfd0 RR |
3480 | } |
3481 | ||
1c8e71c9 VS |
3482 | wxDataViewColumn* |
3483 | wxDataViewMainWindow::FindColumnForEditing(const wxDataViewItem& item, wxDataViewCellMode mode) | |
3484 | { | |
3485 | // Edit the current column editable in 'mode'. If no column is focused | |
3486 | // (typically because the user has full row selected), try to find the | |
3487 | // first editable column (this would typically be a checkbox for | |
3488 | // wxDATAVIEW_CELL_ACTIVATABLE and we don't want to force the user to set | |
3489 | // focus on the checkbox column; or on the only editable text column). | |
3490 | ||
3491 | wxDataViewColumn *candidate = m_currentCol; | |
3492 | ||
3493 | if ( candidate && | |
cf5d4c76 | 3494 | !IsCellEditableInMode(item, candidate, mode) && |
1c8e71c9 VS |
3495 | !m_currentColSetByKeyboard ) |
3496 | { | |
3497 | // If current column was set by mouse to something not editable (in | |
3498 | // 'mode') and the user pressed Space/F2 to edit it, treat the | |
3499 | // situation as if there was whole-row focus, because that's what is | |
3500 | // visually indicated and the mouse click could very well be targeted | |
3501 | // on the row rather than on an individual cell. | |
3502 | // | |
3503 | // But if it was done by keyboard, respect that even if the column | |
3504 | // isn't editable, because focus is visually on that column and editing | |
3505 | // something else would be surprising. | |
3506 | candidate = NULL; | |
3507 | } | |
3508 | ||
3509 | if ( !candidate ) | |
3510 | { | |
3511 | const unsigned cols = GetOwner()->GetColumnCount(); | |
3512 | for ( unsigned i = 0; i < cols; i++ ) | |
3513 | { | |
3514 | wxDataViewColumn *c = GetOwner()->GetColumnAt(i); | |
3515 | if ( c->IsHidden() ) | |
3516 | continue; | |
3517 | ||
cf5d4c76 | 3518 | if ( IsCellEditableInMode(item, c, mode) ) |
1c8e71c9 VS |
3519 | { |
3520 | candidate = c; | |
3521 | break; | |
3522 | } | |
3523 | } | |
3524 | } | |
3525 | ||
3526 | // If on container item without columns, only the expander column | |
3527 | // may be directly editable: | |
3528 | if ( candidate && | |
3529 | GetOwner()->GetExpanderColumn() != candidate && | |
3530 | GetModel()->IsContainer(item) && | |
3531 | !GetModel()->HasContainerColumns(item) ) | |
3532 | { | |
3533 | candidate = GetOwner()->GetExpanderColumn(); | |
3534 | } | |
3535 | ||
3536 | if ( !candidate ) | |
3537 | return NULL; | |
3538 | ||
cf5d4c76 | 3539 | if ( !IsCellEditableInMode(item, candidate, mode) ) |
1c8e71c9 VS |
3540 | return NULL; |
3541 | ||
3542 | return candidate; | |
3543 | } | |
3544 | ||
cf5d4c76 VS |
3545 | bool wxDataViewMainWindow::IsCellEditableInMode(const wxDataViewItem& item, |
3546 | const wxDataViewColumn *col, | |
3547 | wxDataViewCellMode mode) const | |
3548 | { | |
3549 | if ( col->GetRenderer()->GetMode() != mode ) | |
3550 | return false; | |
3551 | ||
3552 | if ( !GetModel()->IsEnabled(item, col->GetModelColumn()) ) | |
3553 | return false; | |
3554 | ||
3555 | return true; | |
3556 | } | |
3557 | ||
64ac3db8 VZ |
3558 | void wxDataViewMainWindow::OnCharHook(wxKeyEvent& event) |
3559 | { | |
3560 | if ( m_editorCtrl ) | |
3561 | { | |
3562 | // Handle any keys special for the in-place editor and return without | |
3563 | // calling Skip() below. | |
3564 | switch ( event.GetKeyCode() ) | |
3565 | { | |
3566 | case WXK_ESCAPE: | |
3567 | m_editorRenderer->CancelEditing(); | |
3568 | return; | |
3569 | ||
3570 | case WXK_RETURN: | |
3571 | m_editorRenderer->FinishEditing(); | |
3572 | return; | |
3573 | } | |
3574 | } | |
3575 | ||
3576 | event.Skip(); | |
3577 | } | |
3578 | ||
cab07038 RR |
3579 | void wxDataViewMainWindow::OnChar( wxKeyEvent &event ) |
3580 | { | |
63ced01b VZ |
3581 | wxWindow * const parent = GetParent(); |
3582 | ||
3583 | // propagate the char event upwards | |
3584 | wxKeyEvent eventForParent(event); | |
3585 | eventForParent.SetEventObject(parent); | |
3586 | if ( parent->ProcessWindowEvent(eventForParent) ) | |
3587 | return; | |
3588 | ||
3589 | if ( parent->HandleAsNavigationKey(event) ) | |
f029f1d1 | 3590 | return; |
cab07038 RR |
3591 | |
3592 | // no item -> nothing to do | |
3593 | if (!HasCurrentRow()) | |
3594 | { | |
3595 | event.Skip(); | |
3596 | return; | |
3597 | } | |
120b9b05 | 3598 | |
cab07038 RR |
3599 | // don't use m_linesPerPage directly as it might not be computed yet |
3600 | const int pageSize = GetCountPerPage(); | |
9a83f860 | 3601 | wxCHECK_RET( pageSize, wxT("should have non zero page size") ); |
cab07038 RR |
3602 | |
3603 | switch ( event.GetKeyCode() ) | |
3604 | { | |
d37b709c | 3605 | case WXK_RETURN: |
a739b8b2 VS |
3606 | if ( event.HasModifiers() ) |
3607 | { | |
3608 | event.Skip(); | |
3609 | break; | |
3610 | } | |
3611 | else | |
d37b709c | 3612 | { |
c2efa4b4 VS |
3613 | // Enter activates the item, i.e. sends wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED to |
3614 | // it. Only if that event is not handled do we activate column renderer (which | |
0fff3dfc | 3615 | // is normally done by Space) or even inline editing. |
c2efa4b4 | 3616 | |
276227fc | 3617 | const wxDataViewItem item = GetItemByRow(m_currentRow); |
d37b709c | 3618 | |
c2efa4b4 VS |
3619 | wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, |
3620 | parent->GetId()); | |
3621 | le.SetItem(item); | |
3622 | le.SetEventObject(parent); | |
3623 | le.SetModel(GetModel()); | |
3624 | ||
857f05e1 | 3625 | if ( parent->ProcessWindowEvent(le) ) |
c2efa4b4 VS |
3626 | break; |
3627 | // else: fall through to WXK_SPACE handling | |
3628 | } | |
3629 | ||
3630 | case WXK_SPACE: | |
a739b8b2 VS |
3631 | if ( event.HasModifiers() ) |
3632 | { | |
3633 | event.Skip(); | |
3634 | break; | |
3635 | } | |
3636 | else | |
c2efa4b4 | 3637 | { |
0fff3dfc VS |
3638 | // Space toggles activatable items or -- if not activatable -- |
3639 | // starts inline editing (this is normally done using F2 on | |
3640 | // Windows, but Space is common everywhere else, so use it too | |
3641 | // for greater cross-platform compatibility). | |
3642 | ||
1c8e71c9 | 3643 | const wxDataViewItem item = GetItemByRow(m_currentRow); |
276227fc | 3644 | |
1c8e71c9 VS |
3645 | // Activate the current activatable column. If not column is focused (typically |
3646 | // because the user has full row selected), try to find the first activatable | |
3647 | // column (this would typically be a checkbox and we don't want to force the user | |
3648 | // to set focus on the checkbox column). | |
3649 | wxDataViewColumn *activatableCol = FindColumnForEditing(item, wxDATAVIEW_CELL_ACTIVATABLE); | |
276227fc VS |
3650 | |
3651 | if ( activatableCol ) | |
3652 | { | |
3653 | const unsigned colIdx = activatableCol->GetModelColumn(); | |
3654 | const wxRect cell_rect = GetOwner()->GetItemRect(item, activatableCol); | |
3655 | ||
3656 | wxDataViewRenderer *cell = activatableCol->GetRenderer(); | |
3657 | cell->PrepareForItem(GetModel(), item, colIdx); | |
dc73d7f5 | 3658 | cell->WXActivateCell(cell_rect, GetModel(), item, colIdx, NULL); |
0fff3dfc VS |
3659 | |
3660 | break; | |
3661 | } | |
3662 | // else: fall through to WXK_F2 handling | |
3663 | } | |
3664 | ||
3665 | case WXK_F2: | |
a739b8b2 VS |
3666 | if ( event.HasModifiers() ) |
3667 | { | |
3668 | event.Skip(); | |
3669 | break; | |
3670 | } | |
3671 | else | |
0fff3dfc VS |
3672 | { |
3673 | if( !m_selection.empty() ) | |
3674 | { | |
3675 | // Mimic Windows 7 behavior: edit the item that has focus | |
3676 | // if it is selected and the first selected item if focus | |
3677 | // is out of selection. | |
3678 | int sel; | |
3679 | if ( m_selection.Index(m_currentRow) != wxNOT_FOUND ) | |
3680 | sel = m_currentRow; | |
3681 | else | |
3682 | sel = m_selection[0]; | |
3683 | ||
3684 | ||
3685 | const wxDataViewItem item = GetItemByRow(sel); | |
3686 | ||
3687 | // Edit the current column. If no column is focused | |
3688 | // (typically because the user has full row selected), try | |
3689 | // to find the first editable column. | |
3690 | wxDataViewColumn *editableCol = FindColumnForEditing(item, wxDATAVIEW_CELL_EDITABLE); | |
3691 | ||
3692 | if ( editableCol ) | |
907f09f4 | 3693 | GetOwner()->EditItem(item, editableCol); |
276227fc | 3694 | } |
d37b709c RR |
3695 | } |
3696 | break; | |
48ae48a9 | 3697 | |
cab07038 RR |
3698 | case WXK_UP: |
3699 | if ( m_currentRow > 0 ) | |
1dc779fc | 3700 | OnVerticalNavigation( m_currentRow - 1, event ); |
cab07038 RR |
3701 | break; |
3702 | ||
3703 | case WXK_DOWN: | |
4385e702 | 3704 | if ( m_currentRow + 1 < GetRowCount() ) |
1dc779fc | 3705 | OnVerticalNavigation( m_currentRow + 1, event ); |
cab07038 | 3706 | break; |
bc4f1ff2 | 3707 | // Add the process for tree expanding/collapsing |
3b6280be | 3708 | case WXK_LEFT: |
cfc21881 | 3709 | OnLeftKey(); |
235d5f88 | 3710 | break; |
cfc21881 | 3711 | |
235d5f88 | 3712 | case WXK_RIGHT: |
cfc21881 | 3713 | OnRightKey(); |
235d5f88 | 3714 | break; |
cfc21881 | 3715 | |
cab07038 | 3716 | case WXK_END: |
235d5f88 | 3717 | { |
cab07038 | 3718 | if (!IsEmpty()) |
1dc779fc | 3719 | OnVerticalNavigation( GetRowCount() - 1, event ); |
cab07038 | 3720 | break; |
235d5f88 | 3721 | } |
cab07038 RR |
3722 | case WXK_HOME: |
3723 | if (!IsEmpty()) | |
1dc779fc | 3724 | OnVerticalNavigation( 0, event ); |
cab07038 RR |
3725 | break; |
3726 | ||
3727 | case WXK_PAGEUP: | |
3728 | { | |
3729 | int steps = pageSize - 1; | |
3730 | int index = m_currentRow - steps; | |
3731 | if (index < 0) | |
3732 | index = 0; | |
3733 | ||
1dc779fc | 3734 | OnVerticalNavigation( index, event ); |
cab07038 RR |
3735 | } |
3736 | break; | |
3737 | ||
3738 | case WXK_PAGEDOWN: | |
3739 | { | |
3740 | int steps = pageSize - 1; | |
0a71f9e9 RR |
3741 | unsigned int index = m_currentRow + steps; |
3742 | unsigned int count = GetRowCount(); | |
cab07038 RR |
3743 | if ( index >= count ) |
3744 | index = count - 1; | |
3745 | ||
1dc779fc | 3746 | OnVerticalNavigation( index, event ); |
cab07038 RR |
3747 | } |
3748 | break; | |
3749 | ||
3750 | default: | |
3751 | event.Skip(); | |
3752 | } | |
3753 | } | |
3754 | ||
1dc779fc VS |
3755 | void wxDataViewMainWindow::OnVerticalNavigation(unsigned int newCurrent, const wxKeyEvent& event) |
3756 | { | |
3757 | wxCHECK_RET( newCurrent < GetRowCount(), | |
3758 | wxT("invalid item index in OnVerticalNavigation()") ); | |
3759 | ||
3760 | // if there is no selection, we cannot move it anywhere | |
3761 | if (!HasCurrentRow()) | |
3762 | return; | |
3763 | ||
3764 | unsigned int oldCurrent = m_currentRow; | |
3765 | ||
3766 | // in single selection we just ignore Shift as we can't select several | |
3767 | // items anyhow | |
3768 | if ( event.ShiftDown() && !IsSingleSel() ) | |
3769 | { | |
3770 | RefreshRow( oldCurrent ); | |
3771 | ||
3772 | ChangeCurrentRow( newCurrent ); | |
3773 | ||
3774 | // select all the items between the old and the new one | |
3775 | if ( oldCurrent > newCurrent ) | |
3776 | { | |
3777 | newCurrent = oldCurrent; | |
3778 | oldCurrent = m_currentRow; | |
3779 | } | |
3780 | ||
3781 | SelectRows( oldCurrent, newCurrent, true ); | |
3782 | if (oldCurrent!=newCurrent) | |
3783 | SendSelectionChangedEvent(GetItemByRow(m_selection[0])); | |
3784 | } | |
3785 | else // !shift | |
3786 | { | |
3787 | RefreshRow( oldCurrent ); | |
3788 | ||
3789 | // all previously selected items are unselected unless ctrl is held | |
3790 | if ( !event.ControlDown() ) | |
3791 | SelectAllRows(false); | |
3792 | ||
3793 | ChangeCurrentRow( newCurrent ); | |
3794 | ||
3795 | if ( !event.ControlDown() ) | |
3796 | { | |
3797 | SelectRow( m_currentRow, true ); | |
3798 | SendSelectionChangedEvent(GetItemByRow(m_currentRow)); | |
3799 | } | |
3800 | else | |
3801 | RefreshRow( m_currentRow ); | |
3802 | } | |
3803 | ||
3804 | GetOwner()->EnsureVisible( m_currentRow, -1 ); | |
3805 | } | |
3806 | ||
cfc21881 VS |
3807 | void wxDataViewMainWindow::OnLeftKey() |
3808 | { | |
1c8e71c9 VS |
3809 | if ( IsList() ) |
3810 | { | |
3811 | TryAdvanceCurrentColumn(NULL, /*forward=*/false); | |
3812 | } | |
3813 | else | |
3814 | { | |
3815 | wxDataViewTreeNode* node = GetTreeNodeByRow(m_currentRow); | |
cfc21881 | 3816 | |
1c8e71c9 VS |
3817 | if ( TryAdvanceCurrentColumn(node, /*forward=*/false) ) |
3818 | return; | |
cfc21881 | 3819 | |
1c8e71c9 VS |
3820 | // Because TryAdvanceCurrentColumn() return false, we are at the first |
3821 | // column or using whole-row selection. In this situation, we can use | |
3822 | // the standard TreeView handling of the left key. | |
3823 | if (node->HasChildren() && node->IsOpen()) | |
3824 | { | |
3825 | Collapse(m_currentRow); | |
3826 | } | |
3827 | else | |
3828 | { | |
3829 | // if the node is already closed, we move the selection to its parent | |
3830 | wxDataViewTreeNode *parent_node = node->GetParent(); | |
3831 | ||
3832 | if (parent_node) | |
3833 | { | |
3834 | int parent = GetRowByItem( parent_node->GetItem() ); | |
3835 | if ( parent >= 0 ) | |
3836 | { | |
3837 | unsigned int row = m_currentRow; | |
3838 | SelectRow( row, false); | |
3839 | SelectRow( parent, true ); | |
3840 | ChangeCurrentRow( parent ); | |
3841 | GetOwner()->EnsureVisible( parent, -1 ); | |
3842 | SendSelectionChangedEvent( parent_node->GetItem() ); | |
3843 | } | |
3844 | } | |
3845 | } | |
3846 | } | |
3847 | } | |
3848 | ||
3849 | void wxDataViewMainWindow::OnRightKey() | |
3850 | { | |
3851 | if ( IsList() ) | |
cfc21881 | 3852 | { |
1c8e71c9 | 3853 | TryAdvanceCurrentColumn(NULL, /*forward=*/true); |
cfc21881 | 3854 | } |
1c8e71c9 | 3855 | else |
cfc21881 | 3856 | { |
1c8e71c9 | 3857 | wxDataViewTreeNode* node = GetTreeNodeByRow(m_currentRow); |
cfc21881 | 3858 | |
1c8e71c9 | 3859 | if ( node->HasChildren() ) |
cfc21881 | 3860 | { |
1c8e71c9 | 3861 | if ( !node->IsOpen() ) |
cfc21881 | 3862 | { |
1c8e71c9 VS |
3863 | Expand( m_currentRow ); |
3864 | } | |
3865 | else | |
3866 | { | |
3867 | // if the node is already open, we move the selection to the first child | |
cfc21881 | 3868 | unsigned int row = m_currentRow; |
1c8e71c9 VS |
3869 | SelectRow( row, false ); |
3870 | SelectRow( row + 1, true ); | |
3871 | ChangeCurrentRow( row + 1 ); | |
3872 | GetOwner()->EnsureVisible( row + 1, -1 ); | |
3873 | SendSelectionChangedEvent( GetItemByRow(row+1) ); | |
cfc21881 VS |
3874 | } |
3875 | } | |
1c8e71c9 VS |
3876 | else |
3877 | { | |
3878 | TryAdvanceCurrentColumn(node, /*forward=*/true); | |
3879 | } | |
cfc21881 VS |
3880 | } |
3881 | } | |
3882 | ||
1c8e71c9 | 3883 | bool wxDataViewMainWindow::TryAdvanceCurrentColumn(wxDataViewTreeNode *node, bool forward) |
cfc21881 | 3884 | { |
1c8e71c9 VS |
3885 | if ( GetOwner()->GetColumnCount() == 0 ) |
3886 | return false; | |
3887 | ||
3888 | if ( !m_useCellFocus ) | |
3889 | return false; | |
3890 | ||
3891 | if ( node ) | |
3892 | { | |
3893 | // navigation shouldn't work in branch nodes without other columns: | |
3894 | if ( node->HasChildren() && !GetModel()->HasContainerColumns(node->GetItem()) ) | |
3895 | return false; | |
3896 | } | |
3897 | ||
3898 | if ( m_currentCol == NULL || !m_currentColSetByKeyboard ) | |
3899 | { | |
3900 | if ( forward ) | |
3901 | { | |
3902 | m_currentCol = GetOwner()->GetColumnAt(1); | |
3903 | m_currentColSetByKeyboard = true; | |
3904 | RefreshRow(m_currentRow); | |
3905 | return true; | |
3906 | } | |
3907 | else | |
3908 | return false; | |
3909 | } | |
3910 | ||
3911 | int idx = GetOwner()->GetColumnIndex(m_currentCol) + (forward ? +1 : -1); | |
3912 | ||
3913 | if ( idx >= (int)GetOwner()->GetColumnCount() ) | |
3914 | return false; | |
3915 | ||
78e18e8d VS |
3916 | GetOwner()->EnsureVisible(m_currentRow, idx); |
3917 | ||
1c8e71c9 | 3918 | if ( idx < 1 ) |
cfc21881 | 3919 | { |
1c8e71c9 VS |
3920 | // We are going to the left of the second column. Reset to whole-row |
3921 | // focus (which means first column would be edited). | |
3922 | m_currentCol = NULL; | |
3923 | RefreshRow(m_currentRow); | |
3924 | return true; | |
cfc21881 | 3925 | } |
1c8e71c9 VS |
3926 | |
3927 | m_currentCol = GetOwner()->GetColumnAt(idx); | |
3928 | m_currentColSetByKeyboard = true; | |
3929 | RefreshRow(m_currentRow); | |
3930 | return true; | |
cfc21881 VS |
3931 | } |
3932 | ||
4ed7af08 RR |
3933 | void wxDataViewMainWindow::OnMouse( wxMouseEvent &event ) |
3934 | { | |
e21f75bd RR |
3935 | if (event.GetEventType() == wxEVT_MOUSEWHEEL) |
3936 | { | |
3937 | // let the base handle mouse wheel events. | |
3938 | event.Skip(); | |
3939 | return; | |
3940 | } | |
3941 | ||
6ceda4f5 VZ |
3942 | if(event.LeftDown()) |
3943 | { | |
3944 | // Not skipping this event would prevent the system from setting focus | |
3945 | // to this window. | |
3946 | event.Skip(); | |
3947 | } | |
3d9bff2f | 3948 | |
0fdc2321 RR |
3949 | int x = event.GetX(); |
3950 | int y = event.GetY(); | |
3951 | m_owner->CalcUnscrolledPosition( x, y, &x, &y ); | |
0fdc2321 | 3952 | wxDataViewColumn *col = NULL; |
b7fe2261 | 3953 | |
0fdc2321 | 3954 | int xpos = 0; |
9861f022 | 3955 | unsigned int cols = GetOwner()->GetColumnCount(); |
0a71f9e9 | 3956 | unsigned int i; |
0fdc2321 RR |
3957 | for (i = 0; i < cols; i++) |
3958 | { | |
702f5349 | 3959 | wxDataViewColumn *c = GetOwner()->GetColumnAt( i ); |
9861f022 RR |
3960 | if (c->IsHidden()) |
3961 | continue; // skip it! | |
3962 | ||
0fdc2321 RR |
3963 | if (x < xpos + c->GetWidth()) |
3964 | { | |
3965 | col = c; | |
3966 | break; | |
3967 | } | |
3968 | xpos += c->GetWidth(); | |
3969 | } | |
7ed24cb6 VZ |
3970 | |
3971 | wxDataViewModel* const model = GetModel(); | |
3972 | ||
3973 | const unsigned int current = GetLineAt( y ); | |
3974 | const wxDataViewItem item = GetItemByRow(current); | |
3975 | ||
3976 | // Handle right clicking here, before everything else as context menu | |
3977 | // events should be sent even when we click outside of any item, unlike all | |
3978 | // the other ones. | |
3979 | if (event.RightUp()) | |
3980 | { | |
3981 | wxWindow *parent = GetParent(); | |
3982 | wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, parent->GetId()); | |
3983 | le.SetEventObject(parent); | |
3984 | le.SetModel(model); | |
3985 | ||
3986 | if ( item.IsOk() && col ) | |
3987 | { | |
3988 | le.SetItem( item ); | |
3989 | le.SetColumn( col->GetModelColumn() ); | |
3990 | le.SetDataViewColumn( col ); | |
3991 | ||
3992 | wxVariant value; | |
3993 | model->GetValue( value, item, col->GetModelColumn() ); | |
3994 | le.SetValue(value); | |
3995 | } | |
3996 | ||
3997 | parent->ProcessWindowEvent(le); | |
3998 | return; | |
3999 | } | |
4000 | ||
f554a14b | 4001 | if (!col) |
737883f2 VZ |
4002 | { |
4003 | event.Skip(); | |
0fdc2321 | 4004 | return; |
737883f2 | 4005 | } |
f554a14b | 4006 | |
24c4a50f | 4007 | wxDataViewRenderer *cell = col->GetRenderer(); |
5179bc0b | 4008 | if ((current >= GetRowCount()) || (x > GetEndOfLastCol())) |
e21f75bd RR |
4009 | { |
4010 | // Unselect all if below the last row ? | |
737883f2 | 4011 | event.Skip(); |
e21f75bd RR |
4012 | return; |
4013 | } | |
f554a14b | 4014 | |
1841f079 VZ |
4015 | wxDataViewColumn* const |
4016 | expander = GetExpanderColumnOrFirstOne(GetOwner()); | |
4017 | ||
902334c8 VZ |
4018 | // Test whether the mouse is hovering over the expander (a.k.a tree "+" |
4019 | // button) and also determine the offset of the real cell start, skipping | |
4020 | // the indentation and the expander itself. | |
abdb8c18 | 4021 | bool hoverOverExpander = false; |
c46ecbe3 | 4022 | int itemOffset = 0; |
1841f079 | 4023 | if ((!IsList()) && (expander == col)) |
24c4a50f RR |
4024 | { |
4025 | wxDataViewTreeNode * node = GetTreeNodeByRow(current); | |
abdb8c18 | 4026 | |
c46ecbe3 VZ |
4027 | int indent = node->GetIndentLevel(); |
4028 | itemOffset = GetOwner()->GetIndent()*indent; | |
4029 | ||
4030 | if ( node->HasChildren() ) | |
4031 | { | |
977a41ec FM |
4032 | // we make the rectangle we are looking in a bit bigger than the actual |
4033 | // visual expander so the user can hit that little thing reliably | |
c46ecbe3 | 4034 | wxRect rect(itemOffset, |
977a41ec FM |
4035 | GetLineStart( current ) + (GetLineHeight(current) - m_lineHeight)/2, |
4036 | m_lineHeight, m_lineHeight); | |
902334c8 | 4037 | |
abdb8c18 | 4038 | if( rect.Contains(x, y) ) |
24c4a50f | 4039 | { |
bc4f1ff2 | 4040 | // So the mouse is over the expander |
abdb8c18 | 4041 | hoverOverExpander = true; |
24c4a50f RR |
4042 | if (m_underMouse && m_underMouse != node) |
4043 | { | |
bc4f1ff2 | 4044 | // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem())); |
df2c23e7 | 4045 | RefreshRow(GetRowByItem(m_underMouse->GetItem())); |
24c4a50f RR |
4046 | } |
4047 | if (m_underMouse != node) | |
4048 | { | |
bc4f1ff2 | 4049 | // wxLogMessage("Do the row: %d", current); |
df2c23e7 | 4050 | RefreshRow(current); |
24c4a50f RR |
4051 | } |
4052 | m_underMouse = node; | |
4053 | } | |
4054 | } | |
c46ecbe3 VZ |
4055 | |
4056 | // Account for the expander as well, even if this item doesn't have it, | |
4057 | // its parent does so it still counts for the offset. | |
4058 | itemOffset += m_lineHeight; | |
24c4a50f | 4059 | } |
abdb8c18 | 4060 | if (!hoverOverExpander) |
24c4a50f RR |
4061 | { |
4062 | if (m_underMouse != NULL) | |
4063 | { | |
bc4f1ff2 | 4064 | // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem())); |
df2c23e7 | 4065 | RefreshRow(GetRowByItem(m_underMouse->GetItem())); |
24c4a50f RR |
4066 | m_underMouse = NULL; |
4067 | } | |
4068 | } | |
4069 | ||
9adeb77a | 4070 | #if wxUSE_DRAG_AND_DROP |
e21f75bd RR |
4071 | if (event.Dragging()) |
4072 | { | |
4073 | if (m_dragCount == 0) | |
4074 | { | |
4075 | // we have to report the raw, physical coords as we want to be | |
4076 | // able to call HitTest(event.m_pointDrag) from the user code to | |
4077 | // get the item being dragged | |
4078 | m_dragStart = event.GetPosition(); | |
4079 | } | |
4080 | ||
4081 | m_dragCount++; | |
4082 | ||
4083 | if (m_dragCount != 3) | |
4084 | return; | |
4085 | ||
4086 | if (event.LeftIsDown()) | |
4087 | { | |
4cef3873 | 4088 | m_owner->CalcUnscrolledPosition( m_dragStart.x, m_dragStart.y, |
bc4f1ff2 | 4089 | &m_dragStart.x, &m_dragStart.y ); |
821baf7d | 4090 | unsigned int drag_item_row = GetLineAt( m_dragStart.y ); |
7ed24cb6 | 4091 | wxDataViewItem itemDragged = GetItemByRow( drag_item_row ); |
821baf7d | 4092 | |
e21f75bd | 4093 | // Notify cell about drag |
821baf7d RR |
4094 | wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG, m_owner->GetId() ); |
4095 | event.SetEventObject( m_owner ); | |
7ed24cb6 | 4096 | event.SetItem( itemDragged ); |
821baf7d RR |
4097 | event.SetModel( model ); |
4098 | if (!m_owner->HandleWindowEvent( event )) | |
4099 | return; | |
9adeb77a | 4100 | |
821baf7d RR |
4101 | if (!event.IsAllowed()) |
4102 | return; | |
9adeb77a | 4103 | |
821baf7d RR |
4104 | wxDataObject *obj = event.GetDataObject(); |
4105 | if (!obj) | |
4106 | return; | |
9adeb77a | 4107 | |
818d91a9 | 4108 | wxDataViewDropSource drag( this, drag_item_row ); |
592883ed | 4109 | drag.SetData( *obj ); |
c04be1a2 | 4110 | /* wxDragResult res = */ drag.DoDragDrop(event.GetDragFlags()); |
592883ed | 4111 | delete obj; |
e21f75bd RR |
4112 | } |
4113 | return; | |
4114 | } | |
4115 | else | |
4116 | { | |
4117 | m_dragCount = 0; | |
4118 | } | |
9adeb77a | 4119 | #endif // wxUSE_DRAG_AND_DROP |
e21f75bd | 4120 | |
abdb8c18 | 4121 | bool simulateClick = false; |
e21f75bd | 4122 | |
0fcce6b9 RR |
4123 | if (event.ButtonDClick()) |
4124 | { | |
4125 | m_renameTimer->Stop(); | |
4126 | m_lastOnSame = false; | |
4127 | } | |
4128 | ||
438fb233 | 4129 | bool ignore_other_columns = |
1841f079 | 4130 | ((expander != col) && |
977a41ec FM |
4131 | (model->IsContainer(item)) && |
4132 | (!model->HasContainerColumns(item))); | |
b5ec7dd6 | 4133 | |
0fdc2321 RR |
4134 | if (event.LeftDClick()) |
4135 | { | |
977a41ec FM |
4136 | if(hoverOverExpander) |
4137 | { | |
4138 | // a double click on the expander will be converted into a "simulated" normal click | |
4139 | simulateClick = true; | |
4140 | } | |
4141 | else if ( current == m_lineLastClicked ) | |
0fdc2321 | 4142 | { |
dc73d7f5 VS |
4143 | wxWindow *parent = GetParent(); |
4144 | wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId()); | |
4145 | le.SetItem( item ); | |
4146 | le.SetColumn( col->GetModelColumn() ); | |
4147 | le.SetDataViewColumn( col ); | |
4148 | le.SetEventObject(parent); | |
4149 | le.SetModel(GetModel()); | |
b7e9f8b1 | 4150 | |
dc73d7f5 | 4151 | parent->ProcessWindowEvent(le); |
e21f75bd RR |
4152 | return; |
4153 | } | |
4154 | else | |
4155 | { | |
4156 | // The first click was on another item, so don't interpret this as | |
4157 | // a double click, but as a simple click instead | |
abdb8c18 | 4158 | simulateClick = true; |
0fdc2321 | 4159 | } |
120b9b05 | 4160 | } |
f554a14b | 4161 | |
abdb8c18 | 4162 | if (event.LeftUp() && !hoverOverExpander) |
0fcce6b9 | 4163 | { |
0a71f9e9 | 4164 | if (m_lineSelectSingleOnUp != (unsigned int)-1) |
e21f75bd RR |
4165 | { |
4166 | // select single line | |
4167 | SelectAllRows( false ); | |
4168 | SelectRow( m_lineSelectSingleOnUp, true ); | |
4a745e76 | 4169 | SendSelectionChangedEvent( GetItemByRow(m_lineSelectSingleOnUp) ); |
e21f75bd | 4170 | } |
120b9b05 | 4171 | |
4cef3873 | 4172 | // If the user click the expander, we do not do editing even if the column |
bc4f1ff2 | 4173 | // with expander are editable |
abdb8c18 | 4174 | if (m_lastOnSame && !ignore_other_columns) |
0fcce6b9 | 4175 | { |
a8461d31 | 4176 | if ((col == m_currentCol) && (current == m_currentRow) && |
cf5d4c76 | 4177 | IsCellEditableInMode(item, col, wxDATAVIEW_CELL_EDITABLE) ) |
0fcce6b9 RR |
4178 | { |
4179 | m_renameTimer->Start( 100, true ); | |
4180 | } | |
4181 | } | |
4182 | ||
4183 | m_lastOnSame = false; | |
0a71f9e9 | 4184 | m_lineSelectSingleOnUp = (unsigned int)-1; |
120b9b05 | 4185 | } |
abdb8c18 | 4186 | else if(!event.LeftUp()) |
e21f75bd RR |
4187 | { |
4188 | // This is necessary, because after a DnD operation in | |
4189 | // from and to ourself, the up event is swallowed by the | |
4190 | // DnD code. So on next non-up event (which means here and | |
4191 | // now) m_lineSelectSingleOnUp should be reset. | |
0a71f9e9 | 4192 | m_lineSelectSingleOnUp = (unsigned int)-1; |
e21f75bd RR |
4193 | } |
4194 | ||
4195 | if (event.RightDown()) | |
4196 | { | |
4197 | m_lineBeforeLastClicked = m_lineLastClicked; | |
4198 | m_lineLastClicked = current; | |
4199 | ||
4200 | // If the item is already selected, do not update the selection. | |
4201 | // Multi-selections should not be cleared if a selected item is clicked. | |
4202 | if (!IsRowSelected(current)) | |
4203 | { | |
4204 | SelectAllRows(false); | |
a09da78b | 4205 | const unsigned oldCurrent = m_currentRow; |
e21f75bd RR |
4206 | ChangeCurrentRow(current); |
4207 | SelectRow(m_currentRow,true); | |
a09da78b | 4208 | RefreshRow(oldCurrent); |
526e19e2 | 4209 | SendSelectionChangedEvent(GetItemByRow( m_currentRow ) ); |
e21f75bd | 4210 | } |
0a807957 | 4211 | } |
e21f75bd RR |
4212 | else if (event.MiddleDown()) |
4213 | { | |
e21f75bd | 4214 | } |
abdb8c18 | 4215 | |
977a41ec FM |
4216 | if((event.LeftDown() || simulateClick) && hoverOverExpander) |
4217 | { | |
4218 | wxDataViewTreeNode* node = GetTreeNodeByRow(current); | |
bc4f1ff2 | 4219 | |
4cef3873 | 4220 | // hoverOverExpander being true tells us that our node must be |
bc4f1ff2 | 4221 | // valid and have children. |
977a41ec FM |
4222 | // So we don't need any extra checks. |
4223 | if( node->IsOpen() ) | |
235d5f88 | 4224 | Collapse(current); |
977a41ec | 4225 | else |
235d5f88 | 4226 | Expand(current); |
977a41ec FM |
4227 | } |
4228 | else if ((event.LeftDown() || simulateClick) && !hoverOverExpander) | |
0fcce6b9 | 4229 | { |
e21f75bd RR |
4230 | m_lineBeforeLastClicked = m_lineLastClicked; |
4231 | m_lineLastClicked = current; | |
4232 | ||
0a71f9e9 | 4233 | unsigned int oldCurrentRow = m_currentRow; |
e21f75bd RR |
4234 | bool oldWasSelected = IsRowSelected(m_currentRow); |
4235 | ||
4236 | bool cmdModifierDown = event.CmdDown(); | |
4237 | if ( IsSingleSel() || !(cmdModifierDown || event.ShiftDown()) ) | |
4238 | { | |
4239 | if ( IsSingleSel() || !IsRowSelected(current) ) | |
4240 | { | |
4241 | SelectAllRows( false ); | |
e21f75bd | 4242 | ChangeCurrentRow(current); |
e21f75bd | 4243 | SelectRow(m_currentRow,true); |
526e19e2 | 4244 | SendSelectionChangedEvent(GetItemByRow( m_currentRow ) ); |
e21f75bd RR |
4245 | } |
4246 | else // multi sel & current is highlighted & no mod keys | |
4247 | { | |
4248 | m_lineSelectSingleOnUp = current; | |
4249 | ChangeCurrentRow(current); // change focus | |
4250 | } | |
4251 | } | |
4252 | else // multi sel & either ctrl or shift is down | |
4253 | { | |
4254 | if (cmdModifierDown) | |
4255 | { | |
4256 | ChangeCurrentRow(current); | |
e21f75bd | 4257 | ReverseRowSelection(m_currentRow); |
9439bc69 | 4258 | SendSelectionChangedEvent(GetItemByRow(m_currentRow)); |
e21f75bd RR |
4259 | } |
4260 | else if (event.ShiftDown()) | |
4261 | { | |
4262 | ChangeCurrentRow(current); | |
4263 | ||
0a71f9e9 | 4264 | unsigned int lineFrom = oldCurrentRow, |
977a41ec | 4265 | lineTo = current; |
e21f75bd RR |
4266 | |
4267 | if ( lineTo < lineFrom ) | |
4268 | { | |
4269 | lineTo = lineFrom; | |
4270 | lineFrom = m_currentRow; | |
4271 | } | |
4272 | ||
4273 | SelectRows(lineFrom, lineTo, true); | |
526e19e2 | 4274 | SendSelectionChangedEvent(GetItemByRow(m_selection[0]) ); |
e21f75bd RR |
4275 | } |
4276 | else // !ctrl, !shift | |
4277 | { | |
4278 | // test in the enclosing if should make it impossible | |
9a83f860 | 4279 | wxFAIL_MSG( wxT("how did we get here?") ); |
e21f75bd RR |
4280 | } |
4281 | } | |
777f9cef | 4282 | |
72664514 RR |
4283 | if (m_currentRow != oldCurrentRow) |
4284 | RefreshRow( oldCurrentRow ); | |
e21f75bd | 4285 | |
0fcce6b9 | 4286 | wxDataViewColumn *oldCurrentCol = m_currentCol; |
120b9b05 | 4287 | |
0fcce6b9 RR |
4288 | // Update selection here... |
4289 | m_currentCol = col; | |
1c8e71c9 | 4290 | m_currentColSetByKeyboard = false; |
120b9b05 | 4291 | |
15ec266a VZ |
4292 | // This flag is used to decide whether we should start editing the item |
4293 | // label. We do it if the user clicks twice (but not double clicks, | |
4294 | // i.e. simulateClick is false) on the same item but not if the click | |
4295 | // was used for something else already, e.g. selecting the item (so it | |
4296 | // must have been already selected) or giving the focus to the control | |
4297 | // (so it must have had focus already). | |
abdb8c18 | 4298 | m_lastOnSame = !simulateClick && ((col == oldCurrentCol) && |
15ec266a VZ |
4299 | (current == oldCurrentRow)) && oldWasSelected && |
4300 | HasFocus(); | |
0bdfa388 | 4301 | |
dc73d7f5 | 4302 | // Call ActivateCell() after everything else as under GTK+ |
cf5d4c76 | 4303 | if ( IsCellEditableInMode(item, col, wxDATAVIEW_CELL_ACTIVATABLE) ) |
0bdfa388 | 4304 | { |
dbc3aec1 VS |
4305 | // notify cell about click |
4306 | cell->PrepareForItem(model, item, col->GetModelColumn()); | |
86755098 | 4307 | |
c46ecbe3 | 4308 | wxRect cell_rect( xpos + itemOffset, |
902334c8 | 4309 | GetLineStart( current ), |
c46ecbe3 | 4310 | col->GetWidth() - itemOffset, |
902334c8 | 4311 | GetLineHeight( current ) ); |
a3a8d81d | 4312 | |
dbc3aec1 VS |
4313 | // Report position relative to the cell's custom area, i.e. |
4314 | // no the entire space as given by the control but the one | |
4315 | // used by the renderer after calculation of alignment etc. | |
a3a8d81d | 4316 | |
dbc3aec1 VS |
4317 | // adjust the rectangle ourselves to account for the alignment |
4318 | wxRect rectItem = cell_rect; | |
4319 | const int align = cell->GetAlignment(); | |
4320 | if ( align != wxDVR_DEFAULT_ALIGNMENT ) | |
4321 | { | |
4322 | const wxSize size = cell->GetSize(); | |
a3a8d81d | 4323 | |
dbc3aec1 VS |
4324 | if ( size.x >= 0 && size.x < cell_rect.width ) |
4325 | { | |
4326 | if ( align & wxALIGN_CENTER_HORIZONTAL ) | |
4327 | rectItem.x += (cell_rect.width - size.x)/2; | |
4328 | else if ( align & wxALIGN_RIGHT ) | |
4329 | rectItem.x += cell_rect.width - size.x; | |
4330 | // else: wxALIGN_LEFT is the default | |
4331 | } | |
a3a8d81d | 4332 | |
dbc3aec1 VS |
4333 | if ( size.y >= 0 && size.y < cell_rect.height ) |
4334 | { | |
4335 | if ( align & wxALIGN_CENTER_VERTICAL ) | |
4336 | rectItem.y += (cell_rect.height - size.y)/2; | |
4337 | else if ( align & wxALIGN_BOTTOM ) | |
4338 | rectItem.y += cell_rect.height - size.y; | |
4339 | // else: wxALIGN_TOP is the default | |
a3a8d81d | 4340 | } |
dbc3aec1 | 4341 | } |
a3a8d81d | 4342 | |
dc73d7f5 VS |
4343 | wxMouseEvent event2(event); |
4344 | event2.m_x -= rectItem.x; | |
4345 | event2.m_y -= rectItem.y; | |
4346 | m_owner->CalcUnscrolledPosition(event2.m_x, event2.m_y, &event2.m_x, &event2.m_y); | |
a3a8d81d | 4347 | |
dc73d7f5 VS |
4348 | /* ignore ret */ cell->WXActivateCell |
4349 | ( | |
4350 | cell_rect, | |
4351 | model, | |
4352 | item, | |
4353 | col->GetModelColumn(), | |
4354 | &event2 | |
4355 | ); | |
0bdfa388 | 4356 | } |
0fdc2321 | 4357 | } |
4ed7af08 RR |
4358 | } |
4359 | ||
4360 | void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event ) | |
4361 | { | |
cab07038 | 4362 | m_hasFocus = true; |
120b9b05 | 4363 | |
cab07038 RR |
4364 | if (HasCurrentRow()) |
4365 | Refresh(); | |
120b9b05 | 4366 | |
cab07038 RR |
4367 | event.Skip(); |
4368 | } | |
4369 | ||
4370 | void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event ) | |
4371 | { | |
4372 | m_hasFocus = false; | |
120b9b05 | 4373 | |
cab07038 RR |
4374 | if (HasCurrentRow()) |
4375 | Refresh(); | |
120b9b05 | 4376 | |
4ed7af08 RR |
4377 | event.Skip(); |
4378 | } | |
4379 | ||
1c8e71c9 VS |
4380 | void wxDataViewMainWindow::OnColumnsCountChanged() |
4381 | { | |
4382 | int editableCount = 0; | |
4383 | ||
4384 | const unsigned cols = GetOwner()->GetColumnCount(); | |
4385 | for ( unsigned i = 0; i < cols; i++ ) | |
4386 | { | |
4387 | wxDataViewColumn *c = GetOwner()->GetColumnAt(i); | |
4388 | if ( c->IsHidden() ) | |
4389 | continue; | |
4390 | if ( c->GetRenderer()->GetMode() != wxDATAVIEW_CELL_INERT ) | |
4391 | editableCount++; | |
4392 | } | |
4393 | ||
4394 | m_useCellFocus = (editableCount > 1); | |
4395 | ||
4396 | UpdateDisplay(); | |
4397 | } | |
4398 | ||
4ed7af08 RR |
4399 | //----------------------------------------------------------------------------- |
4400 | // wxDataViewCtrl | |
4401 | //----------------------------------------------------------------------------- | |
bc4f1ff2 | 4402 | |
a76c2f37 | 4403 | WX_DEFINE_LIST(wxDataViewColumnList) |
4ed7af08 RR |
4404 | |
4405 | IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase) | |
4b3feaa7 RR |
4406 | BEGIN_EVENT_TABLE(wxDataViewCtrl, wxDataViewCtrlBase) |
4407 | EVT_SIZE(wxDataViewCtrl::OnSize) | |
4408 | END_EVENT_TABLE() | |
4409 | ||
4ed7af08 RR |
4410 | wxDataViewCtrl::~wxDataViewCtrl() |
4411 | { | |
4412 | if (m_notifier) | |
4413 | GetModel()->RemoveNotifier( m_notifier ); | |
74123073 | 4414 | |
b3a3c9d8 | 4415 | m_cols.Clear(); |
d0154e3a | 4416 | m_colsBestWidths.clear(); |
4ed7af08 RR |
4417 | } |
4418 | ||
4419 | void wxDataViewCtrl::Init() | |
4420 | { | |
b3a3c9d8 | 4421 | m_cols.DeleteContents(true); |
4ed7af08 | 4422 | m_notifier = NULL; |
e822d1bd | 4423 | |
236a34ef | 4424 | // No sorting column at start |
46234a03 VZ |
4425 | m_sortingColumnIdx = wxNOT_FOUND; |
4426 | ||
236a34ef | 4427 | m_headerArea = NULL; |
bed74e48 VS |
4428 | |
4429 | m_colsDirty = false; | |
4ed7af08 RR |
4430 | } |
4431 | ||
62e9285a VZ |
4432 | bool wxDataViewCtrl::Create(wxWindow *parent, |
4433 | wxWindowID id, | |
4434 | const wxPoint& pos, | |
4435 | const wxSize& size, | |
4436 | long style, | |
4437 | const wxValidator& validator, | |
4438 | const wxString& name) | |
4ed7af08 | 4439 | { |
3fdf86f9 RR |
4440 | // if ( (style & wxBORDER_MASK) == 0) |
4441 | // style |= wxBORDER_SUNKEN; | |
777f9cef | 4442 | |
236a34ef RR |
4443 | Init(); |
4444 | ||
c741d33f | 4445 | if (!wxControl::Create( parent, id, pos, size, |
62e9285a | 4446 | style | wxScrolledWindowStyle, validator, name)) |
4b3feaa7 RR |
4447 | return false; |
4448 | ||
b89cac3f | 4449 | SetInitialSize(size); |
b5ec7dd6 | 4450 | |
4ed7af08 | 4451 | #ifdef __WXMAC__ |
59e60167 | 4452 | MacSetClipChildren( true ); |
4ed7af08 RR |
4453 | #endif |
4454 | ||
f554a14b | 4455 | m_clientArea = new wxDataViewMainWindow( this, wxID_ANY ); |
9861f022 | 4456 | |
63ced01b VZ |
4457 | // We use the cursor keys for moving the selection, not scrolling, so call |
4458 | // this method to ensure wxScrollHelperEvtHandler doesn't catch all | |
4459 | // keyboard events forwarded to us from wxListMainWindow. | |
4460 | DisableKeyboardScrolling(); | |
4461 | ||
9861f022 RR |
4462 | if (HasFlag(wxDV_NO_HEADER)) |
4463 | m_headerArea = NULL; | |
4464 | else | |
56873923 | 4465 | m_headerArea = new wxDataViewHeaderWindow(this); |
f554a14b | 4466 | |
4ed7af08 | 4467 | SetTargetWindow( m_clientArea ); |
f554a14b | 4468 | |
4ed7af08 | 4469 | wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL ); |
9861f022 RR |
4470 | if (m_headerArea) |
4471 | sizer->Add( m_headerArea, 0, wxGROW ); | |
4ed7af08 RR |
4472 | sizer->Add( m_clientArea, 1, wxGROW ); |
4473 | SetSizer( sizer ); | |
b5ec7dd6 | 4474 | |
4ed7af08 RR |
4475 | return true; |
4476 | } | |
4477 | ||
3fdf86f9 RR |
4478 | wxBorder wxDataViewCtrl::GetDefaultBorder() const |
4479 | { | |
4480 | return wxBORDER_THEME; | |
4481 | } | |
4482 | ||
4ed7af08 RR |
4483 | #ifdef __WXMSW__ |
4484 | WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg, | |
bc4f1ff2 FM |
4485 | WXWPARAM wParam, |
4486 | WXLPARAM lParam) | |
4ed7af08 | 4487 | { |
b910a8ad | 4488 | WXLRESULT rc = wxDataViewCtrlBase::MSWWindowProc(nMsg, wParam, lParam); |
4ed7af08 RR |
4489 | |
4490 | #ifndef __WXWINCE__ | |
4491 | // we need to process arrows ourselves for scrolling | |
4492 | if ( nMsg == WM_GETDLGCODE ) | |
4493 | { | |
4494 | rc |= DLGC_WANTARROWS; | |
4495 | } | |
4496 | #endif | |
4497 | ||
4498 | return rc; | |
4499 | } | |
4500 | #endif | |
4501 | ||
2571a33f RR |
4502 | wxSize wxDataViewCtrl::GetSizeAvailableForScrollTarget(const wxSize& size) |
4503 | { | |
4504 | wxSize newsize = size; | |
d7cda9b2 | 4505 | if (!HasFlag(wxDV_NO_HEADER) && (m_headerArea)) |
977a41ec | 4506 | newsize.y -= m_headerArea->GetSize().y; |
e822d1bd | 4507 | |
2571a33f RR |
4508 | return newsize; |
4509 | } | |
4510 | ||
f554a14b | 4511 | void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) ) |
4ed7af08 | 4512 | { |
4b3feaa7 RR |
4513 | // We need to override OnSize so that our scrolled |
4514 | // window a) does call Layout() to use sizers for | |
4515 | // positioning the controls but b) does not query | |
4516 | // the sizer for their size and use that for setting | |
4517 | // the scrollable area as set that ourselves by | |
4518 | // calling SetScrollbar() further down. | |
4519 | ||
4520 | Layout(); | |
4521 | ||
4522 | AdjustScrollbars(); | |
cd9b34ef VZ |
4523 | |
4524 | // We must redraw the headers if their height changed. Normally this | |
4525 | // shouldn't happen as the control shouldn't let itself be resized beneath | |
4526 | // its minimal height but avoid the display artefacts that appear if it | |
4527 | // does happen, e.g. because there is really not enough vertical space. | |
4528 | if ( !HasFlag(wxDV_NO_HEADER) && m_headerArea && | |
4529 | m_headerArea->GetSize().y <= m_headerArea->GetBestSize(). y ) | |
4530 | { | |
4531 | m_headerArea->Refresh(); | |
4532 | } | |
4ed7af08 RR |
4533 | } |
4534 | ||
788432e3 RR |
4535 | void wxDataViewCtrl::SetFocus() |
4536 | { | |
4537 | if (m_clientArea) | |
4538 | m_clientArea->SetFocus(); | |
4539 | } | |
4540 | ||
aba9bfd0 | 4541 | bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model ) |
4ed7af08 RR |
4542 | { |
4543 | if (!wxDataViewCtrlBase::AssociateModel( model )) | |
4544 | return false; | |
4545 | ||
be416221 VZ |
4546 | if (model) |
4547 | { | |
4548 | m_notifier = new wxGenericDataViewModelNotifier( m_clientArea ); | |
4549 | model->AddNotifier( m_notifier ); | |
4550 | } | |
4551 | else if (m_notifier) | |
4552 | { | |
4553 | m_notifier->Cleared(); | |
4554 | m_notifier = NULL; | |
4555 | } | |
4ed7af08 | 4556 | |
51bdecff | 4557 | m_clientArea->DestroyTree(); |
cfa42cb8 | 4558 | |
be416221 VZ |
4559 | if (model) |
4560 | { | |
4561 | m_clientArea->BuildTree(model); | |
4562 | } | |
aba9bfd0 | 4563 | |
4b3feaa7 | 4564 | m_clientArea->UpdateDisplay(); |
f554a14b | 4565 | |
4ed7af08 RR |
4566 | return true; |
4567 | } | |
4568 | ||
9adeb77a VZ |
4569 | #if wxUSE_DRAG_AND_DROP |
4570 | ||
821baf7d RR |
4571 | bool wxDataViewCtrl::EnableDragSource( const wxDataFormat &format ) |
4572 | { | |
4573 | return m_clientArea->EnableDragSource( format ); | |
4574 | } | |
4575 | ||
4576 | bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat &format ) | |
4577 | { | |
4578 | return m_clientArea->EnableDropTarget( format ); | |
4579 | } | |
4580 | ||
9adeb77a VZ |
4581 | #endif // wxUSE_DRAG_AND_DROP |
4582 | ||
4ed7af08 RR |
4583 | bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col ) |
4584 | { | |
4585 | if (!wxDataViewCtrlBase::AppendColumn(col)) | |
4586 | return false; | |
f554a14b | 4587 | |
afebb87b | 4588 | m_cols.Append( col ); |
840fc4d1 | 4589 | m_colsBestWidths.push_back(CachedColWidthInfo()); |
aef252d9 | 4590 | OnColumnsCountChanged(); |
736fe67c RR |
4591 | return true; |
4592 | } | |
4593 | ||
4594 | bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col ) | |
4595 | { | |
4596 | if (!wxDataViewCtrlBase::PrependColumn(col)) | |
4597 | return false; | |
4598 | ||
4599 | m_cols.Insert( col ); | |
840fc4d1 | 4600 | m_colsBestWidths.insert(m_colsBestWidths.begin(), CachedColWidthInfo()); |
aef252d9 | 4601 | OnColumnsCountChanged(); |
4ed7af08 RR |
4602 | return true; |
4603 | } | |
4604 | ||
19723525 RR |
4605 | bool wxDataViewCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col ) |
4606 | { | |
4607 | if (!wxDataViewCtrlBase::InsertColumn(pos,col)) | |
4608 | return false; | |
4609 | ||
4610 | m_cols.Insert( pos, col ); | |
840fc4d1 | 4611 | m_colsBestWidths.insert(m_colsBestWidths.begin() + pos, CachedColWidthInfo()); |
aef252d9 | 4612 | OnColumnsCountChanged(); |
19723525 RR |
4613 | return true; |
4614 | } | |
4615 | ||
aef252d9 VZ |
4616 | void wxDataViewCtrl::OnColumnChange(unsigned int idx) |
4617 | { | |
4618 | if ( m_headerArea ) | |
4619 | m_headerArea->UpdateColumn(idx); | |
4620 | ||
4621 | m_clientArea->UpdateDisplay(); | |
4622 | } | |
4623 | ||
4624 | void wxDataViewCtrl::OnColumnsCountChanged() | |
9861f022 RR |
4625 | { |
4626 | if (m_headerArea) | |
e2bfe673 | 4627 | m_headerArea->SetColumnCount(GetColumnCount()); |
9861f022 | 4628 | |
1c8e71c9 | 4629 | m_clientArea->OnColumnsCountChanged(); |
9861f022 | 4630 | } |
3b6280be RR |
4631 | |
4632 | void wxDataViewCtrl::DoSetExpanderColumn() | |
4633 | { | |
4634 | m_clientArea->UpdateDisplay(); | |
4635 | } | |
4636 | ||
4637 | void wxDataViewCtrl::DoSetIndent() | |
4638 | { | |
4639 | m_clientArea->UpdateDisplay(); | |
4640 | } | |
4641 | ||
afebb87b RR |
4642 | unsigned int wxDataViewCtrl::GetColumnCount() const |
4643 | { | |
4644 | return m_cols.GetCount(); | |
4645 | } | |
4646 | ||
bbfd4548 VZ |
4647 | bool wxDataViewCtrl::SetRowHeight( int lineHeight ) |
4648 | { | |
4649 | if ( !m_clientArea ) | |
4650 | return false; | |
4651 | ||
4652 | m_clientArea->SetRowHeight(lineHeight); | |
4653 | ||
4654 | return true; | |
4655 | } | |
4656 | ||
aef252d9 | 4657 | wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int idx ) const |
afebb87b | 4658 | { |
aef252d9 | 4659 | return m_cols[idx]; |
afebb87b RR |
4660 | } |
4661 | ||
702f5349 | 4662 | wxDataViewColumn *wxDataViewCtrl::GetColumnAt(unsigned int pos) const |
fc8c1a15 | 4663 | { |
702f5349 VZ |
4664 | // columns can't be reordered if there is no header window which allows |
4665 | // to do this | |
4666 | const unsigned idx = m_headerArea ? m_headerArea->GetColumnsOrder()[pos] | |
977a41ec | 4667 | : pos; |
59e60167 | 4668 | |
702f5349 VZ |
4669 | return GetColumn(idx); |
4670 | } | |
cfa42cb8 | 4671 | |
702f5349 VZ |
4672 | int wxDataViewCtrl::GetColumnIndex(const wxDataViewColumn *column) const |
4673 | { | |
4674 | const unsigned count = m_cols.size(); | |
4675 | for ( unsigned n = 0; n < count; n++ ) | |
4676 | { | |
4677 | if ( m_cols[n] == column ) | |
4678 | return n; | |
4679 | } | |
4680 | ||
4681 | return wxNOT_FOUND; | |
4682 | } | |
4683 | ||
d0154e3a VS |
4684 | unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx) const |
4685 | { | |
840fc4d1 VS |
4686 | if ( m_colsBestWidths[idx].width != 0 ) |
4687 | return m_colsBestWidths[idx].width; | |
d0154e3a | 4688 | |
0645bd38 | 4689 | const int count = m_clientArea->GetRowCount(); |
d0154e3a VS |
4690 | wxDataViewColumn *column = GetColumn(idx); |
4691 | wxDataViewRenderer *renderer = | |
4692 | const_cast<wxDataViewRenderer*>(column->GetRenderer()); | |
4693 | ||
0645bd38 VS |
4694 | class MaxWidthCalculator |
4695 | { | |
4696 | public: | |
0fdeaabe VS |
4697 | MaxWidthCalculator(const wxDataViewCtrl *dvc, |
4698 | wxDataViewMainWindow *clientArea, | |
0645bd38 VS |
4699 | wxDataViewRenderer *renderer, |
4700 | const wxDataViewModel *model, | |
0fdeaabe VS |
4701 | unsigned column, |
4702 | int expanderSize) | |
0645bd38 | 4703 | : m_width(0), |
0fdeaabe | 4704 | m_dvc(dvc), |
0645bd38 VS |
4705 | m_clientArea(clientArea), |
4706 | m_renderer(renderer), | |
4707 | m_model(model), | |
0fdeaabe VS |
4708 | m_column(column), |
4709 | m_expanderSize(expanderSize) | |
4710 | ||
0645bd38 | 4711 | { |
0fdeaabe VS |
4712 | m_isExpanderCol = |
4713 | !clientArea->IsList() && | |
4714 | (column == 0 || | |
4715 | GetExpanderColumnOrFirstOne(const_cast<wxDataViewCtrl*>(dvc)) == dvc->GetColumnAt(column)); | |
0645bd38 VS |
4716 | } |
4717 | ||
4718 | void UpdateWithWidth(int width) | |
4719 | { | |
4720 | m_width = wxMax(m_width, width); | |
4721 | } | |
4722 | ||
4723 | void UpdateWithRow(int row) | |
4724 | { | |
0fdeaabe VS |
4725 | int indent = 0; |
4726 | wxDataViewItem item; | |
4727 | ||
4728 | if ( m_isExpanderCol ) | |
4729 | { | |
4730 | wxDataViewTreeNode *node = m_clientArea->GetTreeNodeByRow(row); | |
4731 | item = node->GetItem(); | |
4732 | indent = m_dvc->GetIndent() * node->GetIndentLevel() + m_expanderSize; | |
4733 | } | |
4734 | else | |
4735 | { | |
4736 | item = m_clientArea->GetItemByRow(row); | |
4737 | } | |
4738 | ||
0645bd38 | 4739 | m_renderer->PrepareForItem(m_model, item, m_column); |
0fdeaabe | 4740 | m_width = wxMax(m_width, m_renderer->GetSize().x + indent); |
0645bd38 VS |
4741 | } |
4742 | ||
4743 | int GetMaxWidth() const { return m_width; } | |
4744 | ||
4745 | private: | |
4746 | int m_width; | |
0fdeaabe | 4747 | const wxDataViewCtrl *m_dvc; |
0645bd38 VS |
4748 | wxDataViewMainWindow *m_clientArea; |
4749 | wxDataViewRenderer *m_renderer; | |
4750 | const wxDataViewModel *m_model; | |
4751 | unsigned m_column; | |
0fdeaabe VS |
4752 | bool m_isExpanderCol; |
4753 | int m_expanderSize; | |
0645bd38 VS |
4754 | }; |
4755 | ||
0fdeaabe VS |
4756 | MaxWidthCalculator calculator(this, m_clientArea, renderer, |
4757 | GetModel(), column->GetModelColumn(), | |
4758 | m_clientArea->GetRowHeight()); | |
d0154e3a | 4759 | |
f0630187 VS |
4760 | calculator.UpdateWithWidth(column->GetMinWidth()); |
4761 | ||
d0154e3a | 4762 | if ( m_headerArea ) |
53137278 | 4763 | calculator.UpdateWithWidth(m_headerArea->GetColumnTitleWidth(*column)); |
0645bd38 VS |
4764 | |
4765 | // The code below deserves some explanation. For very large controls, we | |
4766 | // simply can't afford to calculate sizes for all items, it takes too | |
4767 | // long. So the best we can do is to check the first and the last N/2 | |
4768 | // items in the control for some sufficiently large N and calculate best | |
4769 | // sizes from that. That can result in the calculated best width being too | |
4770 | // small for some outliers, but it's better to get slightly imperfect | |
4771 | // result than to wait several seconds after every update. To avoid highly | |
4772 | // visible miscalculations, we also include all currently visible items | |
4773 | // no matter what. Finally, the value of N is determined dynamically by | |
4774 | // measuring how much time we spent on the determining item widths so far. | |
4775 | ||
4776 | #if wxUSE_STOPWATCH | |
4777 | int top_part_end = count; | |
4778 | static const long CALC_TIMEOUT = 20/*ms*/; | |
4779 | // don't call wxStopWatch::Time() too often | |
4780 | static const unsigned CALC_CHECK_FREQ = 100; | |
4781 | wxStopWatch timer; | |
4782 | #else | |
4783 | // use some hard-coded limit, that's the best we can do without timer | |
4784 | int top_part_end = wxMin(500, count); | |
4785 | #endif // wxUSE_STOPWATCH/!wxUSE_STOPWATCH | |
4786 | ||
4787 | int row = 0; | |
4788 | ||
4789 | for ( row = 0; row < top_part_end; row++ ) | |
4790 | { | |
4791 | #if wxUSE_STOPWATCH | |
4792 | if ( row % CALC_CHECK_FREQ == CALC_CHECK_FREQ-1 && | |
4793 | timer.Time() > CALC_TIMEOUT ) | |
4794 | break; | |
4795 | #endif // wxUSE_STOPWATCH | |
4796 | calculator.UpdateWithRow(row); | |
d0154e3a VS |
4797 | } |
4798 | ||
40fc5b2f | 4799 | // row is the first unmeasured item now; that's our value of N/2 |
0645bd38 VS |
4800 | |
4801 | if ( row < count ) | |
d0154e3a | 4802 | { |
0645bd38 | 4803 | top_part_end = row; |
d0154e3a | 4804 | |
0645bd38 VS |
4805 | // add bottom N/2 items now: |
4806 | const int bottom_part_start = wxMax(row, count - row); | |
4807 | for ( row = bottom_part_start; row < count; row++ ) | |
4808 | { | |
4809 | calculator.UpdateWithRow(row); | |
4810 | } | |
86755098 | 4811 | |
0645bd38 VS |
4812 | // finally, include currently visible items in the calculation: |
4813 | const wxPoint origin = CalcUnscrolledPosition(wxPoint(0, 0)); | |
4814 | int first_visible = m_clientArea->GetLineAt(origin.y); | |
4815 | int last_visible = m_clientArea->GetLineAt(origin.y + GetClientSize().y); | |
4816 | ||
4817 | first_visible = wxMax(first_visible, top_part_end); | |
4818 | last_visible = wxMin(bottom_part_start, last_visible); | |
4819 | ||
4820 | for ( row = first_visible; row < last_visible; row++ ) | |
4821 | { | |
4822 | calculator.UpdateWithRow(row); | |
4823 | } | |
4824 | ||
4825 | wxLogTrace("dataview", | |
4826 | "determined best size from %d top, %d bottom plus %d more visible items out of %d total", | |
4827 | top_part_end, | |
4828 | count - bottom_part_start, | |
4829 | wxMax(0, last_visible - first_visible), | |
4830 | count); | |
d0154e3a VS |
4831 | } |
4832 | ||
0645bd38 | 4833 | int max_width = calculator.GetMaxWidth(); |
d0154e3a VS |
4834 | if ( max_width > 0 ) |
4835 | max_width += 2 * PADDING_RIGHTLEFT; | |
4836 | ||
840fc4d1 | 4837 | const_cast<wxDataViewCtrl*>(this)->m_colsBestWidths[idx].width = max_width; |
d0154e3a VS |
4838 | return max_width; |
4839 | } | |
4840 | ||
702f5349 | 4841 | void wxDataViewCtrl::ColumnMoved(wxDataViewColumn * WXUNUSED(col), |
977a41ec | 4842 | unsigned int WXUNUSED(new_pos)) |
702f5349 VZ |
4843 | { |
4844 | // do _not_ reorder m_cols elements here, they should always be in the | |
4845 | // order in which columns were added, we only display the columns in | |
4846 | // different order | |
fc8c1a15 RR |
4847 | m_clientArea->UpdateDisplay(); |
4848 | } | |
4849 | ||
afebb87b RR |
4850 | bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column ) |
4851 | { | |
b3a3c9d8 | 4852 | wxDataViewColumnList::compatibility_iterator ret = m_cols.Find( column ); |
4264606e | 4853 | if (!ret) |
afebb87b RR |
4854 | return false; |
4855 | ||
d0154e3a | 4856 | m_colsBestWidths.erase(m_colsBestWidths.begin() + GetColumnIndex(column)); |
b7fe2261 | 4857 | m_cols.Erase(ret); |
f52f3795 VS |
4858 | |
4859 | if ( m_clientArea->GetCurrentColumn() == column ) | |
4860 | m_clientArea->ClearCurrentColumn(); | |
4861 | ||
aef252d9 | 4862 | OnColumnsCountChanged(); |
afebb87b RR |
4863 | |
4864 | return true; | |
4865 | } | |
4866 | ||
4867 | bool wxDataViewCtrl::ClearColumns() | |
4868 | { | |
42cbde51 | 4869 | SetExpanderColumn(NULL); |
b3a3c9d8 | 4870 | m_cols.Clear(); |
d0154e3a | 4871 | m_colsBestWidths.clear(); |
f52f3795 VS |
4872 | |
4873 | m_clientArea->ClearCurrentColumn(); | |
4874 | ||
aef252d9 | 4875 | OnColumnsCountChanged(); |
f52f3795 | 4876 | |
afebb87b RR |
4877 | return true; |
4878 | } | |
4879 | ||
bed74e48 | 4880 | void wxDataViewCtrl::InvalidateColBestWidth(int idx) |
d0154e3a | 4881 | { |
840fc4d1 VS |
4882 | m_colsBestWidths[idx].width = 0; |
4883 | m_colsBestWidths[idx].dirty = true; | |
bed74e48 | 4884 | m_colsDirty = true; |
d0154e3a VS |
4885 | } |
4886 | ||
bed74e48 | 4887 | void wxDataViewCtrl::InvalidateColBestWidths() |
d0154e3a | 4888 | { |
840fc4d1 | 4889 | // mark all columns as dirty: |
d0154e3a VS |
4890 | m_colsBestWidths.clear(); |
4891 | m_colsBestWidths.resize(m_cols.size()); | |
bed74e48 VS |
4892 | m_colsDirty = true; |
4893 | } | |
d0154e3a | 4894 | |
bed74e48 VS |
4895 | void wxDataViewCtrl::UpdateColWidths() |
4896 | { | |
840fc4d1 VS |
4897 | m_colsDirty = false; |
4898 | ||
bed74e48 VS |
4899 | if ( !m_headerArea ) |
4900 | return; | |
4901 | ||
76b92fa5 VS |
4902 | const unsigned len = m_colsBestWidths.size(); |
4903 | for ( unsigned i = 0; i < len; i++ ) | |
bed74e48 | 4904 | { |
840fc4d1 VS |
4905 | // Note that we have to have an explicit 'dirty' flag here instead of |
4906 | // checking if the width==0, as is done in GetBestColumnWidth(). | |
4907 | // | |
4908 | // Testing width==0 wouldn't work correctly if some code called | |
4909 | // GetWidth() after col. width invalidation but before | |
4910 | // wxDataViewCtrl::UpdateColWidths() was called at idle time. This | |
4911 | // would result in the header's column width getting out of sync with | |
4912 | // the control itself. | |
4913 | if ( m_colsBestWidths[i].dirty ) | |
4914 | { | |
76b92fa5 | 4915 | m_headerArea->UpdateColumn(i); |
840fc4d1 VS |
4916 | m_colsBestWidths[i].dirty = false; |
4917 | } | |
bed74e48 VS |
4918 | } |
4919 | } | |
4920 | ||
4921 | void wxDataViewCtrl::OnInternalIdle() | |
4922 | { | |
4923 | wxDataViewCtrlBase::OnInternalIdle(); | |
4924 | ||
4925 | if ( m_colsDirty ) | |
bed74e48 | 4926 | UpdateColWidths(); |
d0154e3a VS |
4927 | } |
4928 | ||
453091c2 RR |
4929 | int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const |
4930 | { | |
5d9e1605 RR |
4931 | unsigned int len = GetColumnCount(); |
4932 | for ( unsigned int i = 0; i < len; i++ ) | |
4933 | { | |
4934 | wxDataViewColumn * col = GetColumnAt(i); | |
4935 | if (column==col) | |
4936 | return i; | |
4937 | } | |
ce00f59b | 4938 | |
5d9e1605 | 4939 | return wxNOT_FOUND; |
453091c2 RR |
4940 | } |
4941 | ||
21f47fb9 RR |
4942 | wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const |
4943 | { | |
46234a03 | 4944 | return m_sortingColumnIdx == wxNOT_FOUND ? NULL |
977a41ec | 4945 | : GetColumn(m_sortingColumnIdx); |
21f47fb9 RR |
4946 | } |
4947 | ||
80ce465c VZ |
4948 | wxDataViewItem wxDataViewCtrl::DoGetCurrentItem() const |
4949 | { | |
4950 | return GetItemByRow(m_clientArea->GetCurrentRow()); | |
4951 | } | |
4952 | ||
4953 | void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem& item) | |
4954 | { | |
4955 | const int row = m_clientArea->GetRowByItem(item); | |
4956 | ||
4957 | const unsigned oldCurrent = m_clientArea->GetCurrentRow(); | |
4958 | if ( static_cast<unsigned>(row) != oldCurrent ) | |
4959 | { | |
4960 | m_clientArea->ChangeCurrentRow(row); | |
4961 | m_clientArea->RefreshRow(oldCurrent); | |
4962 | m_clientArea->RefreshRow(row); | |
4963 | } | |
4964 | } | |
4965 | ||
ee1377e1 VS |
4966 | wxDataViewColumn *wxDataViewCtrl::GetCurrentColumn() const |
4967 | { | |
4968 | return m_clientArea->GetCurrentColumn(); | |
4969 | } | |
4970 | ||
fa93d732 | 4971 | int wxDataViewCtrl::GetSelectedItemsCount() const |
66e09788 | 4972 | { |
fa93d732 | 4973 | return m_clientArea->GetSelections().size(); |
66e09788 RR |
4974 | } |
4975 | ||
b7e9f8b1 RR |
4976 | int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const |
4977 | { | |
4978 | sel.Empty(); | |
f23b8c0d | 4979 | const wxDataViewSelection& selections = m_clientArea->GetSelections(); |
373a4816 | 4980 | |
f23b8c0d | 4981 | const size_t len = selections.size(); |
eceb6af1 | 4982 | for ( size_t i = 0; i < len; i++ ) |
b7e9f8b1 | 4983 | { |
f23b8c0d | 4984 | wxDataViewItem item = m_clientArea->GetItemByRow(selections[i]); |
373a4816 VS |
4985 | if ( item.IsOk() ) |
4986 | { | |
4987 | sel.Add(item); | |
4988 | } | |
4989 | else | |
4990 | { | |
4991 | wxFAIL_MSG( "invalid item in selection - bad internal state" ); | |
4992 | } | |
b7e9f8b1 | 4993 | } |
373a4816 VS |
4994 | |
4995 | return sel.size(); | |
b7e9f8b1 RR |
4996 | } |
4997 | ||
4998 | void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel ) | |
4999 | { | |
59e60167 | 5000 | wxDataViewSelection selection(wxDataViewSelectionCmp); |
4219d8b0 RR |
5001 | |
5002 | wxDataViewItem last_parent; | |
5003 | ||
b7e9f8b1 RR |
5004 | int len = sel.GetCount(); |
5005 | for( int i = 0; i < len; i ++ ) | |
5006 | { | |
4219d8b0 RR |
5007 | wxDataViewItem item = sel[i]; |
5008 | wxDataViewItem parent = GetModel()->GetParent( item ); | |
5009 | if (parent) | |
5010 | { | |
5011 | if (parent != last_parent) | |
5012 | ExpandAncestors(item); | |
5013 | } | |
9adeb77a | 5014 | |
4219d8b0 RR |
5015 | last_parent = parent; |
5016 | int row = m_clientArea->GetRowByItem( item ); | |
b7e9f8b1 RR |
5017 | if( row >= 0 ) |
5018 | selection.Add( static_cast<unsigned int>(row) ); | |
5019 | } | |
9adeb77a | 5020 | |
b7e9f8b1 RR |
5021 | m_clientArea->SetSelections( selection ); |
5022 | } | |
5023 | ||
5024 | void wxDataViewCtrl::Select( const wxDataViewItem & item ) | |
704c3490 | 5025 | { |
4219d8b0 | 5026 | ExpandAncestors( item ); |
9adeb77a | 5027 | |
b7e9f8b1 RR |
5028 | int row = m_clientArea->GetRowByItem( item ); |
5029 | if( row >= 0 ) | |
57f2a652 | 5030 | { |
bc4f1ff2 | 5031 | // Unselect all rows before select another in the single select mode |
57f2a652 RR |
5032 | if (m_clientArea->IsSingleSel()) |
5033 | m_clientArea->SelectAllRows(false); | |
ce00f59b | 5034 | |
b7e9f8b1 | 5035 | m_clientArea->SelectRow(row, true); |
ce00f59b | 5036 | |
de67922e RR |
5037 | // Also set focus to the selected item |
5038 | m_clientArea->ChangeCurrentRow( row ); | |
57f2a652 | 5039 | } |
704c3490 | 5040 | } |
3b6280be | 5041 | |
b7e9f8b1 | 5042 | void wxDataViewCtrl::Unselect( const wxDataViewItem & item ) |
6ff7eee7 | 5043 | { |
b7e9f8b1 RR |
5044 | int row = m_clientArea->GetRowByItem( item ); |
5045 | if( row >= 0 ) | |
5046 | m_clientArea->SelectRow(row, false); | |
6ff7eee7 RR |
5047 | } |
5048 | ||
b7e9f8b1 | 5049 | bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const |
6ff7eee7 | 5050 | { |
b7e9f8b1 RR |
5051 | int row = m_clientArea->GetRowByItem( item ); |
5052 | if( row >= 0 ) | |
5053 | { | |
5054 | return m_clientArea->IsRowSelected(row); | |
5055 | } | |
5056 | return false; | |
6ff7eee7 RR |
5057 | } |
5058 | ||
4bdc891f VZ |
5059 | void wxDataViewCtrl::SetAlternateRowColour(const wxColour& colour) |
5060 | { | |
5061 | m_alternateRowColour = colour; | |
5062 | } | |
5063 | ||
b7e9f8b1 | 5064 | void wxDataViewCtrl::SelectAll() |
6ff7eee7 | 5065 | { |
b7e9f8b1 RR |
5066 | m_clientArea->SelectAllRows(true); |
5067 | } | |
df387169 | 5068 | |
b7e9f8b1 RR |
5069 | void wxDataViewCtrl::UnselectAll() |
5070 | { | |
5071 | m_clientArea->SelectAllRows(false); | |
6ff7eee7 | 5072 | } |
b7e9f8b1 | 5073 | |
fbda518c | 5074 | void wxDataViewCtrl::EnsureVisible( int row, int column ) |
b7e9f8b1 | 5075 | { |
fbda518c RR |
5076 | if( row < 0 ) |
5077 | row = 0; | |
67be459b | 5078 | if( row > (int) m_clientArea->GetRowCount() ) |
fbda518c RR |
5079 | row = m_clientArea->GetRowCount(); |
5080 | ||
5081 | int first = m_clientArea->GetFirstVisibleRow(); | |
5082 | int last = m_clientArea->GetLastVisibleRow(); | |
5083 | if( row < first ) | |
5084 | m_clientArea->ScrollTo( row, column ); | |
5085 | else if( row > last ) | |
5086 | m_clientArea->ScrollTo( row - last + first, column ); | |
5087 | else | |
5088 | m_clientArea->ScrollTo( first, column ); | |
b7e9f8b1 RR |
5089 | } |
5090 | ||
fbda518c | 5091 | void wxDataViewCtrl::EnsureVisible( const wxDataViewItem & item, const wxDataViewColumn * column ) |
b7e9f8b1 | 5092 | { |
4219d8b0 | 5093 | ExpandAncestors( item ); |
9adeb77a | 5094 | |
13499080 RR |
5095 | m_clientArea->RecalculateDisplay(); |
5096 | ||
b7e9f8b1 RR |
5097 | int row = m_clientArea->GetRowByItem(item); |
5098 | if( row >= 0 ) | |
fbda518c RR |
5099 | { |
5100 | if( column == NULL ) | |
9bcc8016 | 5101 | EnsureVisible(row, -1); |
fbda518c | 5102 | else |
702f5349 | 5103 | EnsureVisible( row, GetColumnIndex(column) ); |
fbda518c | 5104 | } |
b7fe2261 | 5105 | |
b7e9f8b1 RR |
5106 | } |
5107 | ||
4cef3873 | 5108 | void wxDataViewCtrl::HitTest( const wxPoint & point, wxDataViewItem & item, |
bc4f1ff2 | 5109 | wxDataViewColumn* &column ) const |
66e09788 RR |
5110 | { |
5111 | m_clientArea->HitTest(point, item, column); | |
5112 | } | |
5113 | ||
4cef3873 | 5114 | wxRect wxDataViewCtrl::GetItemRect( const wxDataViewItem & item, |
bc4f1ff2 | 5115 | const wxDataViewColumn* column ) const |
66e09788 RR |
5116 | { |
5117 | return m_clientArea->GetItemRect(item, column); | |
5118 | } | |
5119 | ||
b7e9f8b1 RR |
5120 | wxDataViewItem wxDataViewCtrl::GetItemByRow( unsigned int row ) const |
5121 | { | |
5122 | return m_clientArea->GetItemByRow( row ); | |
5123 | } | |
5124 | ||
5125 | int wxDataViewCtrl::GetRowByItem( const wxDataViewItem & item ) const | |
5126 | { | |
5127 | return m_clientArea->GetRowByItem( item ); | |
5128 | } | |
5129 | ||
afebb87b RR |
5130 | void wxDataViewCtrl::Expand( const wxDataViewItem & item ) |
5131 | { | |
e3d358bb RR |
5132 | ExpandAncestors( item ); |
5133 | ||
afebb87b RR |
5134 | int row = m_clientArea->GetRowByItem( item ); |
5135 | if (row != -1) | |
b6b17152 | 5136 | { |
afebb87b | 5137 | m_clientArea->Expand(row); |
b6b17152 VS |
5138 | InvalidateColBestWidths(); |
5139 | } | |
afebb87b RR |
5140 | } |
5141 | ||
5142 | void wxDataViewCtrl::Collapse( const wxDataViewItem & item ) | |
5143 | { | |
5144 | int row = m_clientArea->GetRowByItem( item ); | |
5145 | if (row != -1) | |
b6b17152 | 5146 | { |
b7fe2261 | 5147 | m_clientArea->Collapse(row); |
b6b17152 VS |
5148 | InvalidateColBestWidths(); |
5149 | } | |
afebb87b RR |
5150 | } |
5151 | ||
739a8399 RR |
5152 | bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const |
5153 | { | |
5154 | int row = m_clientArea->GetRowByItem( item ); | |
5155 | if (row != -1) | |
5156 | return m_clientArea->IsExpanded(row); | |
5157 | return false; | |
5158 | } | |
5159 | ||
907f09f4 | 5160 | void wxDataViewCtrl::EditItem(const wxDataViewItem& item, const wxDataViewColumn *column) |
c937344c | 5161 | { |
907f09f4 VS |
5162 | wxCHECK_RET( item.IsOk(), "invalid item" ); |
5163 | wxCHECK_RET( column, "no column provided" ); | |
4cef3873 | 5164 | |
907f09f4 | 5165 | m_clientArea->StartEditing(item, column); |
c937344c RR |
5166 | } |
5167 | ||
4cef3873 | 5168 | #endif // !wxUSE_GENERICDATAVIEWCTRL |
4ed7af08 | 5169 | |
4cef3873 | 5170 | #endif // wxUSE_DATAVIEWCTRL |