]> git.saurik.com Git - wxWidgets.git/blob - src/generic/datavgen.cpp
projects / wxWidgets.git / blob
? search:


edf9429ba4fcf9f12769c5096741664d4472d57e
[wxWidgets.git] / src / generic / datavgen.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/datavgen.cpp
3 // Purpose: wxDataViewCtrl generic implementation
4 // Author: Robert Roebling
5 // Modified by: Francesco Montorsi, Guru Kathiresan, Bo Yang
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
14 #ifdef __BORLANDC__
15 #pragma hdrstop
16 #endif
17
18 #if wxUSE_DATAVIEWCTRL
19
20 #include "wx/dataview.h"
21
22 #ifdef wxUSE_GENERICDATAVIEWCTRL
23
24 #ifndef WX_PRECOMP
25 #ifdef __WXMSW__
26 #include "wx/msw/private.h"
27 #include "wx/msw/wrapwin.h"
28 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
29 #endif
30 #include "wx/sizer.h"
31 #include "wx/log.h"
32 #include "wx/dcclient.h"
33 #include "wx/timer.h"
34 #include "wx/settings.h"
35 #include "wx/msgdlg.h"
36 #include "wx/dcscreen.h"
37 #endif
38
39 #include "wx/stockitem.h"
40 #include "wx/calctrl.h"
41 #include "wx/popupwin.h"
42 #include "wx/renderer.h"
43 #include "wx/dcbuffer.h"
44 #include "wx/icon.h"
45 #include "wx/list.h"
46 #include "wx/listimpl.cpp"
47 #include "wx/imaglist.h"
48 #include "wx/headerctrl.h"
49
50 //-----------------------------------------------------------------------------
51 // classes
52 //-----------------------------------------------------------------------------
53
54 class wxDataViewCtrl;
55
56 static const int SCROLL_UNIT_X = 15;
57
58 // the cell padding on the left/right
59 static const int PADDING_RIGHTLEFT = 3;
60
61 // the expander space margin
62 static const int EXPANDER_MARGIN = 4;
63
64 #ifdef __WXMSW__
65 static const int EXPANDER_OFFSET = 4;
66 #else
67 static const int EXPANDER_OFFSET = 1;
68 #endif
69
70 //Below is the compare stuff
71 //For the generic implements, both the leaf nodes and the nodes are sorted for fast search when needed
72 static wxDataViewModel * g_model;
73 static int g_column = -2;
74 static bool g_asending = true;
75
76 //-----------------------------------------------------------------------------
77 // wxDataViewHeaderWindow
78 //-----------------------------------------------------------------------------
79
80 class wxDataViewHeaderWindow : public wxHeaderCtrl
81 {
82 public:
83 wxDataViewHeaderWindow(wxDataViewCtrl *parent)
84 : wxHeaderCtrl(parent)
85 {
86 }
87
88 wxDataViewCtrl *GetOwner() const
89 { return static_cast<wxDataViewCtrl *>(GetParent()); }
90
91 protected:
92 // implement/override wxHeaderCtrl functions by forwarding them to the main
93 // control
94 virtual wxHeaderColumnBase& GetColumn(unsigned int idx)
95 {
96 return *(GetOwner()->GetColumn(idx));
97 }
98
99 virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle)
100 {
101 wxDataViewCtrl * const owner = GetOwner();
102
103 int widthContents = owner->GetBestColumnWidth(idx);
104 owner->GetColumn(idx)->SetWidth(wxMax(widthTitle, widthContents));
105 owner->OnColumnChange(idx);
106
107 return true;
108 }
109
110 private:
111 bool SendEvent(wxEventType type, unsigned int n)
112 {
113 wxDataViewCtrl * const owner = GetOwner();
114 wxDataViewEvent event(type, owner->GetId());
115
116 event.SetEventObject(owner);
117 event.SetColumn(n);
118 event.SetDataViewColumn(owner->GetColumn(n));
119 event.SetModel(owner->GetModel());
120
121 // for events created by wxDataViewHeaderWindow the
122 // row / value fields are not valid
123 return owner->GetEventHandler()->ProcessEvent(event);
124 }
125
126 void OnClick(wxHeaderCtrlEvent& event)
127 {
128 if ( !SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK,
129 event.GetColumn()) )
130 event.Skip();
131 }
132
133 void OnRClick(wxHeaderCtrlEvent& event)
134 {
135 if ( !SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK,
136 event.GetColumn()) )
137 event.Skip();
138 }
139
140 void OnBeginResize(wxHeaderCtrlEvent& event)
141 {
142 if ( !GetColumn(event.GetColumn()).IsResizeable() )
143 event.Veto();
144 }
145
146 void OnEndResize(wxHeaderCtrlEvent& event)
147 {
148 if ( !event.IsCancelled() )
149 {
150 const unsigned col = event.GetColumn();
151 GetColumn(col).SetWidth(event.GetWidth());
152 GetOwner()->OnColumnChange(col);
153 }
154 }
155
156 DECLARE_EVENT_TABLE()
157 DECLARE_NO_COPY_CLASS(wxDataViewHeaderWindow)
158 };
159
160 BEGIN_EVENT_TABLE(wxDataViewHeaderWindow, wxHeaderCtrl)
161 EVT_HEADER_CLICK(wxID_ANY, wxDataViewHeaderWindow::OnClick)
162 EVT_HEADER_RIGHT_CLICK(wxID_ANY, wxDataViewHeaderWindow::OnRClick)
163
164 EVT_HEADER_BEGIN_RESIZE(wxID_ANY, wxDataViewHeaderWindow::OnBeginResize)
165 EVT_HEADER_END_RESIZE(wxID_ANY, wxDataViewHeaderWindow::OnEndResize)
166 END_EVENT_TABLE()
167
168 //-----------------------------------------------------------------------------
169 // wxDataViewRenameTimer
170 //-----------------------------------------------------------------------------
171
172 class wxDataViewRenameTimer: public wxTimer
173 {
174 private:
175 wxDataViewMainWindow *m_owner;
176
177 public:
178 wxDataViewRenameTimer( wxDataViewMainWindow *owner );
179 void Notify();
180 };
181
182 //-----------------------------------------------------------------------------
183 // wxDataViewTreeNode
184 //-----------------------------------------------------------------------------
185 class wxDataViewTreeNode;
186 WX_DEFINE_ARRAY( wxDataViewTreeNode *, wxDataViewTreeNodes );
187 WX_DEFINE_ARRAY( void* , wxDataViewTreeLeaves);
188
189 int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1, wxDataViewTreeNode ** node2);
190 int LINKAGEMODE wxGenericTreeModelItemCmp( void ** id1, void ** id2);
191
192 class wxDataViewTreeNode
193 {
194 public:
195 wxDataViewTreeNode( wxDataViewTreeNode * parent = NULL )
196 {
197 m_parent = parent;
198 if (!parent)
199 m_open = true;
200 else
201 m_open = false;
202 m_hasChildren = false;
203 m_subTreeCount = 0;
204 }
205
206 ~wxDataViewTreeNode()
207 {
208 }
209
210 wxDataViewTreeNode * GetParent() const { return m_parent; }
211 void SetParent( wxDataViewTreeNode * parent ) { m_parent = parent; }
212 wxDataViewTreeNodes & GetNodes() { return m_nodes; }
213 wxDataViewTreeLeaves & GetChildren() { return m_leaves; }
214
215 void AddNode( wxDataViewTreeNode * node )
216 {
217 m_leaves.Add( node->GetItem().GetID() );
218 if (g_column >= -1)
219 m_leaves.Sort( &wxGenericTreeModelItemCmp );
220 m_nodes.Add( node );
221 if (g_column >= -1)
222 m_nodes.Sort( &wxGenericTreeModelNodeCmp );
223 }
224 void AddLeaf( void * leaf )
225 {
226 m_leaves.Add( leaf );
227 if (g_column >= -1)
228 m_leaves.Sort( &wxGenericTreeModelItemCmp );
229 }
230
231 wxDataViewItem & GetItem() { return m_item; }
232 const wxDataViewItem & GetItem() const { return m_item; }
233 void SetItem( const wxDataViewItem & item ) { m_item = item; }
234
235 unsigned int GetChildrenNumber() const { return m_leaves.GetCount(); }
236 unsigned int GetNodeNumber() const { return m_nodes.GetCount(); }
237 int GetIndentLevel() const
238 {
239 int ret = 0;
240 const wxDataViewTreeNode * node = this;
241 while( node->GetParent()->GetParent() != NULL )
242 {
243 node = node->GetParent();
244 ret ++;
245 }
246 return ret;
247 }
248
249 bool IsOpen() const
250 {
251 return m_open;
252 }
253
254 void ToggleOpen()
255 {
256 int len = m_nodes.GetCount();
257 int sum = 0;
258 for ( int i = 0;i < len; i ++)
259 sum += m_nodes[i]->GetSubTreeCount();
260
261 sum += m_leaves.GetCount();
262 if (m_open)
263 {
264 ChangeSubTreeCount(-sum);
265 m_open = !m_open;
266 }
267 else
268 {
269 m_open = !m_open;
270 ChangeSubTreeCount(sum);
271 }
272 }
273 bool HasChildren() const { return m_hasChildren; }
274 void SetHasChildren( bool has ){ m_hasChildren = has; }
275
276 void SetSubTreeCount( int num ) { m_subTreeCount = num; }
277 int GetSubTreeCount() const { return m_subTreeCount; }
278 void ChangeSubTreeCount( int num )
279 {
280 if( !m_open )
281 return;
282 m_subTreeCount += num;
283 if( m_parent )
284 m_parent->ChangeSubTreeCount(num);
285 }
286
287 void Resort()
288 {
289 if (g_column >= -1)
290 {
291 m_nodes.Sort( &wxGenericTreeModelNodeCmp );
292 int len = m_nodes.GetCount();
293 for (int i = 0; i < len; i ++)
294 m_nodes[i]->Resort();
295 m_leaves.Sort( &wxGenericTreeModelItemCmp );
296 }
297 }
298
299 private:
300 wxDataViewTreeNode *m_parent;
301 wxDataViewTreeNodes m_nodes;
302 wxDataViewTreeLeaves m_leaves;
303 wxDataViewItem m_item;
304 bool m_open;
305 bool m_hasChildren;
306 int m_subTreeCount;
307 };
308
309 int LINKAGEMODE wxGenericTreeModelNodeCmp( wxDataViewTreeNode ** node1, wxDataViewTreeNode ** node2)
310 {
311 return g_model->Compare( (*node1)->GetItem(), (*node2)->GetItem(), g_column, g_asending );
312 }
313
314 int LINKAGEMODE wxGenericTreeModelItemCmp( void ** id1, void ** id2)
315 {
316 return g_model->Compare( *id1, *id2, g_column, g_asending );
317 }
318
319
320
321 //-----------------------------------------------------------------------------
322 // wxDataViewMainWindow
323 //-----------------------------------------------------------------------------
324
325 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection,
326 WXDLLIMPEXP_ADV);
327 WX_DECLARE_LIST(wxDataViewItem, ItemList);
328 WX_DEFINE_LIST(ItemList)
329
330 class wxDataViewMainWindow: public wxWindow
331 {
332 public:
333 wxDataViewMainWindow( wxDataViewCtrl *parent,
334 wxWindowID id,
335 const wxPoint &pos = wxDefaultPosition,
336 const wxSize &size = wxDefaultSize,
337 const wxString &name = wxT("wxdataviewctrlmainwindow") );
338 virtual ~wxDataViewMainWindow();
339
340 bool IsVirtualList() const { return m_root == NULL; }
341
342 // notifications from wxDataViewModel
343 bool ItemAdded( const wxDataViewItem &parent, const wxDataViewItem &item );
344 bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item );
345 bool ItemChanged( const wxDataViewItem &item );
346 bool ValueChanged( const wxDataViewItem &item, unsigned int col );
347 bool Cleared();
348 void Resort()
349 {
350 if (!IsVirtualList())
351 {
352 SortPrepare();
353 m_root->Resort();
354 }
355 UpdateDisplay();
356 }
357
358 void SortPrepare()
359 {
360 g_model = GetOwner()->GetModel();
361 wxDataViewColumn* col = GetOwner()->GetSortingColumn();
362 if( !col )
363 {
364 if (g_model->HasDefaultCompare())
365 g_column = -1;
366 else
367 g_column = -2;
368
369 g_asending = true;
370 return;
371 }
372 g_column = col->GetModelColumn();
373 g_asending = col->IsSortOrderAscending();
374 }
375
376 void SetOwner( wxDataViewCtrl* owner ) { m_owner = owner; }
377 wxDataViewCtrl *GetOwner() { return m_owner; }
378 const wxDataViewCtrl *GetOwner() const { return m_owner; }
379
380 void OnPaint( wxPaintEvent &event );
381 void OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event);
382 void OnChar( wxKeyEvent &event );
383 void OnMouse( wxMouseEvent &event );
384 void OnSetFocus( wxFocusEvent &event );
385 void OnKillFocus( wxFocusEvent &event );
386
387 void UpdateDisplay();
388 void RecalculateDisplay();
389 void OnInternalIdle();
390
391 void OnRenameTimer();
392
393 void ScrollWindow( int dx, int dy, const wxRect *rect = NULL );
394 void ScrollTo( int rows, int column );
395
396 bool HasCurrentRow() { return m_currentRow != (unsigned int)-1; }
397 void ChangeCurrentRow( unsigned int row );
398
399 bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE); }
400 bool IsEmpty() { return GetRowCount() == 0; }
401
402 int GetCountPerPage() const;
403 int GetEndOfLastCol() const;
404 unsigned int GetFirstVisibleRow() const;
405 //I change this method to un const because in the tree view, the displaying number of the tree are changing along with the expanding/collapsing of the tree nodes
406 unsigned int GetLastVisibleRow();
407 unsigned int GetRowCount();
408
409 wxDataViewItem GetSelection() const;
410 wxDataViewSelection GetSelections(){ return m_selection; }
411 void SetSelections( const wxDataViewSelection & sel ) { m_selection = sel; UpdateDisplay(); }
412 void Select( const wxArrayInt& aSelections );
413 void SelectAllRows( bool on );
414 void SelectRow( unsigned int row, bool on );
415 void SelectRows( unsigned int from, unsigned int to, bool on );
416 void ReverseRowSelection( unsigned int row );
417 bool IsRowSelected( unsigned int row );
418 void SendSelectionChangedEvent( const wxDataViewItem& item);
419
420 void RefreshRow( unsigned int row );
421 void RefreshRows( unsigned int from, unsigned int to );
422 void RefreshRowsAfter( unsigned int firstRow );
423
424 // returns the colour to be used for drawing the rules
425 wxColour GetRuleColour() const
426 {
427 return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT);
428 }
429
430 wxRect GetLineRect( unsigned int row ) const;
431
432 int GetLineStart( unsigned int row ) const; // row * m_lineHeight in fixed mode
433 int GetLineHeight( unsigned int row ) const; // m_lineHeight in fixed mode
434 int GetLineAt( unsigned int y ) const; // y / m_lineHeight in fixed mode
435
436 //Some useful functions for row and item mapping
437 wxDataViewItem GetItemByRow( unsigned int row ) const;
438 int GetRowByItem( const wxDataViewItem & item ) const;
439
440 //Methods for building the mapping tree
441 void BuildTree( wxDataViewModel * model );
442 void DestroyTree();
443 void HitTest( const wxPoint & point, wxDataViewItem & item, wxDataViewColumn* &column );
444 wxRect GetItemRect( const wxDataViewItem & item, const wxDataViewColumn* column );
445
446 void Expand( unsigned int row ) { OnExpanding( row ); }
447 void Collapse( unsigned int row ) { OnCollapsing( row ); }
448 private:
449 wxDataViewTreeNode * GetTreeNodeByRow( unsigned int row ) const;
450 //We did not need this temporarily
451 //wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item );
452
453 int RecalculateCount();
454
455 wxDataViewEvent SendExpanderEvent( wxEventType type, const wxDataViewItem & item );
456 void OnExpanding( unsigned int row );
457 void OnCollapsing( unsigned int row );
458
459 wxDataViewTreeNode * FindNode( const wxDataViewItem & item );
460
461 private:
462 wxDataViewCtrl *m_owner;
463 int m_lineHeight;
464 bool m_dirty;
465
466 wxDataViewColumn *m_currentCol;
467 unsigned int m_currentRow;
468 wxDataViewSelection m_selection;
469
470 wxDataViewRenameTimer *m_renameTimer;
471 bool m_lastOnSame;
472
473 bool m_hasFocus;
474
475 int m_dragCount;
476 wxPoint m_dragStart;
477
478 // for double click logic
479 unsigned int m_lineLastClicked,
480 m_lineBeforeLastClicked,
481 m_lineSelectSingleOnUp;
482
483 // the pen used to draw horiz/vertical rules
484 wxPen m_penRule;
485
486 // the pen used to draw the expander and the lines
487 wxPen m_penExpander;
488
489 //This is the tree structure of the model
490 wxDataViewTreeNode * m_root;
491 int m_count;
492 //This is the tree node under the cursor
493 wxDataViewTreeNode * m_underMouse;
494 private:
495 DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow)
496 DECLARE_EVENT_TABLE()
497 };
498
499 // ---------------------------------------------------------
500 // wxGenericDataViewModelNotifier
501 // ---------------------------------------------------------
502
503 class wxGenericDataViewModelNotifier: public wxDataViewModelNotifier
504 {
505 public:
506 wxGenericDataViewModelNotifier( wxDataViewMainWindow *mainWindow )
507 { m_mainWindow = mainWindow; }
508
509 virtual bool ItemAdded( const wxDataViewItem & parent, const wxDataViewItem & item )
510 { return m_mainWindow->ItemAdded( parent , item ); }
511 virtual bool ItemDeleted( const wxDataViewItem &parent, const wxDataViewItem &item )
512 { return m_mainWindow->ItemDeleted( parent, item ); }
513 virtual bool ItemChanged( const wxDataViewItem & item )
514 { return m_mainWindow->ItemChanged(item); }
515 virtual bool ValueChanged( const wxDataViewItem & item , unsigned int col )
516 { return m_mainWindow->ValueChanged( item, col ); }
517 virtual bool Cleared()
518 { return m_mainWindow->Cleared(); }
519 virtual void Resort()
520 { m_mainWindow->Resort(); }
521
522 wxDataViewMainWindow *m_mainWindow;
523 };
524
525 // ---------------------------------------------------------
526 // wxDataViewRenderer
527 // ---------------------------------------------------------
528
529 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
530
531 wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype,
532 wxDataViewCellMode mode,
533 int align) :
534 wxDataViewRendererBase( varianttype, mode, align )
535 {
536 m_dc = NULL;
537 m_align = align;
538 m_mode = mode;
539 m_wantsAttr = false;
540 m_hasAttr = false;
541 }
542
543 wxDataViewRenderer::~wxDataViewRenderer()
544 {
545 if (m_dc)
546 delete m_dc;
547 }
548
549 wxDC *wxDataViewRenderer::GetDC()
550 {
551 if (m_dc == NULL)
552 {
553 if (GetOwner() == NULL)
554 return NULL;
555 if (GetOwner()->GetOwner() == NULL)
556 return NULL;
557 m_dc = new wxClientDC( GetOwner()->GetOwner() );
558 }
559
560 return m_dc;
561 }
562
563 void wxDataViewRenderer::SetAlignment( int align )
564 {
565 m_align=align;
566 }
567
568 int wxDataViewRenderer::GetAlignment() const
569 {
570 return m_align;
571 }
572
573 int wxDataViewRenderer::CalculateAlignment() const
574 {
575 if (m_align == wxDVR_DEFAULT_ALIGNMENT)
576 {
577 if (GetOwner() == NULL)
578 return wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL;
579
580 return GetOwner()->GetAlignment() | wxALIGN_CENTRE_VERTICAL;
581 }
582
583 return m_align;
584 }
585
586 // ---------------------------------------------------------
587 // wxDataViewCustomRenderer
588 // ---------------------------------------------------------
589
590 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
591
592 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString &varianttype,
593 wxDataViewCellMode mode, int align ) :
594 wxDataViewRenderer( varianttype, mode, align )
595 {
596 }
597
598 void wxDataViewCustomRenderer::RenderText( const wxString &text, int xoffset, wxRect cell, wxDC *dc, int state )
599 {
600 wxDataViewCtrl *view = GetOwner()->GetOwner();
601 wxColour col = (state & wxDATAVIEW_CELL_SELECTED) ?
602 wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) :
603 view->GetForegroundColour();
604 dc->SetTextForeground(col);
605 dc->DrawText( text, cell.x + xoffset, cell.y + ((cell.height - dc->GetCharHeight()) / 2));
606 }
607
608 // ---------------------------------------------------------
609 // wxDataViewTextRenderer
610 // ---------------------------------------------------------
611
612 IMPLEMENT_CLASS(wxDataViewTextRenderer, wxDataViewCustomRenderer)
613
614 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString &varianttype,
615 wxDataViewCellMode mode, int align ) :
616 wxDataViewCustomRenderer( varianttype, mode, align )
617 {
618 }
619
620 bool wxDataViewTextRenderer::SetValue( const wxVariant &value )
621 {
622 m_text = value.GetString();
623
624 return true;
625 }
626
627 bool wxDataViewTextRenderer::GetValue( wxVariant& WXUNUSED(value) ) const
628 {
629 return false;
630 }
631
632 bool wxDataViewTextRenderer::HasEditorCtrl()
633 {
634 return true;
635 }
636
637 wxControl* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow *parent,
638 wxRect labelRect, const wxVariant &value )
639 {
640 return new wxTextCtrl( parent, wxID_ANY, value,
641 wxPoint(labelRect.x,labelRect.y),
642 wxSize(labelRect.width,labelRect.height) );
643 }
644
645 bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxControl *editor, wxVariant &value )
646 {
647 wxTextCtrl *text = (wxTextCtrl*) editor;
648 value = text->GetValue();
649 return true;
650 }
651
652 bool wxDataViewTextRenderer::Render( wxRect cell, wxDC *dc, int state )
653 {
654 RenderText( m_text, 0, cell, dc, state );
655 return true;
656 }
657
658 wxSize wxDataViewTextRenderer::GetSize() const
659 {
660 const wxDataViewCtrl *view = GetView();
661 if (!m_text.empty())
662 {
663 int x,y;
664 view->GetTextExtent( m_text, &x, &y );
665 return wxSize( x, y );
666 }
667 return wxSize(80,20);
668 }
669
670 // ---------------------------------------------------------
671 // wxDataViewTextRendererAttr
672 // ---------------------------------------------------------
673
674 IMPLEMENT_CLASS(wxDataViewTextRendererAttr, wxDataViewTextRenderer)
675
676 wxDataViewTextRendererAttr::wxDataViewTextRendererAttr( const wxString &varianttype,
677 wxDataViewCellMode mode, int align ) :
678 wxDataViewTextRenderer( varianttype, mode, align )
679 {
680 m_wantsAttr = true;
681 }
682
683 bool wxDataViewTextRendererAttr::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
684 {
685 wxFont font;
686 wxColour colour;
687
688 if (m_hasAttr)
689 {
690 if (m_attr.HasColour())
691 {
692 colour = dc->GetTextForeground();
693 dc->SetTextForeground( m_attr.GetColour() );
694 }
695
696 if (m_attr.GetBold() || m_attr.GetItalic())
697 {
698 font = dc->GetFont();
699 wxFont myfont = font;
700 if (m_attr.GetBold())
701 myfont.SetWeight( wxFONTWEIGHT_BOLD );
702 if (m_attr.GetItalic())
703 myfont.SetStyle( wxFONTSTYLE_ITALIC );
704 dc->SetFont( myfont );
705 }
706 }
707
708 dc->DrawText( m_text, cell.x, cell.y + ((cell.height - dc->GetCharHeight()) / 2));
709
710 // restore dc
711 if (m_hasAttr)
712 {
713 if (m_attr.HasColour())
714 dc->SetTextForeground( colour );
715
716 if (m_attr.GetBold() || m_attr.GetItalic())
717 dc->SetFont( font );
718 }
719
720 return true;
721 }
722
723
724 // ---------------------------------------------------------
725 // wxDataViewBitmapRenderer
726 // ---------------------------------------------------------
727
728 IMPLEMENT_CLASS(wxDataViewBitmapRenderer, wxDataViewCustomRenderer)
729
730 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString &varianttype,
731 wxDataViewCellMode mode, int align ) :
732 wxDataViewCustomRenderer( varianttype, mode, align )
733 {
734 }
735
736 bool wxDataViewBitmapRenderer::SetValue( const wxVariant &value )
737 {
738 if (value.GetType() == wxT("wxBitmap"))
739 m_bitmap << value;
740 if (value.GetType() == wxT("wxIcon"))
741 m_icon << value;
742
743 return true;
744 }
745
746 bool wxDataViewBitmapRenderer::GetValue( wxVariant& WXUNUSED(value) ) const
747 {
748 return false;
749 }
750
751 bool wxDataViewBitmapRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
752 {
753 if (m_bitmap.Ok())
754 dc->DrawBitmap( m_bitmap, cell.x, cell.y );
755 else if (m_icon.Ok())
756 dc->DrawIcon( m_icon, cell.x, cell.y );
757
758 return true;
759 }
760
761 wxSize wxDataViewBitmapRenderer::GetSize() const
762 {
763 if (m_bitmap.Ok())
764 return wxSize( m_bitmap.GetWidth(), m_bitmap.GetHeight() );
765 else if (m_icon.Ok())
766 return wxSize( m_icon.GetWidth(), m_icon.GetHeight() );
767
768 return wxSize(16,16);
769 }
770
771 // ---------------------------------------------------------
772 // wxDataViewToggleRenderer
773 // ---------------------------------------------------------
774
775 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer, wxDataViewCustomRenderer)
776
777 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString &varianttype,
778 wxDataViewCellMode mode, int align ) :
779 wxDataViewCustomRenderer( varianttype, mode, align )
780 {
781 m_toggle = false;
782 }
783
784 bool wxDataViewToggleRenderer::SetValue( const wxVariant &value )
785 {
786 m_toggle = value.GetBool();
787
788 return true;
789 }
790
791 bool wxDataViewToggleRenderer::GetValue( wxVariant &WXUNUSED(value) ) const
792 {
793 return false;
794 }
795
796 bool wxDataViewToggleRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
797 {
798 // User wxRenderer here
799
800 wxRect rect;
801 rect.x = cell.x + cell.width/2 - 10;
802 rect.width = 20;
803 rect.y = cell.y + cell.height/2 - 10;
804 rect.height = 20;
805
806 int flags = 0;
807 if (m_toggle)
808 flags |= wxCONTROL_CHECKED;
809 if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE)
810 flags |= wxCONTROL_DISABLED;
811
812 wxRendererNative::Get().DrawCheckBox(
813 GetOwner()->GetOwner(),
814 *dc,
815 rect,
816 flags );
817
818 return true;
819 }
820
821 bool wxDataViewToggleRenderer::Activate( wxRect WXUNUSED(cell),
822 wxDataViewModel *model,
823 const wxDataViewItem & item, unsigned int col)
824 {
825 bool value = !m_toggle;
826 wxVariant variant = value;
827 model->SetValue( variant, item, col);
828 model->ValueChanged( item, col );
829 return true;
830 }
831
832 wxSize wxDataViewToggleRenderer::GetSize() const
833 {
834 return wxSize(20,20);
835 }
836
837 // ---------------------------------------------------------
838 // wxDataViewProgressRenderer
839 // ---------------------------------------------------------
840
841 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer, wxDataViewCustomRenderer)
842
843 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString &label,
844 const wxString &varianttype, wxDataViewCellMode mode, int align ) :
845 wxDataViewCustomRenderer( varianttype, mode, align )
846 {
847 m_label = label;
848 m_value = 0;
849 }
850
851 wxDataViewProgressRenderer::~wxDataViewProgressRenderer()
852 {
853 }
854
855 bool wxDataViewProgressRenderer::SetValue( const wxVariant &value )
856 {
857 m_value = (long) value;
858
859 if (m_value < 0) m_value = 0;
860 if (m_value > 100) m_value = 100;
861
862 return true;
863 }
864
865 bool wxDataViewProgressRenderer::GetValue( wxVariant &value ) const
866 {
867 value = (long) m_value;
868 return true;
869 }
870
871 bool wxDataViewProgressRenderer::Render( wxRect cell, wxDC *dc, int WXUNUSED(state) )
872 {
873 double pct = (double)m_value / 100.0;
874 wxRect bar = cell;
875 bar.width = (int)(cell.width * pct);
876 dc->SetPen( *wxTRANSPARENT_PEN );
877 dc->SetBrush( *wxBLUE_BRUSH );
878 dc->DrawRectangle( bar );
879
880 dc->SetBrush( *wxTRANSPARENT_BRUSH );
881 dc->SetPen( *wxBLACK_PEN );
882 dc->DrawRectangle( cell );
883
884 return true;
885 }
886
887 wxSize wxDataViewProgressRenderer::GetSize() const
888 {
889 return wxSize(40,12);
890 }
891
892 // ---------------------------------------------------------
893 // wxDataViewDateRenderer
894 // ---------------------------------------------------------
895
896 #define wxUSE_DATE_RENDERER_POPUP (wxUSE_CALENDARCTRL && wxUSE_POPUPWIN)
897
898 #if wxUSE_DATE_RENDERER_POPUP
899
900 class wxDataViewDateRendererPopupTransient: public wxPopupTransientWindow
901 {
902 public:
903 wxDataViewDateRendererPopupTransient( wxWindow* parent, wxDateTime *value,
904 wxDataViewModel *model, const wxDataViewItem & item, unsigned int col) :
905 wxPopupTransientWindow( parent, wxBORDER_SIMPLE ),
906 m_item( item )
907 {
908 m_model = model;
909 m_col = col;
910 m_cal = new wxCalendarCtrl( this, wxID_ANY, *value );
911 wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );
912 sizer->Add( m_cal, 1, wxGROW );
913 SetSizer( sizer );
914 sizer->Fit( this );
915 }
916
917 void OnCalendar( wxCalendarEvent &event );
918
919 wxCalendarCtrl *m_cal;
920 wxDataViewModel *m_model;
921 unsigned int m_col;
922 const wxDataViewItem & m_item;
923
924 protected:
925 virtual void OnDismiss()
926 {
927 }
928
929 private:
930 DECLARE_EVENT_TABLE()
931 };
932
933 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient,wxPopupTransientWindow)
934 EVT_CALENDAR( wxID_ANY, wxDataViewDateRendererPopupTransient::OnCalendar )
935 END_EVENT_TABLE()
936
937 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent &event )
938 {
939 wxDateTime date = event.GetDate();
940 wxVariant value = date;
941 m_model->SetValue( value, m_item, m_col );
942 m_model->ValueChanged( m_item, m_col );
943 DismissAndNotify();
944 }
945
946 #endif // wxUSE_DATE_RENDERER_POPUP
947
948 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer, wxDataViewCustomRenderer)
949
950 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString &varianttype,
951 wxDataViewCellMode mode, int align ) :
952 wxDataViewCustomRenderer( varianttype, mode, align )
953 {
954 }
955
956 bool wxDataViewDateRenderer::SetValue( const wxVariant &value )
957 {
958 m_date = value.GetDateTime();
959
960 return true;
961 }
962
963 bool wxDataViewDateRenderer::GetValue( wxVariant &value ) const
964 {
965 value = m_date;
966 return true;
967 }
968
969 bool wxDataViewDateRenderer::Render( wxRect cell, wxDC *dc, int state )
970 {
971 wxString tmp = m_date.FormatDate();
972 RenderText( tmp, 0, cell, dc, state );
973 return true;
974 }
975
976 wxSize wxDataViewDateRenderer::GetSize() const
977 {
978 const wxDataViewCtrl* view = GetView();
979 wxString tmp = m_date.FormatDate();
980 wxCoord x,y,d;
981 view->GetTextExtent( tmp, &x, &y, &d );
982 return wxSize(x,y+d);
983 }
984
985 bool wxDataViewDateRenderer::Activate( wxRect WXUNUSED(cell), wxDataViewModel *model,
986 const wxDataViewItem & item, unsigned int col )
987 {
988 wxVariant variant;
989 model->GetValue( variant, item, col );
990 wxDateTime value = variant.GetDateTime();
991
992 #if wxUSE_DATE_RENDERER_POPUP
993 wxDataViewDateRendererPopupTransient *popup = new wxDataViewDateRendererPopupTransient(
994 GetOwner()->GetOwner()->GetParent(), &value, model, item, col);
995 wxPoint pos = wxGetMousePosition();
996 popup->Move( pos );
997 popup->Layout();
998 popup->Popup( popup->m_cal );
999 #else // !wxUSE_DATE_RENDERER_POPUP
1000 wxMessageBox(value.Format());
1001 #endif // wxUSE_DATE_RENDERER_POPUP/!wxUSE_DATE_RENDERER_POPUP
1002 return true;
1003 }
1004
1005 // ---------------------------------------------------------
1006 // wxDataViewIconTextRenderer
1007 // ---------------------------------------------------------
1008
1009 IMPLEMENT_CLASS(wxDataViewIconTextRenderer, wxDataViewCustomRenderer)
1010
1011 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(
1012 const wxString &varianttype, wxDataViewCellMode mode, int align ) :
1013 wxDataViewCustomRenderer( varianttype, mode, align )
1014 {
1015 SetMode(mode);
1016 SetAlignment(align);
1017 }
1018
1019 wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
1020 {
1021 }
1022
1023 bool wxDataViewIconTextRenderer::SetValue( const wxVariant &value )
1024 {
1025 m_value << value;
1026 return true;
1027 }
1028
1029 bool wxDataViewIconTextRenderer::GetValue( wxVariant& WXUNUSED(value) ) const
1030 {
1031 return false;
1032 }
1033
1034 bool wxDataViewIconTextRenderer::Render( wxRect cell, wxDC *dc, int state )
1035 {
1036 int xoffset = 0;
1037 const wxIcon &icon = m_value.GetIcon();
1038 if (icon.IsOk())
1039 {
1040 dc->DrawIcon( icon, cell.x, cell.y + ((cell.height - icon.GetHeight()) / 2));
1041 xoffset = icon.GetWidth()+4;
1042 }
1043
1044 RenderText( m_value.GetText(), xoffset, cell, dc, state );
1045
1046 return true;
1047 }
1048
1049 wxSize wxDataViewIconTextRenderer::GetSize() const
1050 {
1051 const wxDataViewCtrl *view = GetView();
1052 if (!m_value.GetText().empty())
1053 {
1054 int x,y;
1055 view->GetTextExtent( m_value.GetText(), &x, &y );
1056
1057 if (m_value.GetIcon().IsOk())
1058 x += m_value.GetIcon().GetWidth() + 4;
1059 return wxSize( x, y );
1060 }
1061 return wxSize(80,20);
1062 }
1063
1064 wxControl *
1065 wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow * WXUNUSED(parent),
1066 wxRect WXUNUSED(labelRect),
1067 const wxVariant& WXUNUSED(value))
1068 {
1069 return NULL;
1070 }
1071
1072 bool
1073 wxDataViewIconTextRenderer::GetValueFromEditorCtrl(wxControl* WXUNUSED(editor),
1074 wxVariant& WXUNUSED(value))
1075 {
1076 return false;
1077 }
1078
1079 //-----------------------------------------------------------------------------
1080 // wxDataViewRenameTimer
1081 //-----------------------------------------------------------------------------
1082
1083 wxDataViewRenameTimer::wxDataViewRenameTimer( wxDataViewMainWindow *owner )
1084 {
1085 m_owner = owner;
1086 }
1087
1088 void wxDataViewRenameTimer::Notify()
1089 {
1090 m_owner->OnRenameTimer();
1091 }
1092
1093 //-----------------------------------------------------------------------------
1094 // wxDataViewMainWindow
1095 //-----------------------------------------------------------------------------
1096
1097 //The tree building helper, declared firstly
1098 static void BuildTreeHelper( wxDataViewModel * model, wxDataViewItem & item, wxDataViewTreeNode * node);
1099
1100 int LINKAGEMODE wxDataViewSelectionCmp( unsigned int row1, unsigned int row2 )
1101 {
1102 if (row1 > row2) return 1;
1103 if (row1 == row2) return 0;
1104 return -1;
1105 }
1106
1107
1108 IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow, wxWindow)
1109
1110 BEGIN_EVENT_TABLE(wxDataViewMainWindow,wxWindow)
1111 EVT_PAINT (wxDataViewMainWindow::OnPaint)
1112 EVT_MOUSE_EVENTS (wxDataViewMainWindow::OnMouse)
1113 EVT_SET_FOCUS (wxDataViewMainWindow::OnSetFocus)
1114 EVT_KILL_FOCUS (wxDataViewMainWindow::OnKillFocus)
1115 EVT_CHAR (wxDataViewMainWindow::OnChar)
1116 END_EVENT_TABLE()
1117
1118 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl *parent, wxWindowID id,
1119 const wxPoint &pos, const wxSize &size, const wxString &name ) :
1120 wxWindow( parent, id, pos, size, wxWANTS_CHARS|wxBORDER_NONE, name ),
1121 m_selection( wxDataViewSelectionCmp )
1122
1123 {
1124 SetOwner( parent );
1125
1126 m_lastOnSame = false;
1127 m_renameTimer = new wxDataViewRenameTimer( this );
1128
1129 // TODO: user better initial values/nothing selected
1130 m_currentCol = NULL;
1131 m_currentRow = 0;
1132
1133 m_lineHeight = wxMax( 17, GetCharHeight() + 2 ); // 17 = mini icon height + 1
1134
1135 m_dragCount = 0;
1136 m_dragStart = wxPoint(0,0);
1137 m_lineLastClicked = (unsigned int) -1;
1138 m_lineBeforeLastClicked = (unsigned int) -1;
1139 m_lineSelectSingleOnUp = (unsigned int) -1;
1140
1141 m_hasFocus = false;
1142
1143 SetBackgroundColour( *wxWHITE );
1144
1145 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
1146
1147 m_penRule = wxPen(GetRuleColour());
1148
1149 //Here I compose a pen can draw black lines, maybe there are something system colour to use
1150 m_penExpander = wxPen(wxColour(0,0,0));
1151 //Some new added code to deal with the tree structure
1152 m_root = new wxDataViewTreeNode( NULL );
1153 m_root->SetHasChildren(true);
1154
1155 //Make m_count = -1 will cause the class recaculate the real displaying number of rows.
1156 m_count = -1;
1157 m_underMouse = NULL;
1158 UpdateDisplay();
1159 }
1160
1161 wxDataViewMainWindow::~wxDataViewMainWindow()
1162 {
1163 DestroyTree();
1164 delete m_renameTimer;
1165 }
1166
1167 void wxDataViewMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1168 {
1169 wxDataViewModel *model = GetOwner()->GetModel();
1170 wxAutoBufferedPaintDC dc( this );
1171
1172 #ifdef __WXMSW__
1173 dc.SetPen( *wxTRANSPARENT_PEN );
1174 dc.SetBrush( wxBrush( GetBackgroundColour()) );
1175 dc.SetBrush( *wxWHITE_BRUSH );
1176 wxSize size( GetClientSize() );
1177 dc.DrawRectangle( 0,0,size.x,size.y );
1178 #endif
1179
1180 // prepare the DC
1181 GetOwner()->PrepareDC( dc );
1182 dc.SetFont( GetFont() );
1183
1184 wxRect update = GetUpdateRegion().GetBox();
1185 m_owner->CalcUnscrolledPosition( update.x, update.y, &update.x, &update.y );
1186
1187 // compute which items needs to be redrawn
1188 unsigned int item_start = GetLineAt( wxMax(0,update.y) );
1189 unsigned int item_count =
1190 wxMin( (int)( GetLineAt( wxMax(0,update.y+update.height) ) - item_start + 1),
1191 (int)(GetRowCount( ) - item_start));
1192 unsigned int item_last = item_start + item_count;
1193
1194 // compute which columns needs to be redrawn
1195 unsigned int cols = GetOwner()->GetColumnCount();
1196 unsigned int col_start = 0;
1197 unsigned int x_start;
1198 for (x_start = 0; col_start < cols; col_start++)
1199 {
1200 wxDataViewColumn *col = GetOwner()->GetColumn(col_start);
1201 if (col->IsHidden())
1202 continue; // skip it!
1203
1204 unsigned int w = col->GetWidth();
1205 if (x_start+w >= (unsigned int)update.x)
1206 break;
1207
1208 x_start += w;
1209 }
1210
1211 unsigned int col_last = col_start;
1212 unsigned int x_last = x_start;
1213 for (; col_last < cols; col_last++)
1214 {
1215 wxDataViewColumn *col = GetOwner()->GetColumn(col_last);
1216 if (col->IsHidden())
1217 continue; // skip it!
1218
1219 if (x_last > (unsigned int)update.GetRight())
1220 break;
1221
1222 x_last += col->GetWidth();
1223 }
1224
1225 // Draw horizontal rules if required
1226 if ( m_owner->HasFlag(wxDV_HORIZ_RULES) )
1227 {
1228 dc.SetPen(m_penRule);
1229 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1230
1231 for (unsigned int i = item_start; i <= item_last+1; i++)
1232 {
1233 int y = GetLineStart( i );
1234 dc.DrawLine(x_start, y, x_last, y);
1235 }
1236 }
1237
1238 // Draw vertical rules if required
1239 if ( m_owner->HasFlag(wxDV_VERT_RULES) )
1240 {
1241 dc.SetPen(m_penRule);
1242 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1243
1244 int x = x_start;
1245 for (unsigned int i = col_start; i < col_last; i++)
1246 {
1247 wxDataViewColumn *col = GetOwner()->GetColumn(i);
1248 if (col->IsHidden())
1249 continue; // skip it
1250
1251 dc.DrawLine(x, GetLineStart( item_start ),
1252 x, GetLineStart( item_last ) );
1253
1254 x += col->GetWidth();
1255 }
1256
1257 // Draw last vertical rule
1258 dc.DrawLine(x, GetLineStart( item_start ),
1259 x, GetLineStart( item_last ) );
1260 }
1261
1262 // redraw the background for the items which are selected/current
1263 for (unsigned int item = item_start; item < item_last; item++)
1264 {
1265 bool selected = m_selection.Index( item ) != wxNOT_FOUND;
1266 if (selected || item == m_currentRow)
1267 {
1268 int flags = selected ? (int)wxCONTROL_SELECTED : 0;
1269 if (item == m_currentRow)
1270 flags |= wxCONTROL_CURRENT;
1271 if (m_hasFocus)
1272 flags |= wxCONTROL_FOCUSED;
1273
1274 wxRect rect( x_start, GetLineStart( item ), x_last, GetLineHeight( item ) );
1275 wxRendererNative::Get().DrawItemSelectionRect
1276 (
1277 this,
1278 dc,
1279 rect,
1280 flags
1281 );
1282 }
1283 }
1284
1285 wxDataViewColumn *expander = GetOwner()->GetExpanderColumn();
1286 if (!expander)
1287 {
1288 // TODO: last column for RTL support
1289 expander = GetOwner()->GetColumn( 0 );
1290 GetOwner()->SetExpanderColumn(expander);
1291 }
1292
1293 // redraw all cells for all rows which must be repainted and all columns
1294 wxRect cell_rect;
1295 cell_rect.x = x_start;
1296 for (unsigned int i = col_start; i < col_last; i++)
1297 {
1298
1299 wxDataViewColumn *col = GetOwner()->GetColumn( i );
1300 wxDataViewRenderer *cell = col->GetRenderer();
1301 cell_rect.width = col->GetWidth();
1302
1303 if (col->IsHidden())
1304 continue; // skip it!
1305
1306 for (unsigned int item = item_start; item < item_last; item++)
1307 {
1308 // get the cell value and set it into the renderer
1309 wxVariant value;
1310 wxDataViewTreeNode *node = NULL;
1311 wxDataViewItem dataitem;
1312
1313 if (!IsVirtualList())
1314 {
1315 node = GetTreeNodeByRow(item);
1316 if( node == NULL )
1317 continue;
1318
1319 dataitem = node->GetItem();
1320
1321 if ((i > 0) && model->IsContainer(dataitem) && !model->HasContainerColumns(dataitem))
1322 continue;
1323 }
1324 else
1325 {
1326 dataitem = wxDataViewItem( wxUIntToPtr(item) );
1327 }
1328
1329 model->GetValue( value, dataitem, col->GetModelColumn());
1330 cell->SetValue( value );
1331
1332 if (cell->GetWantsAttr())
1333 {
1334 wxDataViewItemAttr attr;
1335 bool ret = model->GetAttr( dataitem, col->GetModelColumn(), attr );
1336 if (ret)
1337 cell->SetAttr( attr );
1338 cell->SetHasAttr( ret );
1339 }
1340
1341 // update cell_rect
1342 cell_rect.y = GetLineStart( item );
1343 cell_rect.height = GetLineHeight( item ); // -1 is for the horizontal rules (?)
1344
1345 //Draw the expander here.
1346 int indent = 0;
1347 if ((!IsVirtualList()) && (col == expander))
1348 {
1349 indent = node->GetIndentLevel();
1350
1351 //Calculate the indent first
1352 indent = cell_rect.x + GetOwner()->GetIndent() * indent;
1353
1354 int expander_width = m_lineHeight - 2*EXPANDER_MARGIN;
1355 // change the cell_rect.x to the appropriate pos
1356 int expander_x = indent + EXPANDER_MARGIN;
1357 int expander_y = cell_rect.y + EXPANDER_MARGIN + (GetLineHeight(item) / 2) - (expander_width/2) - EXPANDER_OFFSET;
1358 indent = indent + m_lineHeight; //try to use the m_lineHeight as the expander space
1359 dc.SetPen( m_penExpander );
1360 dc.SetBrush( wxNullBrush );
1361 if( node->HasChildren() )
1362 {
1363 wxRect rect( expander_x , expander_y, expander_width, expander_width);
1364 int flag = 0;
1365 if (m_underMouse == node)
1366 {
1367 flag |= wxCONTROL_CURRENT;
1368 }
1369 if( node->IsOpen() )
1370 wxRendererNative::Get().DrawTreeItemButton( this, dc, rect, flag|wxCONTROL_EXPANDED );
1371 else
1372 wxRendererNative::Get().DrawTreeItemButton( this, dc, rect, flag);
1373 }
1374 //force the expander column to left-center align
1375 cell->SetAlignment( wxALIGN_CENTER_VERTICAL );
1376 }
1377 if (node && !node->HasChildren())
1378 {
1379 // Yes, if the node does not have any child, it must be a leaf which
1380 // mean that it is a temporarily created by GetTreeNodeByRow
1381 wxDELETE(node);
1382 }
1383
1384 // cannot be bigger than allocated space
1385 wxSize size = cell->GetSize();
1386 // Because of the tree structure indent, here we should minus the width of the cell for drawing
1387 size.x = wxMin( size.x + 2*PADDING_RIGHTLEFT, cell_rect.width - indent );
1388 // size.y = wxMin( size.y, cell_rect.height );
1389 size.y = cell_rect.height;
1390
1391 wxRect item_rect(cell_rect.GetTopLeft(), size);
1392 int align = cell->CalculateAlignment();
1393
1394 // horizontal alignment:
1395 item_rect.x = cell_rect.x;
1396 if (align & wxALIGN_CENTER_HORIZONTAL)
1397 item_rect.x = cell_rect.x + (cell_rect.width / 2) - (size.x / 2);
1398 else if (align & wxALIGN_RIGHT)
1399 item_rect.x = cell_rect.x + cell_rect.width - size.x;
1400 //else: wxALIGN_LEFT is the default
1401
1402 // vertical alignment:
1403 item_rect.y = cell_rect.y;
1404 if (align & wxALIGN_CENTER_VERTICAL)
1405 item_rect.y = cell_rect.y + (cell_rect.height / 2) - (size.y / 2);
1406 else if (align & wxALIGN_BOTTOM)
1407 item_rect.y = cell_rect.y + cell_rect.height - size.y;
1408 //else: wxALIGN_TOP is the default
1409
1410 // add padding
1411 item_rect.x += PADDING_RIGHTLEFT;
1412 item_rect.width = size.x - 2 * PADDING_RIGHTLEFT;
1413
1414 //Here we add the tree indent
1415 item_rect.x += indent;
1416
1417 int state = 0;
1418 if (m_hasFocus && (m_selection.Index(item) != wxNOT_FOUND))
1419 state |= wxDATAVIEW_CELL_SELECTED;
1420
1421 // TODO: it would be much more efficient to create a clipping
1422 // region for the entire column being rendered (in the OnPaint
1423 // of wxDataViewMainWindow) instead of a single clip region for
1424 // each cell. However it would mean that each renderer should
1425 // respect the given wxRect's top & bottom coords, eventually
1426 // violating only the left & right coords - however the user can
1427 // make its own renderer and thus we cannot be sure of that.
1428 dc.SetClippingRegion( item_rect );
1429 cell->Render( item_rect, &dc, state );
1430 dc.DestroyClippingRegion();
1431 }
1432
1433 cell_rect.x += cell_rect.width;
1434 }
1435 }
1436
1437 void wxDataViewMainWindow::OnRenameTimer()
1438 {
1439 // We have to call this here because changes may just have
1440 // been made and no screen update taken place.
1441 if ( m_dirty )
1442 wxSafeYield();
1443
1444 int xpos = 0;
1445 unsigned int cols = GetOwner()->GetColumnCount();
1446 unsigned int i;
1447 for (i = 0; i < cols; i++)
1448 {
1449 wxDataViewColumn *c = GetOwner()->GetColumn( i );
1450 if (c->IsHidden())
1451 continue; // skip it!
1452
1453 if (c == m_currentCol)
1454 break;
1455 xpos += c->GetWidth();
1456 }
1457 wxRect labelRect( xpos,
1458 GetLineStart( m_currentRow ),
1459 m_currentCol->GetWidth(),
1460 GetLineHeight( m_currentRow ) );
1461
1462 GetOwner()->CalcScrolledPosition( labelRect.x, labelRect.y,
1463 &labelRect.x, &labelRect.y);
1464
1465 wxDataViewItem item = GetItemByRow( m_currentRow );
1466 m_currentCol->GetRenderer()->StartEditing( item, labelRect );
1467
1468 }
1469
1470 //------------------------------------------------------------------
1471 // Helper class for do operation on the tree node
1472 //------------------------------------------------------------------
1473 class DoJob
1474 {
1475 public:
1476 DoJob() { }
1477 virtual ~DoJob() { }
1478
1479 //The return value control how the tree-walker tranverse the tree
1480 // 0: Job done, stop tranverse and return
1481 // 1: Ignore the current node's subtree and continue
1482 // 2: Job not done, continue
1483 enum { OK = 0 , IGR = 1, CONT = 2 };
1484 virtual int operator() ( wxDataViewTreeNode * node ) = 0;
1485 virtual int operator() ( void * n ) = 0;
1486 };
1487
1488 bool Walker( wxDataViewTreeNode * node, DoJob & func )
1489 {
1490 if( node==NULL )
1491 return false;
1492
1493 switch( func( node ) )
1494 {
1495 case DoJob::OK :
1496 return true;
1497 case DoJob::IGR:
1498 return false;
1499 case DoJob::CONT:
1500 default:
1501 ;
1502 }
1503
1504 wxDataViewTreeNodes nodes = node->GetNodes();
1505 wxDataViewTreeLeaves leaves = node->GetChildren();
1506
1507 int len_nodes = nodes.GetCount();
1508 int len = leaves.GetCount();
1509 int i = 0, nodes_i = 0;
1510
1511 for(; i < len; i ++ )
1512 {
1513 void * n = leaves[i];
1514 if( nodes_i < len_nodes && n == nodes[nodes_i]->GetItem().GetID() )
1515 {
1516 wxDataViewTreeNode * nd = nodes[nodes_i];
1517 nodes_i++;
1518
1519 if( Walker( nd , func ) )
1520 return true;
1521
1522 }
1523 else
1524 switch( func( n ) )
1525 {
1526 case DoJob::OK :
1527 return true;
1528 case DoJob::IGR:
1529 continue;
1530 case DoJob::CONT:
1531 default:
1532 ;
1533 }
1534 }
1535 return false;
1536 }
1537
1538 bool wxDataViewMainWindow::ItemAdded(const wxDataViewItem & parent, const wxDataViewItem & item)
1539 {
1540 if (!m_root)
1541 {
1542 m_count++;
1543 UpdateDisplay();
1544 return true;
1545 }
1546
1547 SortPrepare();
1548
1549 wxDataViewTreeNode * node;
1550 node = FindNode(parent);
1551
1552 if( node == NULL )
1553 return false;
1554
1555 node->SetHasChildren( true );
1556
1557 if( g_model->IsContainer( item ) )
1558 {
1559 wxDataViewTreeNode * newnode = new wxDataViewTreeNode( node );
1560 newnode->SetItem(item);
1561 newnode->SetHasChildren( true );
1562 node->AddNode( newnode);
1563 }
1564 else
1565 node->AddLeaf( item.GetID() );
1566
1567 node->ChangeSubTreeCount(1);
1568
1569 m_count = -1;
1570 UpdateDisplay();
1571
1572 return true;
1573 }
1574
1575 static void DestroyTreeHelper( wxDataViewTreeNode * node);
1576
1577 bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem& parent,
1578 const wxDataViewItem& item)
1579 {
1580 if (!m_root)
1581 {
1582 m_count--;
1583 if( m_currentRow > GetRowCount() )
1584 m_currentRow = m_count - 1;
1585
1586 m_selection.Empty();
1587
1588 UpdateDisplay();
1589
1590 return true;
1591 }
1592
1593 wxDataViewTreeNode * node = FindNode(parent);
1594
1595 wxCHECK_MSG( node != NULL, false, "item not found" );
1596 wxCHECK_MSG( node->GetChildren().Index( item.GetID() ) != wxNOT_FOUND, false, "item not found" );
1597
1598 int sub = -1;
1599 node->GetChildren().Remove( item.GetID() );
1600 //Manuplate selection
1601 if( m_selection.GetCount() > 1 )
1602 {
1603 m_selection.Empty();
1604 }
1605 bool isContainer = false;
1606 wxDataViewTreeNodes nds = node->GetNodes();
1607 for (size_t i = 0; i < nds.GetCount(); i ++)
1608 {
1609 if (nds[i]->GetItem() == item)
1610 {
1611 isContainer = true;
1612 break;
1613 }
1614 }
1615 if( isContainer )
1616 {
1617 wxDataViewTreeNode * n = NULL;
1618 wxDataViewTreeNodes nodes = node->GetNodes();
1619 int len = nodes.GetCount();
1620 for( int i = 0; i < len; i ++)
1621 {
1622 if( nodes[i]->GetItem() == item )
1623 {
1624 n = nodes[i];
1625 break;
1626 }
1627 }
1628
1629 wxCHECK_MSG( n != NULL, false, "item not found" );
1630
1631 node->GetNodes().Remove( n );
1632 sub -= n->GetSubTreeCount();
1633 ::DestroyTreeHelper(n);
1634 }
1635 //Make the row number invalid and get a new valid one when user call GetRowCount
1636 m_count = -1;
1637 node->ChangeSubTreeCount(sub);
1638
1639 //Change the current row to the last row if the current exceed the max row number
1640 if( m_currentRow > GetRowCount() )
1641 m_currentRow = m_count - 1;
1642
1643 UpdateDisplay();
1644
1645 return true;
1646 }
1647
1648 bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem & item)
1649 {
1650 SortPrepare();
1651 g_model->Resort();
1652
1653 //Send event
1654 wxWindow *parent = GetParent();
1655 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId());
1656 le.SetEventObject(parent);
1657 le.SetModel(GetOwner()->GetModel());
1658 le.SetItem(item);
1659 parent->GetEventHandler()->ProcessEvent(le);
1660
1661 return true;
1662 }
1663
1664 bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem & item, unsigned int col )
1665 {
1666 // NOTE: to be valid, we cannot use e.g. INT_MAX - 1
1667 /*#define MAX_VIRTUAL_WIDTH 100000
1668
1669 wxRect rect( 0, row*m_lineHeight, MAX_VIRTUAL_WIDTH, m_lineHeight );
1670 m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
1671 Refresh( true, &rect );
1672
1673 return true;
1674 */
1675 SortPrepare();
1676 g_model->Resort();
1677
1678 //Send event
1679 wxWindow *parent = GetParent();
1680 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, parent->GetId());
1681 le.SetEventObject(parent);
1682 le.SetModel(GetOwner()->GetModel());
1683 le.SetItem(item);
1684 le.SetColumn(col);
1685 le.SetDataViewColumn(GetOwner()->GetColumn(col));
1686 parent->GetEventHandler()->ProcessEvent(le);
1687
1688 return true;
1689 }
1690
1691 bool wxDataViewMainWindow::Cleared()
1692 {
1693 DestroyTree();
1694
1695 SortPrepare();
1696 BuildTree( GetOwner()->GetModel() );
1697
1698 UpdateDisplay();
1699
1700 return true;
1701 }
1702
1703 void wxDataViewMainWindow::UpdateDisplay()
1704 {
1705 m_dirty = true;
1706 }
1707
1708 void wxDataViewMainWindow::OnInternalIdle()
1709 {
1710 wxWindow::OnInternalIdle();
1711
1712 if (m_dirty)
1713 {
1714 RecalculateDisplay();
1715 m_dirty = false;
1716 }
1717 }
1718
1719 void wxDataViewMainWindow::RecalculateDisplay()
1720 {
1721 wxDataViewModel *model = GetOwner()->GetModel();
1722 if (!model)
1723 {
1724 Refresh();
1725 return;
1726 }
1727
1728 int width = GetEndOfLastCol();
1729 int height = GetLineStart( GetRowCount() );
1730
1731 SetVirtualSize( width, height );
1732 GetOwner()->SetScrollRate( 10, m_lineHeight );
1733
1734 Refresh();
1735 }
1736
1737 void wxDataViewMainWindow::ScrollWindow( int dx, int dy, const wxRect *rect )
1738 {
1739 wxWindow::ScrollWindow( dx, dy, rect );
1740
1741 if (GetOwner()->m_headerArea)
1742 GetOwner()->m_headerArea->ScrollWindow( dx, 0 );
1743 }
1744
1745 void wxDataViewMainWindow::ScrollTo( int rows, int column )
1746 {
1747 int x, y;
1748 m_owner->GetScrollPixelsPerUnit( &x, &y );
1749 int sy = GetLineStart( rows )/y;
1750 int sx = 0;
1751 if( column != -1 )
1752 {
1753 wxRect rect = GetClientRect();
1754 int colnum = 0;
1755 int x_start, w = 0;
1756 int xx, yy, xe;
1757 m_owner->CalcUnscrolledPosition( rect.x, rect.y, &xx, &yy );
1758 for (x_start = 0; colnum < column; colnum++)
1759 {
1760 wxDataViewColumn *col = GetOwner()->GetColumn(colnum);
1761 if (col->IsHidden())
1762 continue; // skip it!
1763
1764 w = col->GetWidth();
1765 x_start += w;
1766 }
1767
1768 int x_end = x_start + w;
1769 xe = xx + rect.width;
1770 if( x_end > xe )
1771 {
1772 sx = ( xx + x_end - xe )/x;
1773 }
1774 if( x_start < xx )
1775 {
1776 sx = x_start/x;
1777 }
1778 }
1779 m_owner->Scroll( sx, sy );
1780 }
1781
1782 int wxDataViewMainWindow::GetCountPerPage() const
1783 {
1784 wxSize size = GetClientSize();
1785 return size.y / m_lineHeight;
1786 }
1787
1788 int wxDataViewMainWindow::GetEndOfLastCol() const
1789 {
1790 int width = 0;
1791 unsigned int i;
1792 for (i = 0; i < GetOwner()->GetColumnCount(); i++)
1793 {
1794 const wxDataViewColumn *c =
1795 const_cast<wxDataViewCtrl*>(GetOwner())->GetColumn( i );
1796
1797 if (!c->IsHidden())
1798 width += c->GetWidth();
1799 }
1800 return width;
1801 }
1802
1803 unsigned int wxDataViewMainWindow::GetFirstVisibleRow() const
1804 {
1805 int x = 0;
1806 int y = 0;
1807 m_owner->CalcUnscrolledPosition( x, y, &x, &y );
1808
1809 return GetLineAt( y );
1810 }
1811
1812 unsigned int wxDataViewMainWindow::GetLastVisibleRow()
1813 {
1814 wxSize client_size = GetClientSize();
1815 m_owner->CalcUnscrolledPosition( client_size.x, client_size.y,
1816 &client_size.x, &client_size.y );
1817
1818 //we should deal with the pixel here
1819 unsigned int row = GetLineAt(client_size.y) - 1;
1820
1821 return wxMin( GetRowCount()-1, row );
1822 }
1823
1824 unsigned int wxDataViewMainWindow::GetRowCount()
1825 {
1826 if ( m_count == -1 )
1827 {
1828 m_count = RecalculateCount();
1829 UpdateDisplay();
1830 }
1831 return m_count;
1832 }
1833
1834 void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row )
1835 {
1836 m_currentRow = row;
1837
1838 // send event
1839 }
1840
1841 void wxDataViewMainWindow::SelectAllRows( bool on )
1842 {
1843 if (IsEmpty())
1844 return;
1845
1846 if (on)
1847 {
1848 m_selection.Clear();
1849 for (unsigned int i = 0; i < GetRowCount(); i++)
1850 m_selection.Add( i );
1851 Refresh();
1852 }
1853 else
1854 {
1855 unsigned int first_visible = GetFirstVisibleRow();
1856 unsigned int last_visible = GetLastVisibleRow();
1857 unsigned int i;
1858 for (i = 0; i < m_selection.GetCount(); i++)
1859 {
1860 unsigned int row = m_selection[i];
1861 if ((row >= first_visible) && (row <= last_visible))
1862 RefreshRow( row );
1863 }
1864 m_selection.Clear();
1865 }
1866 }
1867
1868 void wxDataViewMainWindow::SelectRow( unsigned int row, bool on )
1869 {
1870 if (m_selection.Index( row ) == wxNOT_FOUND)
1871 {
1872 if (on)
1873 {
1874 m_selection.Add( row );
1875 RefreshRow( row );
1876 }
1877 }
1878 else
1879 {
1880 if (!on)
1881 {
1882 m_selection.Remove( row );
1883 RefreshRow( row );
1884 }
1885 }
1886 }
1887
1888 void wxDataViewMainWindow::SelectRows( unsigned int from, unsigned int to, bool on )
1889 {
1890 if (from > to)
1891 {
1892 unsigned int tmp = from;
1893 from = to;
1894 to = tmp;
1895 }
1896
1897 unsigned int i;
1898 for (i = from; i <= to; i++)
1899 {
1900 if (m_selection.Index( i ) == wxNOT_FOUND)
1901 {
1902 if (on)
1903 m_selection.Add( i );
1904 }
1905 else
1906 {
1907 if (!on)
1908 m_selection.Remove( i );
1909 }
1910 }
1911 RefreshRows( from, to );
1912 }
1913
1914 void wxDataViewMainWindow::Select( const wxArrayInt& aSelections )
1915 {
1916 for (size_t i=0; i < aSelections.GetCount(); i++)
1917 {
1918 int n = aSelections[i];
1919
1920 m_selection.Add( n );
1921 RefreshRow( n );
1922 }
1923 }
1924
1925 void wxDataViewMainWindow::ReverseRowSelection( unsigned int row )
1926 {
1927 if (m_selection.Index( row ) == wxNOT_FOUND)
1928 m_selection.Add( row );
1929 else
1930 m_selection.Remove( row );
1931 RefreshRow( row );
1932 }
1933
1934 bool wxDataViewMainWindow::IsRowSelected( unsigned int row )
1935 {
1936 return (m_selection.Index( row ) != wxNOT_FOUND);
1937 }
1938
1939 void wxDataViewMainWindow::SendSelectionChangedEvent( const wxDataViewItem& item)
1940 {
1941 wxWindow *parent = GetParent();
1942 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, parent->GetId());
1943
1944 le.SetEventObject(parent);
1945 le.SetModel(GetOwner()->GetModel());
1946 le.SetItem( item );
1947
1948 parent->GetEventHandler()->ProcessEvent(le);
1949 }
1950
1951 void wxDataViewMainWindow::RefreshRow( unsigned int row )
1952 {
1953 wxRect rect( 0, GetLineStart( row ), GetEndOfLastCol(), GetLineHeight( row ) );
1954 m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
1955
1956 wxSize client_size = GetClientSize();
1957 wxRect client_rect( 0, 0, client_size.x, client_size.y );
1958 wxRect intersect_rect = client_rect.Intersect( rect );
1959 if (intersect_rect.width > 0)
1960 Refresh( true, &intersect_rect );
1961 }
1962
1963 void wxDataViewMainWindow::RefreshRows( unsigned int from, unsigned int to )
1964 {
1965 if (from > to)
1966 {
1967 unsigned int tmp = to;
1968 to = from;
1969 from = tmp;
1970 }
1971
1972 wxRect rect( 0, GetLineStart( from ), GetEndOfLastCol(), GetLineStart( (to-from+1) ) );
1973 m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
1974
1975 wxSize client_size = GetClientSize();
1976 wxRect client_rect( 0, 0, client_size.x, client_size.y );
1977 wxRect intersect_rect = client_rect.Intersect( rect );
1978 if (intersect_rect.width > 0)
1979 Refresh( true, &intersect_rect );
1980 }
1981
1982 void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow )
1983 {
1984 wxSize client_size = GetClientSize();
1985 int start = GetLineStart( firstRow );
1986 m_owner->CalcScrolledPosition( start, 0, &start, NULL );
1987 if (start > client_size.y) return;
1988
1989 wxRect rect( 0, start, client_size.x, client_size.y - start );
1990
1991 Refresh( true, &rect );
1992 }
1993
1994 void wxDataViewMainWindow::OnArrowChar(unsigned int newCurrent, const wxKeyEvent& event)
1995 {
1996 wxCHECK_RET( newCurrent < GetRowCount(),
1997 _T("invalid item index in OnArrowChar()") );
1998
1999 // if there is no selection, we cannot move it anywhere
2000 if (!HasCurrentRow())
2001 return;
2002
2003 unsigned int oldCurrent = m_currentRow;
2004
2005 // in single selection we just ignore Shift as we can't select several
2006 // items anyhow
2007 if ( event.ShiftDown() && !IsSingleSel() )
2008 {
2009 RefreshRow( oldCurrent );
2010
2011 ChangeCurrentRow( newCurrent );
2012
2013 // select all the items between the old and the new one
2014 if ( oldCurrent > newCurrent )
2015 {
2016 newCurrent = oldCurrent;
2017 oldCurrent = m_currentRow;
2018 }
2019
2020 SelectRows( oldCurrent, newCurrent, true );
2021 if (oldCurrent!=newCurrent)
2022 SendSelectionChangedEvent(GetItemByRow(m_selection[0]));
2023 }
2024 else // !shift
2025 {
2026 RefreshRow( oldCurrent );
2027
2028 // all previously selected items are unselected unless ctrl is held
2029 if ( !event.ControlDown() )
2030 SelectAllRows(false);
2031
2032 ChangeCurrentRow( newCurrent );
2033
2034 if ( !event.ControlDown() )
2035 {
2036 SelectRow( m_currentRow, true );
2037 SendSelectionChangedEvent(GetItemByRow(m_currentRow));
2038 }
2039 else
2040 RefreshRow( m_currentRow );
2041 }
2042
2043 GetOwner()->EnsureVisible( m_currentRow, -1 );
2044 }
2045
2046 wxRect wxDataViewMainWindow::GetLineRect( unsigned int row ) const
2047 {
2048 wxRect rect;
2049 rect.x = 0;
2050 rect.y = GetLineStart( row );
2051 rect.width = GetEndOfLastCol();
2052 rect.height = GetLineHeight( row );
2053
2054 return rect;
2055 }
2056
2057 int wxDataViewMainWindow::GetLineStart( unsigned int row ) const
2058 {
2059 const wxDataViewModel *model = GetOwner()->GetModel();
2060
2061 if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
2062 {
2063 // TODO make more efficient
2064
2065 int start = 0;
2066
2067 unsigned int r;
2068 for (r = 0; r < row; r++)
2069 {
2070 const wxDataViewTreeNode* node = GetTreeNodeByRow(r);
2071 if (!node) return start;
2072
2073 wxDataViewItem item = node->GetItem();
2074
2075 if (node && !node->HasChildren())
2076 {
2077 // Yes, if the node does not have any child, it must be a leaf which
2078 // mean that it is a temporarily created by GetTreeNodeByRow
2079 wxDELETE(node);
2080 }
2081
2082 unsigned int cols = GetOwner()->GetColumnCount();
2083 unsigned int col;
2084 int height = m_lineHeight;
2085 for (col = 0; col < cols; col++)
2086 {
2087 const wxDataViewColumn *column = GetOwner()->GetColumn(col);
2088 if (column->IsHidden())
2089 continue; // skip it!
2090
2091 if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
2092 continue; // skip it!
2093
2094 const wxDataViewRenderer *renderer = column->GetRenderer();
2095 wxVariant value;
2096 model->GetValue( value, item, column->GetModelColumn() );
2097 wxDataViewRenderer *renderer2 = const_cast<wxDataViewRenderer*>(renderer);
2098 renderer2->SetValue( value );
2099 height = wxMax( height, renderer->GetSize().y );
2100 }
2101
2102
2103 start += height;
2104 }
2105
2106 return start;
2107 }
2108 else
2109 {
2110 return row * m_lineHeight;
2111 }
2112 }
2113
2114 int wxDataViewMainWindow::GetLineAt( unsigned int y ) const
2115 {
2116 const wxDataViewModel *model = GetOwner()->GetModel();
2117
2118 // check for the easy case first
2119 if ( !GetOwner()->HasFlag(wxDV_VARIABLE_LINE_HEIGHT) )
2120 return y / m_lineHeight;
2121
2122 // TODO make more efficient
2123 unsigned int row = 0;
2124 unsigned int yy = 0;
2125 for (;;)
2126 {
2127 const wxDataViewTreeNode* node = GetTreeNodeByRow(row);
2128 if (!node)
2129 {
2130 // not really correct...
2131 return row + ((y-yy) / m_lineHeight);
2132 }
2133
2134 wxDataViewItem item = node->GetItem();
2135
2136 if (node && !node->HasChildren())
2137 {
2138 // Yes, if the node does not have any child, it must be a leaf which
2139 // mean that it is a temporarily created by GetTreeNodeByRow
2140 wxDELETE(node);
2141 }
2142
2143 unsigned int cols = GetOwner()->GetColumnCount();
2144 unsigned int col;
2145 int height = m_lineHeight;
2146 for (col = 0; col < cols; col++)
2147 {
2148 const wxDataViewColumn *column = GetOwner()->GetColumn(col);
2149 if (column->IsHidden())
2150 continue; // skip it!
2151
2152 if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
2153 continue; // skip it!
2154
2155 const wxDataViewRenderer *renderer = column->GetRenderer();
2156 wxVariant value;
2157 model->GetValue( value, item, column->GetModelColumn() );
2158 wxDataViewRenderer *renderer2 = const_cast<wxDataViewRenderer*>(renderer);
2159 renderer2->SetValue( value );
2160 height = wxMax( height, renderer->GetSize().y );
2161 }
2162
2163 yy += height;
2164 if (y < yy)
2165 return row;
2166
2167 row++;
2168 }
2169 }
2170
2171 int wxDataViewMainWindow::GetLineHeight( unsigned int row ) const
2172 {
2173 const wxDataViewModel *model = GetOwner()->GetModel();
2174
2175 if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
2176 {
2177 wxASSERT( !IsVirtualList() );
2178
2179 const wxDataViewTreeNode* node = GetTreeNodeByRow(row);
2180 // wxASSERT( node );
2181 if (!node) return m_lineHeight;
2182
2183 wxDataViewItem item = node->GetItem();
2184
2185 if (node && !node->HasChildren())
2186 {
2187 // Yes, if the node does not have any child, it must be a leaf which
2188 // mean that it is a temporarily created by GetTreeNodeByRow
2189 wxDELETE(node);
2190 }
2191
2192 int height = m_lineHeight;
2193
2194 unsigned int cols = GetOwner()->GetColumnCount();
2195 unsigned int col;
2196 for (col = 0; col < cols; col++)
2197 {
2198 const wxDataViewColumn *column = GetOwner()->GetColumn(col);
2199 if (column->IsHidden())
2200 continue; // skip it!
2201
2202 if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
2203 continue; // skip it!
2204
2205 const wxDataViewRenderer *renderer = column->GetRenderer();
2206 wxVariant value;
2207 model->GetValue( value, item, column->GetModelColumn() );
2208 wxDataViewRenderer *renderer2 = const_cast<wxDataViewRenderer*>(renderer);
2209 renderer2->SetValue( value );
2210 height = wxMax( height, renderer->GetSize().y );
2211 }
2212
2213 return height;
2214 }
2215 else
2216 {
2217 return m_lineHeight;
2218 }
2219 }
2220
2221 class RowToItemJob: public DoJob
2222 {
2223 public:
2224 RowToItemJob( unsigned int row , int current ) { this->row = row; this->current = current;}
2225 virtual ~RowToItemJob() { }
2226
2227 virtual int operator() ( wxDataViewTreeNode * node )
2228 {
2229 current ++;
2230 if( current == static_cast<int>(row))
2231 {
2232 ret = node->GetItem();
2233 return DoJob::OK;
2234 }
2235
2236 if( node->GetSubTreeCount() + current < static_cast<int>(row) )
2237 {
2238 current += node->GetSubTreeCount();
2239 return DoJob::IGR;
2240 }
2241 else
2242 {
2243 //If the current has no child node, we can find the desired item of the row number directly.
2244 //This if can speed up finding in some case, and will has a very good effect when it comes to list view
2245 if( node->GetNodes().GetCount() == 0)
2246 {
2247 int index = static_cast<int>(row) - current - 1;
2248 ret = node->GetChildren().Item( index );
2249 return DoJob::OK;
2250 }
2251 return DoJob::CONT;
2252 }
2253 }
2254
2255 virtual int operator() ( void * n )
2256 {
2257 current ++;
2258 if( current == static_cast<int>(row))
2259 {
2260 ret = wxDataViewItem( n );
2261 return DoJob::OK;
2262 }
2263 return DoJob::CONT;
2264 }
2265 wxDataViewItem GetResult(){ return ret; }
2266 private:
2267 unsigned int row;
2268 int current;
2269 wxDataViewItem ret;
2270 };
2271
2272 wxDataViewItem wxDataViewMainWindow::GetItemByRow(unsigned int row) const
2273 {
2274 if (!m_root)
2275 {
2276 return wxDataViewItem( wxUIntToPtr(row) );
2277 }
2278 else
2279 {
2280 RowToItemJob job( row, -2 );
2281 Walker( m_root , job );
2282 return job.GetResult();
2283 }
2284 }
2285
2286 class RowToTreeNodeJob: public DoJob
2287 {
2288 public:
2289 RowToTreeNodeJob( unsigned int row , int current, wxDataViewTreeNode * node )
2290 {
2291 this->row = row;
2292 this->current = current;
2293 ret = NULL;
2294 parent = node;
2295 }
2296 virtual ~RowToTreeNodeJob(){ }
2297
2298 virtual int operator() ( wxDataViewTreeNode * node )
2299 {
2300 current ++;
2301 if( current == static_cast<int>(row))
2302 {
2303 ret = node;
2304 return DoJob::OK;
2305 }
2306
2307 if( node->GetSubTreeCount() + current < static_cast<int>(row) )
2308 {
2309 current += node->GetSubTreeCount();
2310 return DoJob::IGR;
2311 }
2312 else
2313 {
2314 parent = node;
2315 //If the current has no child node, we can find the desired item of the row number directly.
2316 //This if can speed up finding in some case, and will has a very good effect when it comes to list view
2317 if( node->GetNodes().GetCount() == 0)
2318 {
2319 int index = static_cast<int>(row) - current - 1;
2320 void * n = node->GetChildren().Item( index );
2321 ret = new wxDataViewTreeNode( parent );
2322 ret->SetItem( wxDataViewItem( n ));
2323 ret->SetHasChildren(false);
2324 return DoJob::OK;
2325 }
2326 return DoJob::CONT;
2327 }
2328
2329
2330 }
2331
2332 virtual int operator() ( void * n )
2333 {
2334 current ++;
2335 if( current == static_cast<int>(row))
2336 {
2337 ret = new wxDataViewTreeNode( parent );
2338 ret->SetItem( wxDataViewItem( n ));
2339 ret->SetHasChildren(false);
2340 return DoJob::OK;
2341 }
2342
2343 return DoJob::CONT;
2344 }
2345 wxDataViewTreeNode * GetResult(){ return ret; }
2346 private:
2347 unsigned int row;
2348 int current;
2349 wxDataViewTreeNode * ret;
2350 wxDataViewTreeNode * parent;
2351 };
2352
2353
2354 wxDataViewTreeNode * wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row) const
2355 {
2356 wxASSERT( !IsVirtualList() );
2357
2358 RowToTreeNodeJob job( row , -2, m_root );
2359 Walker( m_root , job );
2360 return job.GetResult();
2361 }
2362
2363 wxDataViewEvent wxDataViewMainWindow::SendExpanderEvent( wxEventType type, const wxDataViewItem & item )
2364 {
2365 wxWindow *parent = GetParent();
2366 wxDataViewEvent le(type, parent->GetId());
2367
2368 le.SetEventObject(parent);
2369 le.SetModel(GetOwner()->GetModel());
2370 le.SetItem( item );
2371
2372 parent->GetEventHandler()->ProcessEvent(le);
2373 return le;
2374 }
2375
2376 void wxDataViewMainWindow::OnExpanding( unsigned int row )
2377 {
2378 if (IsVirtualList())
2379 return;
2380
2381 wxDataViewTreeNode * node = GetTreeNodeByRow(row);
2382 if( node != NULL )
2383 {
2384 if( node->HasChildren())
2385 {
2386 if( !node->IsOpen())
2387 {
2388 wxDataViewEvent e = SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING,node->GetItem());
2389 //Check if the user prevent expanding
2390 if( e.GetSkipped() )
2391 return;
2392
2393 node->ToggleOpen();
2394 //Here I build the children of current node
2395 if( node->GetChildrenNumber() == 0 )
2396 {
2397 SortPrepare();
2398 ::BuildTreeHelper(GetOwner()->GetModel(), node->GetItem(), node);
2399 }
2400 m_count = -1;
2401 UpdateDisplay();
2402 //Send the expanded event
2403 SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,node->GetItem());
2404 }
2405 else
2406 {
2407 SelectRow( row, false );
2408 SelectRow( row + 1, true );
2409 ChangeCurrentRow( row + 1 );
2410 SendSelectionChangedEvent( GetItemByRow(row+1));
2411 }
2412 }
2413 else
2414 delete node;
2415 }
2416 }
2417
2418 void wxDataViewMainWindow::OnCollapsing(unsigned int row)
2419 {
2420 if (IsVirtualList())
2421 return;
2422
2423 wxDataViewTreeNode * node = GetTreeNodeByRow(row);
2424 if( node != NULL )
2425 {
2426 wxDataViewTreeNode * nd = node;
2427
2428 if( node->HasChildren() && node->IsOpen() )
2429 {
2430 wxDataViewEvent e = SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,node->GetItem());
2431 if( e.GetSkipped() )
2432 return;
2433 node->ToggleOpen();
2434 m_count = -1;
2435 UpdateDisplay();
2436 SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,nd->GetItem());
2437 }
2438 else
2439 {
2440 node = node->GetParent();
2441 if( node != NULL )
2442 {
2443 int parent = GetRowByItem( node->GetItem() );
2444 if( parent >= 0 )
2445 {
2446 SelectRow( row, false);
2447 SelectRow(parent , true );
2448 ChangeCurrentRow( parent );
2449 SendSelectionChangedEvent( node->GetItem() );
2450 }
2451 }
2452 }
2453 if( !nd->HasChildren())
2454 delete nd;
2455 }
2456 }
2457
2458 wxDataViewTreeNode * wxDataViewMainWindow::FindNode( const wxDataViewItem & item )
2459 {
2460 wxDataViewModel * model = GetOwner()->GetModel();
2461 if( model == NULL )
2462 return NULL;
2463
2464 //Compose the a parent-chain of the finding item
2465 ItemList list;
2466 list.DeleteContents( true );
2467 wxDataViewItem it( item );
2468 while( it.IsOk() )
2469 {
2470 wxDataViewItem * pItem = new wxDataViewItem( it );
2471 list.Insert( pItem );
2472 it = model->GetParent( it );
2473 }
2474
2475 //Find the item along the parent-chain.
2476 //This algorithm is designed to speed up the node-finding method
2477 wxDataViewTreeNode * node = m_root;
2478 for( ItemList::const_iterator iter = list.begin(); iter !=list.end(); iter++ )
2479 {
2480 if( node->HasChildren() )
2481 {
2482 if( node->GetChildrenNumber() == 0 )
2483 {
2484 SortPrepare();
2485 ::BuildTreeHelper(model, node->GetItem(), node);
2486 }
2487
2488 wxDataViewTreeNodes nodes = node->GetNodes();
2489 unsigned int i;
2490 bool found = false;
2491
2492 for (i = 0; i < nodes.GetCount(); i ++)
2493 {
2494 if (nodes[i]->GetItem() == (**iter))
2495 {
2496 if (nodes[i]->GetItem() == item)
2497 return nodes[i];
2498
2499 node = nodes[i];
2500 found = true;
2501 break;
2502 }
2503 }
2504 if (!found)
2505 return NULL;
2506 }
2507 else
2508 return NULL;
2509 }
2510 return NULL;
2511 }
2512
2513 void wxDataViewMainWindow::HitTest( const wxPoint & point, wxDataViewItem & item, wxDataViewColumn* &column )
2514 {
2515 wxDataViewColumn *col = NULL;
2516 unsigned int cols = GetOwner()->GetColumnCount();
2517 unsigned int colnum = 0;
2518 int x, y;
2519 m_owner->CalcUnscrolledPosition( point.x, point.y, &x, &y );
2520 for (unsigned x_start = 0; colnum < cols; colnum++)
2521 {
2522 col = GetOwner()->GetColumn(colnum);
2523 if (col->IsHidden())
2524 continue; // skip it!
2525
2526 unsigned int w = col->GetWidth();
2527 if (x_start+w >= (unsigned int)x)
2528 break;
2529
2530 x_start += w;
2531 }
2532
2533 column = col;
2534 item = GetItemByRow( GetLineAt( y ) );
2535 }
2536
2537 wxRect wxDataViewMainWindow::GetItemRect( const wxDataViewItem & item, const wxDataViewColumn* column )
2538 {
2539 int row = GetRowByItem(item);
2540 int y = GetLineStart( row );
2541 int h = GetLineHeight( m_lineHeight );
2542 int x = 0;
2543 wxDataViewColumn *col = NULL;
2544 for( int i = 0, cols = GetOwner()->GetColumnCount(); i < cols; i ++ )
2545 {
2546 col = GetOwner()->GetColumn( i );
2547 x += col->GetWidth();
2548 if( GetOwner()->GetColumn(i+1) == column )
2549 break;
2550 }
2551 int w = col->GetWidth();
2552 m_owner->CalcScrolledPosition( x, y, &x, &y );
2553 return wxRect(x, y, w, h);
2554 }
2555
2556 int wxDataViewMainWindow::RecalculateCount()
2557 {
2558 if (!m_root)
2559 {
2560 wxDataViewIndexListModel *list_model = (wxDataViewIndexListModel*) GetOwner()->GetModel();
2561 #ifndef __WXMAC__
2562 return list_model->GetLastIndex() + 1;
2563 #else
2564 return list_model->GetLastIndex() - 1;
2565 #endif
2566 }
2567 else
2568 {
2569 return m_root->GetSubTreeCount();
2570 }
2571 }
2572
2573 class ItemToRowJob : public DoJob
2574 {
2575 public:
2576 ItemToRowJob(const wxDataViewItem& item_, ItemList::const_iterator iter)
2577 : m_iter(iter),
2578 item(item_)
2579 {
2580 ret = -1;
2581 }
2582
2583 //Maybe binary search will help to speed up this process
2584 virtual int operator() ( wxDataViewTreeNode * node)
2585 {
2586 ret ++;
2587 if( node->GetItem() == item )
2588 {
2589 return DoJob::OK;
2590 }
2591
2592 if( node->GetItem() == **m_iter )
2593 {
2594 m_iter++;
2595 return DoJob::CONT;
2596 }
2597 else
2598 {
2599 ret += node->GetSubTreeCount();
2600 return DoJob::IGR;
2601 }
2602
2603 }
2604
2605 virtual int operator() ( void * n )
2606 {
2607 ret ++;
2608 if( n == item.GetID() )
2609 return DoJob::OK;
2610 return DoJob::CONT;
2611 }
2612 //the row number is begin from zero
2613 int GetResult() { return ret -1; }
2614
2615 private:
2616 ItemList::const_iterator m_iter;
2617 wxDataViewItem item;
2618 int ret;
2619
2620 };
2621
2622 int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem & item) const
2623 {
2624 const wxDataViewModel * model = GetOwner()->GetModel();
2625 if( model == NULL )
2626 return -1;
2627
2628 if (!m_root)
2629 {
2630 return wxPtrToUInt( item.GetID() );
2631 }
2632 else
2633 {
2634 if( !item.IsOk() )
2635 return -1;
2636
2637 //Compose the a parent-chain of the finding item
2638 ItemList list;
2639 wxDataViewItem * pItem;
2640 list.DeleteContents( true );
2641 wxDataViewItem it( item );
2642 while( it.IsOk() )
2643 {
2644 pItem = new wxDataViewItem( it );
2645 list.Insert( pItem );
2646 it = model->GetParent( it );
2647 }
2648 pItem = new wxDataViewItem( );
2649 list.Insert( pItem );
2650
2651 ItemToRowJob job( item, list.begin() );
2652 Walker(m_root , job );
2653 return job.GetResult();
2654 }
2655 }
2656
2657 static void BuildTreeHelper( wxDataViewModel * model, wxDataViewItem & item, wxDataViewTreeNode * node)
2658 {
2659 if( !model->IsContainer( item ) )
2660 return;
2661
2662 wxDataViewItemArray children;
2663 unsigned int num = model->GetChildren( item, children);
2664 unsigned int index = 0;
2665 while( index < num )
2666 {
2667 if( model->IsContainer( children[index] ) )
2668 {
2669 wxDataViewTreeNode * n = new wxDataViewTreeNode( node );
2670 n->SetItem(children[index]);
2671 n->SetHasChildren( true );
2672 node->AddNode( n );
2673 }
2674 else
2675 {
2676 node->AddLeaf( children[index].GetID() );
2677 }
2678 index ++;
2679 }
2680 node->SetSubTreeCount( num );
2681 wxDataViewTreeNode * n = node->GetParent();
2682 if( n != NULL)
2683 n->ChangeSubTreeCount(num);
2684
2685 }
2686
2687 void wxDataViewMainWindow::BuildTree(wxDataViewModel * model)
2688 {
2689 DestroyTree();
2690
2691 if (GetOwner()->GetModel()->IsVirtualListModel())
2692 {
2693 m_count = -1;
2694 return;
2695 }
2696
2697 m_root = new wxDataViewTreeNode( NULL );
2698 m_root->SetHasChildren(true);
2699
2700 //First we define a invalid item to fetch the top-level elements
2701 wxDataViewItem item;
2702 SortPrepare();
2703 BuildTreeHelper( model, item, m_root);
2704 m_count = -1;
2705 }
2706
2707 static void DestroyTreeHelper( wxDataViewTreeNode * node )
2708 {
2709 if( node->GetNodeNumber() != 0 )
2710 {
2711 int len = node->GetNodeNumber();
2712 int i = 0;
2713 wxDataViewTreeNodes& nodes = node->GetNodes();
2714 for(; i < len; i ++ )
2715 {
2716 DestroyTreeHelper(nodes[i]);
2717 }
2718 }
2719 delete node;
2720 }
2721
2722 void wxDataViewMainWindow::DestroyTree()
2723 {
2724 if (!IsVirtualList())
2725 {
2726 ::DestroyTreeHelper(m_root);
2727 m_count = 0;
2728 m_root = NULL;
2729 }
2730 }
2731
2732 void wxDataViewMainWindow::OnChar( wxKeyEvent &event )
2733 {
2734 if ( GetParent()->HandleAsNavigationKey(event) )
2735 return;
2736
2737 // no item -> nothing to do
2738 if (!HasCurrentRow())
2739 {
2740 event.Skip();
2741 return;
2742 }
2743
2744 // don't use m_linesPerPage directly as it might not be computed yet
2745 const int pageSize = GetCountPerPage();
2746 wxCHECK_RET( pageSize, _T("should have non zero page size") );
2747
2748 switch ( event.GetKeyCode() )
2749 {
2750 case WXK_RETURN:
2751 {
2752 if (m_currentRow > 0)
2753 {
2754 wxWindow *parent = GetParent();
2755 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId());
2756 le.SetItem( GetItemByRow(m_currentRow) );
2757 le.SetEventObject(parent);
2758 le.SetModel(GetOwner()->GetModel());
2759
2760 parent->GetEventHandler()->ProcessEvent(le);
2761 }
2762 break;
2763 }
2764 case WXK_UP:
2765 if ( m_currentRow > 0 )
2766 OnArrowChar( m_currentRow - 1, event );
2767 break;
2768
2769 case WXK_DOWN:
2770 if ( m_currentRow < GetRowCount() - 1 )
2771 OnArrowChar( m_currentRow + 1, event );
2772 break;
2773 //Add the process for tree expanding/collapsing
2774 case WXK_LEFT:
2775 OnCollapsing(m_currentRow);
2776 break;
2777 case WXK_RIGHT:
2778 OnExpanding( m_currentRow);
2779 break;
2780 case WXK_END:
2781 if (!IsEmpty())
2782 OnArrowChar( GetRowCount() - 1, event );
2783 break;
2784
2785 case WXK_HOME:
2786 if (!IsEmpty())
2787 OnArrowChar( 0, event );
2788 break;
2789
2790 case WXK_PAGEUP:
2791 {
2792 int steps = pageSize - 1;
2793 int index = m_currentRow - steps;
2794 if (index < 0)
2795 index = 0;
2796
2797 OnArrowChar( index, event );
2798 }
2799 break;
2800
2801 case WXK_PAGEDOWN:
2802 {
2803 int steps = pageSize - 1;
2804 unsigned int index = m_currentRow + steps;
2805 unsigned int count = GetRowCount();
2806 if ( index >= count )
2807 index = count - 1;
2808
2809 OnArrowChar( index, event );
2810 }
2811 break;
2812
2813 default:
2814 event.Skip();
2815 }
2816 }
2817
2818 void wxDataViewMainWindow::OnMouse( wxMouseEvent &event )
2819 {
2820 if (event.GetEventType() == wxEVT_MOUSEWHEEL)
2821 {
2822 // let the base handle mouse wheel events.
2823 event.Skip();
2824 return;
2825 }
2826
2827 int x = event.GetX();
2828 int y = event.GetY();
2829 m_owner->CalcUnscrolledPosition( x, y, &x, &y );
2830 wxDataViewColumn *col = NULL;
2831
2832 int xpos = 0;
2833 unsigned int cols = GetOwner()->GetColumnCount();
2834 unsigned int i;
2835 for (i = 0; i < cols; i++)
2836 {
2837 wxDataViewColumn *c = GetOwner()->GetColumn( i );
2838 if (c->IsHidden())
2839 continue; // skip it!
2840
2841 if (x < xpos + c->GetWidth())
2842 {
2843 col = c;
2844 break;
2845 }
2846 xpos += c->GetWidth();
2847 }
2848 if (!col)
2849 return;
2850
2851 wxDataViewRenderer *cell = col->GetRenderer();
2852 unsigned int current = GetLineAt( y );
2853 if ((current > GetRowCount()) || (x > GetEndOfLastCol()))
2854 {
2855 // Unselect all if below the last row ?
2856 return;
2857 }
2858
2859 //Test whether the mouse is hovered on the tree item button
2860 bool hover = false;
2861 if ((!IsVirtualList()) && (GetOwner()->GetExpanderColumn() == col))
2862 {
2863 wxDataViewTreeNode * node = GetTreeNodeByRow(current);
2864 if( node!=NULL && node->HasChildren() )
2865 {
2866 int indent = node->GetIndentLevel();
2867 indent = GetOwner()->GetIndent()*indent;
2868 wxRect rect( xpos + indent + EXPANDER_MARGIN,
2869 GetLineStart( current ) + EXPANDER_MARGIN + (GetLineHeight(current)/2) - (m_lineHeight/2) - EXPANDER_OFFSET,
2870 m_lineHeight-2*EXPANDER_MARGIN,
2871 m_lineHeight-2*EXPANDER_MARGIN + EXPANDER_OFFSET);
2872 if( rect.Contains( x, y) )
2873 {
2874 //So the mouse is over the expander
2875 hover = true;
2876 if (m_underMouse && m_underMouse != node)
2877 {
2878 //wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
2879 RefreshRow(GetRowByItem(m_underMouse->GetItem()));
2880 }
2881 if (m_underMouse != node)
2882 {
2883 //wxLogMessage("Do the row: %d", current);
2884 RefreshRow(current);
2885 }
2886 m_underMouse = node;
2887 }
2888 }
2889 if (node!=NULL && !node->HasChildren())
2890 delete node;
2891 }
2892 if (!hover)
2893 {
2894 if (m_underMouse != NULL)
2895 {
2896 //wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
2897 RefreshRow(GetRowByItem(m_underMouse->GetItem()));
2898 m_underMouse = NULL;
2899 }
2900 }
2901
2902 wxDataViewModel *model = GetOwner()->GetModel();
2903
2904 if (event.Dragging())
2905 {
2906 if (m_dragCount == 0)
2907 {
2908 // we have to report the raw, physical coords as we want to be
2909 // able to call HitTest(event.m_pointDrag) from the user code to
2910 // get the item being dragged
2911 m_dragStart = event.GetPosition();
2912 }
2913
2914 m_dragCount++;
2915
2916 if (m_dragCount != 3)
2917 return;
2918
2919 if (event.LeftIsDown())
2920 {
2921 // Notify cell about drag
2922 }
2923 return;
2924 }
2925 else
2926 {
2927 m_dragCount = 0;
2928 }
2929
2930 bool forceClick = false;
2931
2932 if (event.ButtonDClick())
2933 {
2934 m_renameTimer->Stop();
2935 m_lastOnSame = false;
2936 }
2937
2938 wxDataViewItem item = GetItemByRow(current);
2939 bool ignore_other_columns =
2940 ((GetOwner()->GetExpanderColumn() != col) &&
2941 (model->IsContainer(item)) &&
2942 (!model->HasContainerColumns(item)));
2943
2944 if (event.LeftDClick())
2945 {
2946 if ( current == m_lineLastClicked )
2947 {
2948 if ((!ignore_other_columns) && (cell->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE))
2949 {
2950 wxVariant value;
2951 model->GetValue( value, item, col->GetModelColumn() );
2952 cell->SetValue( value );
2953 wxRect cell_rect( xpos, GetLineStart( current ),
2954 col->GetWidth(), GetLineHeight( current ) );
2955 cell->Activate( cell_rect, model, item, col->GetModelColumn() );
2956
2957 }
2958 else
2959 {
2960 wxWindow *parent = GetParent();
2961 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED, parent->GetId());
2962 le.SetItem( item );
2963 le.SetEventObject(parent);
2964 le.SetModel(GetOwner()->GetModel());
2965
2966 parent->GetEventHandler()->ProcessEvent(le);
2967 }
2968 return;
2969 }
2970 else
2971 {
2972 // The first click was on another item, so don't interpret this as
2973 // a double click, but as a simple click instead
2974 forceClick = true;
2975 }
2976 }
2977
2978 if (event.LeftUp())
2979 {
2980 if (m_lineSelectSingleOnUp != (unsigned int)-1)
2981 {
2982 // select single line
2983 SelectAllRows( false );
2984 SelectRow( m_lineSelectSingleOnUp, true );
2985 }
2986
2987 //Process the event of user clicking the expander
2988 bool expander = false;
2989 if ((!IsVirtualList()) && (GetOwner()->GetExpanderColumn() == col))
2990 {
2991 wxDataViewTreeNode * node = GetTreeNodeByRow(current);
2992 if( node!=NULL && node->HasChildren() )
2993 {
2994 int indent = node->GetIndentLevel();
2995 indent = GetOwner()->GetIndent()*indent;
2996 wxRect rect( xpos + indent + EXPANDER_MARGIN,
2997 GetLineStart( current ) + EXPANDER_MARGIN + (GetLineHeight(current)/2) - (m_lineHeight/2) - EXPANDER_OFFSET,
2998 m_lineHeight-2*EXPANDER_MARGIN,
2999 m_lineHeight-2*EXPANDER_MARGIN + EXPANDER_OFFSET);
3000
3001 if( rect.Contains( x, y) )
3002 {
3003 expander = true;
3004 if( node->IsOpen() )
3005 OnCollapsing(current);
3006 else
3007 OnExpanding( current );
3008 }
3009 }
3010 if (node && !node->HasChildren())
3011 delete node;
3012 }
3013 //If the user click the expander, we do not do editing even if the column with expander are editable
3014 if (m_lastOnSame && !expander && !ignore_other_columns)
3015 {
3016 if ((col == m_currentCol) && (current == m_currentRow) &&
3017 (cell->GetMode() & wxDATAVIEW_CELL_EDITABLE) )
3018 {
3019 m_renameTimer->Start( 100, true );
3020 }
3021 }
3022
3023 m_lastOnSame = false;
3024 m_lineSelectSingleOnUp = (unsigned int)-1;
3025 }
3026 else
3027 {
3028 // This is necessary, because after a DnD operation in
3029 // from and to ourself, the up event is swallowed by the
3030 // DnD code. So on next non-up event (which means here and
3031 // now) m_lineSelectSingleOnUp should be reset.
3032 m_lineSelectSingleOnUp = (unsigned int)-1;
3033 }
3034
3035 if (event.RightDown())
3036 {
3037 m_lineBeforeLastClicked = m_lineLastClicked;
3038 m_lineLastClicked = current;
3039
3040 // If the item is already selected, do not update the selection.
3041 // Multi-selections should not be cleared if a selected item is clicked.
3042 if (!IsRowSelected(current))
3043 {
3044 SelectAllRows(false);
3045 ChangeCurrentRow(current);
3046 SelectRow(m_currentRow,true);
3047 SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
3048 }
3049
3050 wxVariant value;
3051 model->GetValue( value, item, col->GetModelColumn() );
3052 wxWindow *parent = GetParent();
3053 wxDataViewEvent le(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU, parent->GetId());
3054 le.SetItem( item );
3055 le.SetEventObject(parent);
3056 le.SetModel(GetOwner()->GetModel());
3057 le.SetValue(value);
3058 parent->GetEventHandler()->ProcessEvent(le);
3059 }
3060 else if (event.MiddleDown())
3061 {
3062 }
3063 if (event.LeftDown() || forceClick)
3064 {
3065 SetFocus();
3066
3067 m_lineBeforeLastClicked = m_lineLastClicked;
3068 m_lineLastClicked = current;
3069
3070 unsigned int oldCurrentRow = m_currentRow;
3071 bool oldWasSelected = IsRowSelected(m_currentRow);
3072
3073 bool cmdModifierDown = event.CmdDown();
3074 if ( IsSingleSel() || !(cmdModifierDown || event.ShiftDown()) )
3075 {
3076 if ( IsSingleSel() || !IsRowSelected(current) )
3077 {
3078 SelectAllRows( false );
3079 ChangeCurrentRow(current);
3080 SelectRow(m_currentRow,true);
3081 SendSelectionChangedEvent(GetItemByRow( m_currentRow ) );
3082 }
3083 else // multi sel & current is highlighted & no mod keys
3084 {
3085 m_lineSelectSingleOnUp = current;
3086 ChangeCurrentRow(current); // change focus
3087 }
3088 }
3089 else // multi sel & either ctrl or shift is down
3090 {
3091 if (cmdModifierDown)
3092 {
3093 ChangeCurrentRow(current);
3094 ReverseRowSelection(m_currentRow);
3095 SendSelectionChangedEvent(GetItemByRow(m_selection[0]) );
3096 }
3097 else if (event.ShiftDown())
3098 {
3099 ChangeCurrentRow(current);
3100
3101 unsigned int lineFrom = oldCurrentRow,
3102 lineTo = current;
3103
3104 if ( lineTo < lineFrom )
3105 {
3106 lineTo = lineFrom;
3107 lineFrom = m_currentRow;
3108 }
3109
3110 SelectRows(lineFrom, lineTo, true);
3111 SendSelectionChangedEvent(GetItemByRow(m_selection[0]) );
3112 }
3113 else // !ctrl, !shift
3114 {
3115 // test in the enclosing if should make it impossible
3116 wxFAIL_MSG( _T("how did we get here?") );
3117 }
3118 }
3119
3120 if (m_currentRow != oldCurrentRow)
3121 RefreshRow( oldCurrentRow );
3122
3123 wxDataViewColumn *oldCurrentCol = m_currentCol;
3124
3125 // Update selection here...
3126 m_currentCol = col;
3127
3128 m_lastOnSame = !forceClick && ((col == oldCurrentCol) &&
3129 (current == oldCurrentRow)) && oldWasSelected;
3130
3131 // Call LeftClick after everything else as under GTK+
3132 if (cell->GetMode() & wxDATAVIEW_CELL_ACTIVATABLE)
3133 {
3134 // notify cell about right click
3135 wxVariant value;
3136 model->GetValue( value, item, col->GetModelColumn() );
3137 cell->SetValue( value );
3138 wxRect cell_rect( xpos, GetLineStart( current ),
3139 col->GetWidth(), GetLineHeight( current ) );
3140 /* ignore ret */ cell->LeftClick( event.GetPosition(), cell_rect, model, item, col->GetModelColumn());
3141 }
3142 }
3143 }
3144
3145 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent &event )
3146 {
3147 m_hasFocus = true;
3148
3149 if (HasCurrentRow())
3150 Refresh();
3151
3152 event.Skip();
3153 }
3154
3155 void wxDataViewMainWindow::OnKillFocus( wxFocusEvent &event )
3156 {
3157 m_hasFocus = false;
3158
3159 if (HasCurrentRow())
3160 Refresh();
3161
3162 event.Skip();
3163 }
3164
3165 wxDataViewItem wxDataViewMainWindow::GetSelection() const
3166 {
3167 if( m_selection.GetCount() != 1 )
3168 return wxDataViewItem();
3169
3170 return GetItemByRow( m_selection.Item(0));
3171 }
3172
3173 //-----------------------------------------------------------------------------
3174 // wxDataViewCtrl
3175 //-----------------------------------------------------------------------------
3176 WX_DEFINE_LIST(wxDataViewColumnList)
3177
3178 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
3179
3180 BEGIN_EVENT_TABLE(wxDataViewCtrl, wxDataViewCtrlBase)
3181 EVT_SIZE(wxDataViewCtrl::OnSize)
3182 END_EVENT_TABLE()
3183
3184 wxDataViewCtrl::~wxDataViewCtrl()
3185 {
3186 if (m_notifier)
3187 GetModel()->RemoveNotifier( m_notifier );
3188
3189 m_cols.Clear();
3190 }
3191
3192 void wxDataViewCtrl::Init()
3193 {
3194 m_cols.DeleteContents(true);
3195 m_notifier = NULL;
3196
3197 // No sorting column at start
3198 m_sortingColumn = NULL;
3199 m_headerArea = NULL;
3200 }
3201
3202 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id,
3203 const wxPoint& pos, const wxSize& size,
3204 long style, const wxValidator& validator )
3205 {
3206 if ( (style & wxBORDER_MASK) == 0)
3207 style |= wxBORDER_SUNKEN;
3208
3209 Init();
3210
3211 if (!wxControl::Create( parent, id, pos, size,
3212 style | wxScrolledWindowStyle, validator))
3213 return false;
3214
3215 SetInitialSize(size);
3216
3217 #ifdef __WXMAC__
3218 MacSetClipChildren( true );
3219 #endif
3220
3221 m_clientArea = new wxDataViewMainWindow( this, wxID_ANY );
3222
3223 if (HasFlag(wxDV_NO_HEADER))
3224 m_headerArea = NULL;
3225 else
3226 m_headerArea = new wxDataViewHeaderWindow(this);
3227
3228 SetTargetWindow( m_clientArea );
3229
3230 wxBoxSizer *sizer = new wxBoxSizer( wxVERTICAL );
3231 if (m_headerArea)
3232 sizer->Add( m_headerArea, 0, wxGROW );
3233 sizer->Add( m_clientArea, 1, wxGROW );
3234 SetSizer( sizer );
3235
3236 return true;
3237 }
3238
3239 #ifdef __WXMSW__
3240 WXLRESULT wxDataViewCtrl::MSWWindowProc(WXUINT nMsg,
3241 WXWPARAM wParam,
3242 WXLPARAM lParam)
3243 {
3244 WXLRESULT rc = wxDataViewCtrlBase::MSWWindowProc(nMsg, wParam, lParam);
3245
3246 #ifndef __WXWINCE__
3247 // we need to process arrows ourselves for scrolling
3248 if ( nMsg == WM_GETDLGCODE )
3249 {
3250 rc |= DLGC_WANTARROWS;
3251 }
3252 #endif
3253
3254 return rc;
3255 }
3256 #endif
3257
3258 wxSize wxDataViewCtrl::GetSizeAvailableForScrollTarget(const wxSize& size)
3259 {
3260 wxSize newsize = size;
3261 if (!HasFlag(wxDV_NO_HEADER) && (m_headerArea))
3262 newsize.y -= m_headerArea->GetSize().y;
3263
3264 return newsize;
3265 }
3266
3267 void wxDataViewCtrl::OnSize( wxSizeEvent &WXUNUSED(event) )
3268 {
3269 // We need to override OnSize so that our scrolled
3270 // window a) does call Layout() to use sizers for
3271 // positioning the controls but b) does not query
3272 // the sizer for their size and use that for setting
3273 // the scrollable area as set that ourselves by
3274 // calling SetScrollbar() further down.
3275
3276 Layout();
3277
3278 AdjustScrollbars();
3279 }
3280
3281 void wxDataViewCtrl::SetFocus()
3282 {
3283 if (m_clientArea)
3284 m_clientArea->SetFocus();
3285 }
3286
3287 bool wxDataViewCtrl::AssociateModel( wxDataViewModel *model )
3288 {
3289 if (!wxDataViewCtrlBase::AssociateModel( model ))
3290 return false;
3291
3292 m_notifier = new wxGenericDataViewModelNotifier( m_clientArea );
3293
3294 model->AddNotifier( m_notifier );
3295
3296 m_clientArea->DestroyTree();
3297
3298 m_clientArea->BuildTree(model);
3299
3300 m_clientArea->UpdateDisplay();
3301
3302 return true;
3303 }
3304
3305 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn *col )
3306 {
3307 if (!wxDataViewCtrlBase::AppendColumn(col))
3308 return false;
3309
3310 m_cols.Append( col );
3311 OnColumnsCountChanged();
3312 return true;
3313 }
3314
3315 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col )
3316 {
3317 if (!wxDataViewCtrlBase::PrependColumn(col))
3318 return false;
3319
3320 m_cols.Insert( col );
3321 OnColumnsCountChanged();
3322 return true;
3323 }
3324
3325 bool wxDataViewCtrl::InsertColumn( unsigned int pos, wxDataViewColumn *col )
3326 {
3327 if (!wxDataViewCtrlBase::InsertColumn(pos,col))
3328 return false;
3329
3330 m_cols.Insert( pos, col );
3331 OnColumnsCountChanged();
3332 return true;
3333 }
3334
3335 void wxDataViewCtrl::OnColumnChange(unsigned int idx)
3336 {
3337 if ( m_headerArea )
3338 m_headerArea->UpdateColumn(idx);
3339
3340 m_clientArea->UpdateDisplay();
3341 }
3342
3343 void wxDataViewCtrl::OnColumnsCountChanged()
3344 {
3345 if (m_headerArea)
3346 m_headerArea->SetColumnCount(GetColumnCount());
3347
3348 m_clientArea->UpdateDisplay();
3349 }
3350
3351 void wxDataViewCtrl::DoSetExpanderColumn()
3352 {
3353 m_clientArea->UpdateDisplay();
3354 }
3355
3356 void wxDataViewCtrl::DoSetIndent()
3357 {
3358 m_clientArea->UpdateDisplay();
3359 }
3360
3361 unsigned int wxDataViewCtrl::GetColumnCount() const
3362 {
3363 return m_cols.GetCount();
3364 }
3365
3366 wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int idx ) const
3367 {
3368 return m_cols[idx];
3369 }
3370
3371 void wxDataViewCtrl::ColumnMoved( wxDataViewColumn* col, unsigned int new_pos )
3372 {
3373 if (new_pos > m_cols.GetCount()) return;
3374
3375 // Exchange position
3376 m_cols.DeleteContents(false);
3377 m_cols.DeleteObject( col );
3378 m_cols.Insert( new_pos, col );
3379 m_cols.DeleteContents(true);
3380
3381 m_clientArea->UpdateDisplay();
3382 }
3383
3384 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column )
3385 {
3386 wxDataViewColumnList::compatibility_iterator ret = m_cols.Find( column );
3387 if (!ret)
3388 return false;
3389
3390 m_cols.Erase(ret);
3391 OnColumnsCountChanged();
3392
3393 return true;
3394 }
3395
3396 bool wxDataViewCtrl::ClearColumns()
3397 {
3398 m_cols.Clear();
3399 OnColumnsCountChanged();
3400 return true;
3401 }
3402
3403 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const
3404 {
3405 int ret = 0, dead = 0;
3406 int len = GetColumnCount();
3407 for (int i=0; i<len; i++)
3408 {
3409 wxDataViewColumn * col = GetColumn(i);
3410 if (col->IsHidden())
3411 continue;
3412 ret += col->GetWidth();
3413 if (column==col)
3414 {
3415 CalcScrolledPosition( ret, dead, &ret, &dead );
3416 break;
3417 }
3418 }
3419 return ret;
3420 }
3421
3422 wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const
3423 {
3424 return NULL;
3425 }
3426
3427 //Selection code with wxDataViewItem as parameters
3428 wxDataViewItem wxDataViewCtrl::GetSelection() const
3429 {
3430 return m_clientArea->GetSelection();
3431 }
3432
3433 int wxDataViewCtrl::GetSelections( wxDataViewItemArray & sel ) const
3434 {
3435 sel.Empty();
3436 wxDataViewSelection selection = m_clientArea->GetSelections();
3437 int len = selection.GetCount();
3438 for( int i = 0; i < len; i ++)
3439 {
3440 unsigned int row = selection[i];
3441 sel.Add( m_clientArea->GetItemByRow( row ) );
3442 }
3443 return len;
3444 }
3445
3446 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray & sel )
3447 {
3448 wxDataViewSelection selection(wxDataViewSelectionCmp);
3449 int len = sel.GetCount();
3450 for( int i = 0; i < len; i ++ )
3451 {
3452 int row = m_clientArea->GetRowByItem( sel[i] );
3453 if( row >= 0 )
3454 selection.Add( static_cast<unsigned int>(row) );
3455 }
3456 m_clientArea->SetSelections( selection );
3457 }
3458
3459 void wxDataViewCtrl::Select( const wxDataViewItem & item )
3460 {
3461 int row = m_clientArea->GetRowByItem( item );
3462 if( row >= 0 )
3463 {
3464 //Unselect all rows before select another in the single select mode
3465 if (m_clientArea->IsSingleSel())
3466 m_clientArea->SelectAllRows(false);
3467 m_clientArea->SelectRow(row, true);
3468 }
3469 }
3470
3471 void wxDataViewCtrl::Unselect( const wxDataViewItem & item )
3472 {
3473 int row = m_clientArea->GetRowByItem( item );
3474 if( row >= 0 )
3475 m_clientArea->SelectRow(row, false);
3476 }
3477
3478 bool wxDataViewCtrl::IsSelected( const wxDataViewItem & item ) const
3479 {
3480 int row = m_clientArea->GetRowByItem( item );
3481 if( row >= 0 )
3482 {
3483 return m_clientArea->IsRowSelected(row);
3484 }
3485 return false;
3486 }
3487
3488 //Selection code with row number as parameter
3489 int wxDataViewCtrl::GetSelections( wxArrayInt & sel ) const
3490 {
3491 sel.Empty();
3492 wxDataViewSelection selection = m_clientArea->GetSelections();
3493 int len = selection.GetCount();
3494 for( int i = 0; i < len; i ++)
3495 {
3496 unsigned int row = selection[i];
3497 sel.Add( row );
3498 }
3499 return len;
3500 }
3501
3502 void wxDataViewCtrl::SetSelections( const wxArrayInt & sel )
3503 {
3504 wxDataViewSelection selection(wxDataViewSelectionCmp);
3505 int len = sel.GetCount();
3506 for( int i = 0; i < len; i ++ )
3507 {
3508 int row = sel[i];
3509 if( row >= 0 )
3510 selection.Add( static_cast<unsigned int>(row) );
3511 }
3512 m_clientArea->SetSelections( selection );
3513 }
3514
3515 void wxDataViewCtrl::Select( int row )
3516 {
3517 if( row >= 0 )
3518 {
3519 if (m_clientArea->IsSingleSel())
3520 m_clientArea->SelectAllRows(false);
3521 m_clientArea->SelectRow( row, true );
3522 }
3523 }
3524
3525 void wxDataViewCtrl::Unselect( int row )
3526 {
3527 if( row >= 0 )
3528 m_clientArea->SelectRow(row, false);
3529 }
3530
3531 bool wxDataViewCtrl::IsSelected( int row ) const
3532 {
3533 if( row >= 0 )
3534 return m_clientArea->IsRowSelected(row);
3535 return false;
3536 }
3537
3538 void wxDataViewCtrl::SelectRange( int from, int to )
3539 {
3540 wxArrayInt sel;
3541 for( int i = from; i < to; i ++ )
3542 sel.Add( i );
3543 m_clientArea->Select(sel);
3544 }
3545
3546 void wxDataViewCtrl::UnselectRange( int from, int to )
3547 {
3548 wxDataViewSelection sel = m_clientArea->GetSelections();
3549 for( int i = from; i < to; i ++ )
3550 if( sel.Index( i ) != wxNOT_FOUND )
3551 sel.Remove( i );
3552 m_clientArea->SetSelections(sel);
3553 }
3554
3555 void wxDataViewCtrl::SelectAll()
3556 {
3557 m_clientArea->SelectAllRows(true);
3558 }
3559
3560 void wxDataViewCtrl::UnselectAll()
3561 {
3562 m_clientArea->SelectAllRows(false);
3563 }
3564
3565 void wxDataViewCtrl::EnsureVisible( int row, int column )
3566 {
3567 if( row < 0 )
3568 row = 0;
3569 if( row > (int) m_clientArea->GetRowCount() )
3570 row = m_clientArea->GetRowCount();
3571
3572 int first = m_clientArea->GetFirstVisibleRow();
3573 int last = m_clientArea->GetLastVisibleRow();
3574 if( row < first )
3575 m_clientArea->ScrollTo( row, column );
3576 else if( row > last )
3577 m_clientArea->ScrollTo( row - last + first, column );
3578 else
3579 m_clientArea->ScrollTo( first, column );
3580 }
3581
3582 void wxDataViewCtrl::EnsureVisible( const wxDataViewItem & item, const wxDataViewColumn * column )
3583 {
3584 int row = m_clientArea->GetRowByItem(item);
3585 if( row >= 0 )
3586 {
3587 if( column == NULL )
3588 EnsureVisible(row, -1);
3589 else
3590 {
3591 int col = 0;
3592 int len = GetColumnCount();
3593 for( int i = 0; i < len; i ++ )
3594 if( GetColumn(i) == column )
3595 {
3596 col = i;
3597 break;
3598 }
3599 EnsureVisible( row, col );
3600 }
3601 }
3602
3603 }
3604
3605 void wxDataViewCtrl::HitTest( const wxPoint & point, wxDataViewItem & item, wxDataViewColumn* &column ) const
3606 {
3607 m_clientArea->HitTest(point, item, column);
3608 }
3609
3610 wxRect wxDataViewCtrl::GetItemRect( const wxDataViewItem & item, const wxDataViewColumn* column ) const
3611 {
3612 return m_clientArea->GetItemRect(item, column);
3613 }
3614
3615 wxDataViewItem wxDataViewCtrl::GetItemByRow( unsigned int row ) const
3616 {
3617 return m_clientArea->GetItemByRow( row );
3618 }
3619
3620 int wxDataViewCtrl::GetRowByItem( const wxDataViewItem & item ) const
3621 {
3622 return m_clientArea->GetRowByItem( item );
3623 }
3624
3625 void wxDataViewCtrl::Expand( const wxDataViewItem & item )
3626 {
3627 int row = m_clientArea->GetRowByItem( item );
3628 if (row != -1)
3629 m_clientArea->Expand(row);
3630 }
3631
3632 void wxDataViewCtrl::Collapse( const wxDataViewItem & item )
3633 {
3634 int row = m_clientArea->GetRowByItem( item );
3635 if (row != -1)
3636 m_clientArea->Collapse(row);
3637 }
3638
3639 #endif
3640 // !wxUSE_GENERICDATAVIEWCTRL
3641
3642 #endif
3643 // wxUSE_DATAVIEWCTRL
wxWidgets (Impactor)