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