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


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