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