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


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