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


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