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


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