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


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