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