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


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