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
7 // Copyright: (c) 1998 Robert Roebling
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
11 // For compilers that support precompilation, includes "wx.h".
12 #include "wx/wxprec.h"
18 #if wxUSE_DATAVIEWCTRL
20 #include "wx/dataview.h"
22 #ifdef wxUSE_GENERICDATAVIEWCTRL
26 #include "wx/msw/private.h"
27 #include "wx/msw/wrapwin.h"
28 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/dcclient.h"
34 #include "wx/settings.h"
35 #include "wx/msgdlg.h"
36 #include "wx/dcscreen.h"
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"
47 #include "wx/listimpl.cpp"
48 #include "wx/imaglist.h"
49 #include "wx/headerctrl.h"
51 #include "wx/stopwatch.h"
53 //-----------------------------------------------------------------------------
55 //-----------------------------------------------------------------------------
57 class wxDataViewColumn
;
58 class wxDataViewHeaderWindow
;
61 //-----------------------------------------------------------------------------
63 //-----------------------------------------------------------------------------
65 static const int SCROLL_UNIT_X
= 15;
67 // the cell padding on the left/right
68 static const int PADDING_RIGHTLEFT
= 3;
70 // the expander space margin
71 static const int EXPANDER_MARGIN
= 4;
74 static const int EXPANDER_OFFSET
= 4;
76 static const int EXPANDER_OFFSET
= 1;
79 // Below is the compare stuff.
80 // For the generic implementation, both the leaf nodes and the nodes are sorted for
81 // fast search when needed
82 static wxDataViewModel
* g_model
;
83 static int g_column
= -2;
84 static bool g_asending
= true;
86 //-----------------------------------------------------------------------------
88 //-----------------------------------------------------------------------------
90 void wxDataViewColumn::Init(int width
, wxAlignment align
, int flags
)
97 m_sortAscending
= true;
100 int wxDataViewColumn::GetWidth() const
104 case wxCOL_WIDTH_DEFAULT
:
105 return wxDVC_DEFAULT_WIDTH
;
107 case wxCOL_WIDTH_AUTOSIZE
:
108 wxCHECK_MSG( m_owner
, wxDVC_DEFAULT_WIDTH
, "no owner control" );
109 return m_owner
->GetBestColumnWidth(m_owner
->GetColumnIndex(this));
116 void wxDataViewColumn::UpdateDisplay()
120 int idx
= m_owner
->GetColumnIndex( this );
121 m_owner
->OnColumnChange( idx
);
125 //-----------------------------------------------------------------------------
126 // wxDataViewHeaderWindow
127 //-----------------------------------------------------------------------------
129 class wxDataViewHeaderWindow
: public wxHeaderCtrl
132 wxDataViewHeaderWindow(wxDataViewCtrl
*parent
)
133 : wxHeaderCtrl(parent
)
137 wxDataViewCtrl
*GetOwner() const
138 { return static_cast<wxDataViewCtrl
*>(GetParent()); }
141 // implement/override wxHeaderCtrl functions by forwarding them to the main
143 virtual const wxHeaderColumn
& GetColumn(unsigned int idx
) const
145 return *(GetOwner()->GetColumn(idx
));
148 virtual bool UpdateColumnWidthToFit(unsigned int idx
, int widthTitle
)
150 wxDataViewCtrl
* const owner
= GetOwner();
152 int widthContents
= owner
->GetBestColumnWidth(idx
);
153 owner
->GetColumn(idx
)->SetWidth(wxMax(widthTitle
, widthContents
));
154 owner
->OnColumnChange(idx
);
160 bool SendEvent(wxEventType type
, unsigned int n
)
162 wxDataViewCtrl
* const owner
= GetOwner();
163 wxDataViewEvent
event(type
, owner
->GetId());
165 event
.SetEventObject(owner
);
167 event
.SetDataViewColumn(owner
->GetColumn(n
));
168 event
.SetModel(owner
->GetModel());
170 // for events created by wxDataViewHeaderWindow the
171 // row / value fields are not valid
172 return owner
->GetEventHandler()->ProcessEvent(event
);
175 void OnClick(wxHeaderCtrlEvent
& event
)
177 const unsigned idx
= event
.GetColumn();
179 if ( SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK
, idx
) )
182 // default handling for the column click is to sort by this column or
183 // toggle its sort order
184 wxDataViewCtrl
* const owner
= GetOwner();
185 wxDataViewColumn
* const col
= owner
->GetColumn(idx
);
186 if ( !col
->IsSortable() )
188 // no default handling for non-sortable columns
193 if ( col
->IsSortKey() )
195 // already using this column for sorting, just change the order
196 col
->ToggleSortOrder();
198 else // not using this column for sorting yet
200 // first unset the old sort column if any
201 int oldSortKey
= owner
->GetSortingColumnIndex();
202 if ( oldSortKey
!= wxNOT_FOUND
)
204 owner
->GetColumn(oldSortKey
)->UnsetAsSortKey();
205 owner
->OnColumnChange(oldSortKey
);
208 owner
->SetSortingColumnIndex(idx
);
212 wxDataViewModel
* const model
= owner
->GetModel();
216 owner
->OnColumnChange(idx
);
218 SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED
, idx
);
221 void OnRClick(wxHeaderCtrlEvent
& event
)
223 if ( !SendEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK
,
228 void OnResize(wxHeaderCtrlEvent
& event
)
230 wxDataViewCtrl
* const owner
= GetOwner();
232 const unsigned col
= event
.GetColumn();
233 owner
->GetColumn(col
)->SetWidth(event
.GetWidth());
234 GetOwner()->OnColumnChange(col
);
237 void OnEndReorder(wxHeaderCtrlEvent
& event
)
239 wxDataViewCtrl
* const owner
= GetOwner();
240 owner
->ColumnMoved(owner
->GetColumn(event
.GetColumn()),
241 event
.GetNewOrder());
244 DECLARE_EVENT_TABLE()
245 wxDECLARE_NO_COPY_CLASS(wxDataViewHeaderWindow
);
248 BEGIN_EVENT_TABLE(wxDataViewHeaderWindow
, wxHeaderCtrl
)
249 EVT_HEADER_CLICK(wxID_ANY
, wxDataViewHeaderWindow::OnClick
)
250 EVT_HEADER_RIGHT_CLICK(wxID_ANY
, wxDataViewHeaderWindow::OnRClick
)
252 EVT_HEADER_RESIZING(wxID_ANY
, wxDataViewHeaderWindow::OnResize
)
253 EVT_HEADER_END_RESIZE(wxID_ANY
, wxDataViewHeaderWindow::OnResize
)
255 EVT_HEADER_END_REORDER(wxID_ANY
, wxDataViewHeaderWindow::OnEndReorder
)
258 //-----------------------------------------------------------------------------
259 // wxDataViewRenameTimer
260 //-----------------------------------------------------------------------------
262 class wxDataViewRenameTimer
: public wxTimer
265 wxDataViewMainWindow
*m_owner
;
268 wxDataViewRenameTimer( wxDataViewMainWindow
*owner
);
272 //-----------------------------------------------------------------------------
273 // wxDataViewTreeNode
274 //-----------------------------------------------------------------------------
276 class wxDataViewTreeNode
;
277 WX_DEFINE_ARRAY( wxDataViewTreeNode
*, wxDataViewTreeNodes
);
279 int LINKAGEMODE
wxGenericTreeModelNodeCmp( wxDataViewTreeNode
** node1
,
280 wxDataViewTreeNode
** node2
);
282 class wxDataViewTreeNode
285 wxDataViewTreeNode(wxDataViewTreeNode
*parent
, const wxDataViewItem
& item
)
288 m_hasChildren(false),
294 static wxDataViewTreeNode
* CreateRootNode()
296 wxDataViewTreeNode
*n
= new wxDataViewTreeNode(NULL
, wxDataViewItem());
298 n
->m_hasChildren
= true;
302 wxDataViewTreeNode
* GetParent() const { return m_parent
; }
304 wxDataViewTreeNodes
& GetNodes() { return m_nodes
; }
306 void AddNode( wxDataViewTreeNode
* node
)
309 // TODO: insert into sorted array directly in O(log n) instead of resorting in O(n log n)
311 m_nodes
.Sort( &wxGenericTreeModelNodeCmp
);
314 const wxDataViewItem
& GetItem() const { return m_item
; }
315 void SetItem( const wxDataViewItem
& item
) { m_item
= item
; }
317 int GetIndentLevel() const
320 const wxDataViewTreeNode
* node
= this;
321 while( node
->GetParent()->GetParent() != NULL
)
323 node
= node
->GetParent();
338 const int len
= m_nodes
.GetCount();
339 for ( int i
= 0;i
< len
; i
++)
340 sum
+= 1 + m_nodes
[i
]->GetSubTreeCount();
344 ChangeSubTreeCount(-sum
);
350 ChangeSubTreeCount(+sum
);
354 // "HasChildren" property corresponds to model's IsContainer(). Note that it may be true
355 // even if GetNodes() is empty; see below.
356 bool HasChildren() const { return m_hasChildren
; }
357 void SetHasChildren(bool has
) { m_hasChildren
= has
; }
359 int GetSubTreeCount() const { return m_subTreeCount
; }
360 void ChangeSubTreeCount( int num
)
365 m_subTreeCount
+= num
;
366 wxASSERT( m_subTreeCount
>= 0 );
369 m_parent
->ChangeSubTreeCount(num
);
376 m_nodes
.Sort( &wxGenericTreeModelNodeCmp
);
377 int len
= m_nodes
.GetCount();
378 for (int i
= 0; i
< len
; i
++)
380 if ( m_nodes
[i
]->HasChildren() )
381 m_nodes
[i
]->Resort();
388 // Corresponding model item.
389 wxDataViewItem m_item
;
391 wxDataViewTreeNode
*m_parent
;
393 // Child nodes. Note that this may be empty even if m_hasChildren in case this branch
394 // of the tree wasn't expanded and realized yet.
395 wxDataViewTreeNodes m_nodes
;
397 // True if the node has children, i.e. if model's IsContainer() returned true for it.
400 // Is the branch node currently open (expanded)?
403 // Total count of expanded (i.e. visible with the help of some scrolling) items in the subtree,
404 // but excluding this node. I.e. it is 0 for leaves and is the number of rows the subtree occupies
410 int LINKAGEMODE
wxGenericTreeModelNodeCmp( wxDataViewTreeNode
** node1
,
411 wxDataViewTreeNode
** node2
)
413 return g_model
->Compare( (*node1
)->GetItem(), (*node2
)->GetItem(), g_column
, g_asending
);
417 //-----------------------------------------------------------------------------
418 // wxDataViewMainWindow
419 //-----------------------------------------------------------------------------
421 WX_DEFINE_SORTED_ARRAY_SIZE_T(unsigned int, wxDataViewSelection
);
423 class wxDataViewMainWindow
: public wxWindow
426 wxDataViewMainWindow( wxDataViewCtrl
*parent
,
428 const wxPoint
&pos
= wxDefaultPosition
,
429 const wxSize
&size
= wxDefaultSize
,
430 const wxString
&name
= wxT("wxdataviewctrlmainwindow") );
431 virtual ~wxDataViewMainWindow();
433 bool IsList() const { return GetOwner()->GetModel()->IsListModel(); }
434 bool IsVirtualList() const { return m_root
== NULL
; }
436 // notifications from wxDataViewModel
437 bool ItemAdded( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
438 bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
);
439 bool ItemChanged( const wxDataViewItem
&item
);
440 bool ValueChanged( const wxDataViewItem
&item
, unsigned int model_column
);
444 if (!IsVirtualList())
454 g_model
= GetOwner()->GetModel();
455 wxDataViewColumn
* col
= GetOwner()->GetSortingColumn();
458 if (g_model
->HasDefaultCompare())
466 g_column
= col
->GetModelColumn();
467 g_asending
= col
->IsSortOrderAscending();
470 void SetOwner( wxDataViewCtrl
* owner
) { m_owner
= owner
; }
471 wxDataViewCtrl
*GetOwner() { return m_owner
; }
472 const wxDataViewCtrl
*GetOwner() const { return m_owner
; }
474 #if wxUSE_DRAG_AND_DROP
475 wxBitmap
CreateItemBitmap( unsigned int row
, int &indent
);
476 #endif // wxUSE_DRAG_AND_DROP
477 void OnPaint( wxPaintEvent
&event
);
478 void OnArrowChar(unsigned int newCurrent
, const wxKeyEvent
& event
);
479 void OnChar( wxKeyEvent
&event
);
480 void OnMouse( wxMouseEvent
&event
);
481 void OnSetFocus( wxFocusEvent
&event
);
482 void OnKillFocus( wxFocusEvent
&event
);
484 void UpdateDisplay();
485 void RecalculateDisplay();
486 void OnInternalIdle();
488 void OnRenameTimer();
490 void ScrollWindow( int dx
, int dy
, const wxRect
*rect
= NULL
);
491 void ScrollTo( int rows
, int column
);
493 unsigned GetCurrentRow() const { return m_currentRow
; }
494 bool HasCurrentRow() { return m_currentRow
!= (unsigned int)-1; }
495 void ChangeCurrentRow( unsigned int row
);
497 bool IsSingleSel() const { return !GetParent()->HasFlag(wxDV_MULTIPLE
); }
498 bool IsEmpty() { return GetRowCount() == 0; }
500 int GetCountPerPage() const;
501 int GetEndOfLastCol() const;
502 unsigned int GetFirstVisibleRow() const;
504 // I change this method to un const because in the tree view,
505 // the displaying number of the tree are changing along with the
506 // expanding/collapsing of the tree nodes
507 unsigned int GetLastVisibleRow();
508 unsigned int GetRowCount();
510 const wxDataViewSelection
& GetSelections() const { return m_selection
; }
511 void SetSelections( const wxDataViewSelection
& sel
)
512 { m_selection
= sel
; UpdateDisplay(); }
513 void Select( const wxArrayInt
& aSelections
);
514 void SelectAllRows( bool on
);
515 void SelectRow( unsigned int row
, bool on
);
516 void SelectRows( unsigned int from
, unsigned int to
, bool on
);
517 void ReverseRowSelection( unsigned int row
);
518 bool IsRowSelected( unsigned int row
);
519 void SendSelectionChangedEvent( const wxDataViewItem
& item
);
521 void RefreshRow( unsigned int row
);
522 void RefreshRows( unsigned int from
, unsigned int to
);
523 void RefreshRowsAfter( unsigned int firstRow
);
525 // returns the colour to be used for drawing the rules
526 wxColour
GetRuleColour() const
528 return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT
);
531 wxRect
GetLineRect( unsigned int row
) const;
533 int GetLineStart( unsigned int row
) const; // row * m_lineHeight in fixed mode
534 int GetLineHeight( unsigned int row
) const; // m_lineHeight in fixed mode
535 int GetLineAt( unsigned int y
) const; // y / m_lineHeight in fixed mode
537 void SetRowHeight( int lineHeight
) { m_lineHeight
= lineHeight
; }
539 // Some useful functions for row and item mapping
540 wxDataViewItem
GetItemByRow( unsigned int row
) const;
541 int GetRowByItem( const wxDataViewItem
& item
) const;
543 // Methods for building the mapping tree
544 void BuildTree( wxDataViewModel
* model
);
546 void HitTest( const wxPoint
& point
, wxDataViewItem
& item
, wxDataViewColumn
* &column
);
547 wxRect
GetItemRect( const wxDataViewItem
& item
, const wxDataViewColumn
* column
);
549 void Expand( unsigned int row
);
550 void Collapse( unsigned int row
);
551 bool IsExpanded( unsigned int row
) const;
552 bool HasChildren( unsigned int row
) const;
554 #if wxUSE_DRAG_AND_DROP
555 bool EnableDragSource( const wxDataFormat
&format
);
556 bool EnableDropTarget( const wxDataFormat
&format
);
558 void RemoveDropHint();
559 wxDragResult
OnDragOver( wxDataFormat format
, wxCoord x
, wxCoord y
, wxDragResult def
);
560 bool OnDrop( wxDataFormat format
, wxCoord x
, wxCoord y
);
561 wxDragResult
OnData( wxDataFormat format
, wxCoord x
, wxCoord y
, wxDragResult def
);
563 #endif // wxUSE_DRAG_AND_DROP
566 wxDataViewTreeNode
* GetTreeNodeByRow( unsigned int row
) const;
567 // We did not need this temporarily
568 // wxDataViewTreeNode * GetTreeNodeByItem( const wxDataViewItem & item );
570 int RecalculateCount();
572 // Return false only if the event was vetoed by its handler.
573 bool SendExpanderEvent(wxEventType type
, const wxDataViewItem
& item
);
575 wxDataViewTreeNode
* FindNode( const wxDataViewItem
& item
);
578 wxDataViewCtrl
*m_owner
;
582 wxDataViewColumn
*m_currentCol
;
583 unsigned int m_currentRow
;
584 wxDataViewSelection m_selection
;
586 wxDataViewRenameTimer
*m_renameTimer
;
591 #if wxUSE_DRAG_AND_DROP
596 wxDataFormat m_dragFormat
;
599 wxDataFormat m_dropFormat
;
601 unsigned int m_dropHintLine
;
602 #endif // wxUSE_DRAG_AND_DROP
604 // for double click logic
605 unsigned int m_lineLastClicked
,
606 m_lineBeforeLastClicked
,
607 m_lineSelectSingleOnUp
;
609 // the pen used to draw horiz/vertical rules
612 // the pen used to draw the expander and the lines
615 // This is the tree structure of the model
616 wxDataViewTreeNode
* m_root
;
619 // This is the tree node under the cursor
620 wxDataViewTreeNode
* m_underMouse
;
623 DECLARE_DYNAMIC_CLASS(wxDataViewMainWindow
)
624 DECLARE_EVENT_TABLE()
627 // ---------------------------------------------------------
628 // wxGenericDataViewModelNotifier
629 // ---------------------------------------------------------
631 class wxGenericDataViewModelNotifier
: public wxDataViewModelNotifier
634 wxGenericDataViewModelNotifier( wxDataViewMainWindow
*mainWindow
)
635 { m_mainWindow
= mainWindow
; }
637 virtual bool ItemAdded( const wxDataViewItem
& parent
, const wxDataViewItem
& item
)
638 { return m_mainWindow
->ItemAdded( parent
, item
); }
639 virtual bool ItemDeleted( const wxDataViewItem
&parent
, const wxDataViewItem
&item
)
640 { return m_mainWindow
->ItemDeleted( parent
, item
); }
641 virtual bool ItemChanged( const wxDataViewItem
& item
)
642 { return m_mainWindow
->ItemChanged(item
); }
643 virtual bool ValueChanged( const wxDataViewItem
& item
, unsigned int col
)
644 { return m_mainWindow
->ValueChanged( item
, col
); }
645 virtual bool Cleared()
646 { return m_mainWindow
->Cleared(); }
647 virtual void Resort()
648 { m_mainWindow
->Resort(); }
650 wxDataViewMainWindow
*m_mainWindow
;
653 // ---------------------------------------------------------
654 // wxDataViewRenderer
655 // ---------------------------------------------------------
657 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer
, wxDataViewRendererBase
)
659 wxDataViewRenderer::wxDataViewRenderer( const wxString
&varianttype
,
660 wxDataViewCellMode mode
,
662 wxDataViewCustomRendererBase( varianttype
, mode
, align
)
666 m_ellipsizeMode
= wxELLIPSIZE_MIDDLE
;
670 wxDataViewRenderer::~wxDataViewRenderer()
675 wxDC
*wxDataViewRenderer::GetDC()
679 if (GetOwner() == NULL
)
681 if (GetOwner()->GetOwner() == NULL
)
683 m_dc
= new wxClientDC( GetOwner()->GetOwner() );
689 void wxDataViewRenderer::SetAlignment( int align
)
694 int wxDataViewRenderer::GetAlignment() const
699 // ---------------------------------------------------------
700 // wxDataViewCustomRenderer
701 // ---------------------------------------------------------
703 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer
, wxDataViewRenderer
)
705 wxDataViewCustomRenderer::wxDataViewCustomRenderer( const wxString
&varianttype
,
706 wxDataViewCellMode mode
, int align
) :
707 wxDataViewRenderer( varianttype
, mode
, align
)
711 // ---------------------------------------------------------
712 // wxDataViewTextRenderer
713 // ---------------------------------------------------------
715 IMPLEMENT_CLASS(wxDataViewTextRenderer
, wxDataViewRenderer
)
717 wxDataViewTextRenderer::wxDataViewTextRenderer( const wxString
&varianttype
,
718 wxDataViewCellMode mode
, int align
) :
719 wxDataViewRenderer( varianttype
, mode
, align
)
723 bool wxDataViewTextRenderer::SetValue( const wxVariant
&value
)
725 m_text
= value
.GetString();
730 bool wxDataViewTextRenderer::GetValue( wxVariant
& WXUNUSED(value
) ) const
735 bool wxDataViewTextRenderer::HasEditorCtrl() const
740 wxWindow
* wxDataViewTextRenderer::CreateEditorCtrl( wxWindow
*parent
,
741 wxRect labelRect
, const wxVariant
&value
)
743 wxTextCtrl
* ctrl
= new wxTextCtrl( parent
, wxID_ANY
, value
,
744 wxPoint(labelRect
.x
,labelRect
.y
),
745 wxSize(labelRect
.width
,labelRect
.height
) );
747 // select the text in the control an place the cursor at the end
748 ctrl
->SetInsertionPointEnd();
754 bool wxDataViewTextRenderer::GetValueFromEditorCtrl( wxWindow
*editor
, wxVariant
&value
)
756 wxTextCtrl
*text
= (wxTextCtrl
*) editor
;
757 value
= text
->GetValue();
761 bool wxDataViewTextRenderer::Render(wxRect rect
, wxDC
*dc
, int state
)
763 RenderText(m_text
, 0, rect
, dc
, state
);
767 wxSize
wxDataViewTextRenderer::GetSize() const
770 return GetTextExtent(m_text
);
772 return wxSize(wxDVC_DEFAULT_RENDERER_SIZE
,wxDVC_DEFAULT_RENDERER_SIZE
);
775 // ---------------------------------------------------------
776 // wxDataViewBitmapRenderer
777 // ---------------------------------------------------------
779 IMPLEMENT_CLASS(wxDataViewBitmapRenderer
, wxDataViewRenderer
)
781 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer( const wxString
&varianttype
,
782 wxDataViewCellMode mode
, int align
) :
783 wxDataViewRenderer( varianttype
, mode
, align
)
787 bool wxDataViewBitmapRenderer::SetValue( const wxVariant
&value
)
789 if (value
.GetType() == wxT("wxBitmap"))
791 if (value
.GetType() == wxT("wxIcon"))
797 bool wxDataViewBitmapRenderer::GetValue( wxVariant
& WXUNUSED(value
) ) const
802 bool wxDataViewBitmapRenderer::Render( wxRect cell
, wxDC
*dc
, int WXUNUSED(state
) )
805 dc
->DrawBitmap( m_bitmap
, cell
.x
, cell
.y
);
806 else if (m_icon
.IsOk())
807 dc
->DrawIcon( m_icon
, cell
.x
, cell
.y
);
812 wxSize
wxDataViewBitmapRenderer::GetSize() const
815 return wxSize( m_bitmap
.GetWidth(), m_bitmap
.GetHeight() );
816 else if (m_icon
.IsOk())
817 return wxSize( m_icon
.GetWidth(), m_icon
.GetHeight() );
819 return wxSize(wxDVC_DEFAULT_RENDERER_SIZE
,wxDVC_DEFAULT_RENDERER_SIZE
);
822 // ---------------------------------------------------------
823 // wxDataViewToggleRenderer
824 // ---------------------------------------------------------
826 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer
, wxDataViewRenderer
)
828 wxDataViewToggleRenderer::wxDataViewToggleRenderer( const wxString
&varianttype
,
829 wxDataViewCellMode mode
, int align
) :
830 wxDataViewRenderer( varianttype
, mode
, align
)
835 bool wxDataViewToggleRenderer::SetValue( const wxVariant
&value
)
837 m_toggle
= value
.GetBool();
842 bool wxDataViewToggleRenderer::GetValue( wxVariant
&WXUNUSED(value
) ) const
847 bool wxDataViewToggleRenderer::Render( wxRect cell
, wxDC
*dc
, int WXUNUSED(state
) )
851 flags
|= wxCONTROL_CHECKED
;
852 if (GetMode() != wxDATAVIEW_CELL_ACTIVATABLE
||
853 GetEnabled() == false)
854 flags
|= wxCONTROL_DISABLED
;
856 // check boxes we draw must always have the same, standard size (if it's
857 // bigger than the cell size the checkbox will be truncated because the
858 // caller had set the clipping rectangle to prevent us from drawing outside
860 cell
.SetSize(GetSize());
862 wxRendererNative::Get().DrawCheckBox(
863 GetOwner()->GetOwner(),
871 bool wxDataViewToggleRenderer::WXOnLeftClick(const wxPoint
& cursor
,
872 const wxRect
& WXUNUSED(cell
),
873 wxDataViewModel
*model
,
874 const wxDataViewItem
& item
,
877 // only react to clicks directly on the checkbox, not elsewhere in the same cell:
878 if (!wxRect(GetSize()).Contains(cursor
))
881 if (model
->IsEnabled(item
, col
))
883 model
->ChangeValue(!m_toggle
, item
, col
);
890 wxSize
wxDataViewToggleRenderer::GetSize() const
892 // the window parameter is not used by GetCheckBoxSize() so it's
894 return wxRendererNative::Get().GetCheckBoxSize(NULL
);
897 // ---------------------------------------------------------
898 // wxDataViewProgressRenderer
899 // ---------------------------------------------------------
901 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer
, wxDataViewRenderer
)
903 wxDataViewProgressRenderer::wxDataViewProgressRenderer( const wxString
&label
,
904 const wxString
&varianttype
, wxDataViewCellMode mode
, int align
) :
905 wxDataViewRenderer( varianttype
, mode
, align
)
911 bool wxDataViewProgressRenderer::SetValue( const wxVariant
&value
)
913 m_value
= (long) value
;
915 if (m_value
< 0) m_value
= 0;
916 if (m_value
> 100) m_value
= 100;
921 bool wxDataViewProgressRenderer::GetValue( wxVariant
&value
) const
923 value
= (long) m_value
;
928 wxDataViewProgressRenderer::Render(wxRect rect
, wxDC
*dc
, int WXUNUSED(state
))
930 // deflate the rect to leave a small border between bars in adjacent rows
931 wxRect bar
= rect
.Deflate(0, 1);
933 dc
->SetBrush( *wxTRANSPARENT_BRUSH
);
934 dc
->SetPen( *wxBLACK_PEN
);
935 dc
->DrawRectangle( bar
);
937 bar
.width
= (int)(bar
.width
* m_value
/ 100.);
938 dc
->SetPen( *wxTRANSPARENT_PEN
);
940 const wxDataViewItemAttr
& attr
= GetAttr();
941 dc
->SetBrush( attr
.HasColour() ? wxBrush(attr
.GetColour())
943 dc
->DrawRectangle( bar
);
948 wxSize
wxDataViewProgressRenderer::GetSize() const
950 return wxSize(40,12);
953 // ---------------------------------------------------------
954 // wxDataViewDateRenderer
955 // ---------------------------------------------------------
957 #define wxUSE_DATE_RENDERER_POPUP (wxUSE_CALENDARCTRL && wxUSE_POPUPWIN)
959 #if wxUSE_DATE_RENDERER_POPUP
961 class wxDataViewDateRendererPopupTransient
: public wxPopupTransientWindow
964 wxDataViewDateRendererPopupTransient( wxWindow
* parent
, wxDateTime
*value
,
965 wxDataViewModel
*model
, const wxDataViewItem
& item
, unsigned int col
) :
966 wxPopupTransientWindow( parent
, wxBORDER_SIMPLE
),
971 m_cal
= new wxCalendarCtrl( this, wxID_ANY
, *value
);
972 wxBoxSizer
*sizer
= new wxBoxSizer( wxHORIZONTAL
);
973 sizer
->Add( m_cal
, 1, wxGROW
);
978 void OnCalendar( wxCalendarEvent
&event
);
980 wxCalendarCtrl
*m_cal
;
981 wxDataViewModel
*m_model
;
983 const wxDataViewItem
& m_item
;
986 virtual void OnDismiss()
991 DECLARE_EVENT_TABLE()
994 BEGIN_EVENT_TABLE(wxDataViewDateRendererPopupTransient
,wxPopupTransientWindow
)
995 EVT_CALENDAR( wxID_ANY
, wxDataViewDateRendererPopupTransient::OnCalendar
)
998 void wxDataViewDateRendererPopupTransient::OnCalendar( wxCalendarEvent
&event
)
1000 m_model
->ChangeValue( event
.GetDate(), m_item
, m_col
);
1004 #endif // wxUSE_DATE_RENDERER_POPUP
1006 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer
, wxDataViewRenderer
)
1008 wxDataViewDateRenderer::wxDataViewDateRenderer( const wxString
&varianttype
,
1009 wxDataViewCellMode mode
, int align
) :
1010 wxDataViewRenderer( varianttype
, mode
, align
)
1014 bool wxDataViewDateRenderer::SetValue( const wxVariant
&value
)
1016 m_date
= value
.GetDateTime();
1021 bool wxDataViewDateRenderer::GetValue( wxVariant
&value
) const
1027 bool wxDataViewDateRenderer::Render( wxRect cell
, wxDC
*dc
, int state
)
1029 wxString tmp
= m_date
.FormatDate();
1030 RenderText( tmp
, 0, cell
, dc
, state
);
1034 wxSize
wxDataViewDateRenderer::GetSize() const
1036 return GetTextExtent(m_date
.FormatDate());
1039 bool wxDataViewDateRenderer::WXOnActivate(const wxRect
& WXUNUSED(cell
),
1040 wxDataViewModel
*model
,
1041 const wxDataViewItem
& item
,
1044 wxDateTime dtOld
= m_date
;
1046 #if wxUSE_DATE_RENDERER_POPUP
1047 wxDataViewDateRendererPopupTransient
*popup
= new wxDataViewDateRendererPopupTransient(
1048 GetOwner()->GetOwner()->GetParent(), &dtOld
, model
, item
, col
);
1049 wxPoint pos
= wxGetMousePosition();
1052 popup
->Popup( popup
->m_cal
);
1053 #else // !wxUSE_DATE_RENDERER_POPUP
1054 wxMessageBox(dtOld
.Format());
1055 #endif // wxUSE_DATE_RENDERER_POPUP/!wxUSE_DATE_RENDERER_POPUP
1060 // ---------------------------------------------------------
1061 // wxDataViewIconTextRenderer
1062 // ---------------------------------------------------------
1064 IMPLEMENT_CLASS(wxDataViewIconTextRenderer
, wxDataViewRenderer
)
1066 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(
1067 const wxString
&varianttype
, wxDataViewCellMode mode
, int align
) :
1068 wxDataViewRenderer( varianttype
, mode
, align
)
1071 SetAlignment(align
);
1074 bool wxDataViewIconTextRenderer::SetValue( const wxVariant
&value
)
1080 bool wxDataViewIconTextRenderer::GetValue( wxVariant
& WXUNUSED(value
) ) const
1085 bool wxDataViewIconTextRenderer::Render(wxRect rect
, wxDC
*dc
, int state
)
1089 const wxIcon
& icon
= m_value
.GetIcon();
1092 dc
->DrawIcon(icon
, rect
.x
, rect
.y
+ (rect
.height
- icon
.GetHeight())/2);
1093 xoffset
= icon
.GetWidth()+4;
1096 RenderText(m_value
.GetText(), xoffset
, rect
, dc
, state
);
1101 wxSize
wxDataViewIconTextRenderer::GetSize() const
1103 if (!m_value
.GetText().empty())
1105 wxSize size
= GetTextExtent(m_value
.GetText());
1107 if (m_value
.GetIcon().IsOk())
1108 size
.x
+= m_value
.GetIcon().GetWidth() + 4;
1111 return wxSize(80,20);
1114 wxWindow
* wxDataViewIconTextRenderer::CreateEditorCtrl(wxWindow
*parent
, wxRect labelRect
, const wxVariant
& value
)
1116 wxDataViewIconText iconText
;
1119 wxString text
= iconText
.GetText();
1121 // adjust the label rect to take the width of the icon into account
1122 if (iconText
.GetIcon().IsOk())
1124 int w
= iconText
.GetIcon().GetWidth() + 4;
1126 labelRect
.width
-= w
;
1129 wxTextCtrl
* ctrl
= new wxTextCtrl( parent
, wxID_ANY
, text
,
1130 wxPoint(labelRect
.x
,labelRect
.y
),
1131 wxSize(labelRect
.width
,labelRect
.height
) );
1133 // select the text in the control an place the cursor at the end
1134 ctrl
->SetInsertionPointEnd();
1140 bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxWindow
*editor
, wxVariant
& value
)
1142 wxTextCtrl
*text
= (wxTextCtrl
*) editor
;
1144 wxDataViewIconText
iconText(text
->GetValue(), m_value
.GetIcon());
1149 //-----------------------------------------------------------------------------
1150 // wxDataViewDropTarget
1151 //-----------------------------------------------------------------------------
1153 #if wxUSE_DRAG_AND_DROP
1155 class wxBitmapCanvas
: public wxWindow
1158 wxBitmapCanvas( wxWindow
*parent
, const wxBitmap
&bitmap
, const wxSize
&size
) :
1159 wxWindow( parent
, wxID_ANY
, wxPoint(0,0), size
)
1162 Connect( wxEVT_PAINT
, wxPaintEventHandler(wxBitmapCanvas::OnPaint
) );
1165 void OnPaint( wxPaintEvent
&WXUNUSED(event
) )
1168 dc
.DrawBitmap( m_bitmap
, 0, 0);
1174 class wxDataViewDropSource
: public wxDropSource
1177 wxDataViewDropSource( wxDataViewMainWindow
*win
, unsigned int row
) :
1185 ~wxDataViewDropSource()
1190 virtual bool GiveFeedback( wxDragResult
WXUNUSED(effect
) )
1192 wxPoint pos
= wxGetMousePosition();
1196 int liney
= m_win
->GetLineStart( m_row
);
1198 m_win
->GetOwner()->CalcUnscrolledPosition( 0, liney
, NULL
, &liney
);
1199 m_win
->ClientToScreen( &linex
, &liney
);
1200 m_dist_x
= pos
.x
- linex
;
1201 m_dist_y
= pos
.y
- liney
;
1204 wxBitmap ib
= m_win
->CreateItemBitmap( m_row
, indent
);
1206 m_hint
= new wxFrame( m_win
->GetParent(), wxID_ANY
, wxEmptyString
,
1207 wxPoint(pos
.x
- m_dist_x
, pos
.y
+ 5 ),
1209 wxFRAME_TOOL_WINDOW
|
1210 wxFRAME_FLOAT_ON_PARENT
|
1211 wxFRAME_NO_TASKBAR
|
1213 new wxBitmapCanvas( m_hint
, ib
, ib
.GetSize() );
1218 m_hint
->Move( pos
.x
- m_dist_x
, pos
.y
+ 5 );
1219 m_hint
->SetTransparent( 128 );
1225 wxDataViewMainWindow
*m_win
;
1228 int m_dist_x
,m_dist_y
;
1232 class wxDataViewDropTarget
: public wxDropTarget
1235 wxDataViewDropTarget( wxDataObject
*obj
, wxDataViewMainWindow
*win
) :
1241 virtual wxDragResult
OnDragOver( wxCoord x
, wxCoord y
, wxDragResult def
)
1243 wxDataFormat format
= GetMatchingPair();
1244 if (format
== wxDF_INVALID
)
1246 return m_win
->OnDragOver( format
, x
, y
, def
);
1249 virtual bool OnDrop( wxCoord x
, wxCoord y
)
1251 wxDataFormat format
= GetMatchingPair();
1252 if (format
== wxDF_INVALID
)
1254 return m_win
->OnDrop( format
, x
, y
);
1257 virtual wxDragResult
OnData( wxCoord x
, wxCoord y
, wxDragResult def
)
1259 wxDataFormat format
= GetMatchingPair();
1260 if (format
== wxDF_INVALID
)
1264 return m_win
->OnData( format
, x
, y
, def
);
1267 virtual void OnLeave()
1268 { m_win
->OnLeave(); }
1270 wxDataViewMainWindow
*m_win
;
1273 #endif // wxUSE_DRAG_AND_DROP
1275 //-----------------------------------------------------------------------------
1276 // wxDataViewRenameTimer
1277 //-----------------------------------------------------------------------------
1279 wxDataViewRenameTimer::wxDataViewRenameTimer( wxDataViewMainWindow
*owner
)
1284 void wxDataViewRenameTimer::Notify()
1286 m_owner
->OnRenameTimer();
1289 //-----------------------------------------------------------------------------
1290 // wxDataViewMainWindow
1291 //-----------------------------------------------------------------------------
1293 // The tree building helper, declared firstly
1294 static void BuildTreeHelper( const wxDataViewModel
* model
, const wxDataViewItem
& item
,
1295 wxDataViewTreeNode
* node
);
1297 int LINKAGEMODE
wxDataViewSelectionCmp( unsigned int row1
, unsigned int row2
)
1299 if (row1
> row2
) return 1;
1300 if (row1
== row2
) return 0;
1304 IMPLEMENT_ABSTRACT_CLASS(wxDataViewMainWindow
, wxWindow
)
1306 BEGIN_EVENT_TABLE(wxDataViewMainWindow
,wxWindow
)
1307 EVT_PAINT (wxDataViewMainWindow::OnPaint
)
1308 EVT_MOUSE_EVENTS (wxDataViewMainWindow::OnMouse
)
1309 EVT_SET_FOCUS (wxDataViewMainWindow::OnSetFocus
)
1310 EVT_KILL_FOCUS (wxDataViewMainWindow::OnKillFocus
)
1311 EVT_CHAR (wxDataViewMainWindow::OnChar
)
1314 wxDataViewMainWindow::wxDataViewMainWindow( wxDataViewCtrl
*parent
, wxWindowID id
,
1315 const wxPoint
&pos
, const wxSize
&size
, const wxString
&name
) :
1316 wxWindow( parent
, id
, pos
, size
, wxWANTS_CHARS
|wxBORDER_NONE
, name
),
1317 m_selection( wxDataViewSelectionCmp
)
1322 m_lastOnSame
= false;
1323 m_renameTimer
= new wxDataViewRenameTimer( this );
1325 // TODO: user better initial values/nothing selected
1326 m_currentCol
= NULL
;
1329 m_lineHeight
= wxMax( 17, GetCharHeight() + 2 ); // 17 = mini icon height + 1
1331 #if wxUSE_DRAG_AND_DROP
1333 m_dragStart
= wxPoint(0,0);
1335 m_dragEnabled
= false;
1336 m_dropEnabled
= false;
1338 m_dropHintLine
= (unsigned int) -1;
1339 #endif // wxUSE_DRAG_AND_DROP
1341 m_lineLastClicked
= (unsigned int) -1;
1342 m_lineBeforeLastClicked
= (unsigned int) -1;
1343 m_lineSelectSingleOnUp
= (unsigned int) -1;
1347 SetBackgroundColour( *wxWHITE
);
1349 SetBackgroundStyle(wxBG_STYLE_CUSTOM
);
1351 m_penRule
= wxPen(GetRuleColour());
1353 // compose a pen whichcan draw black lines
1354 // TODO: maybe there is something system colour to use
1355 m_penExpander
= wxPen(wxColour(0,0,0));
1357 m_root
= wxDataViewTreeNode::CreateRootNode();
1359 // Make m_count = -1 will cause the class recaculate the real displaying number of rows.
1361 m_underMouse
= NULL
;
1365 wxDataViewMainWindow::~wxDataViewMainWindow()
1368 delete m_renameTimer
;
1372 #if wxUSE_DRAG_AND_DROP
1373 bool wxDataViewMainWindow::EnableDragSource( const wxDataFormat
&format
)
1375 m_dragFormat
= format
;
1376 m_dragEnabled
= format
!= wxDF_INVALID
;
1381 bool wxDataViewMainWindow::EnableDropTarget( const wxDataFormat
&format
)
1383 m_dropFormat
= format
;
1384 m_dropEnabled
= format
!= wxDF_INVALID
;
1387 SetDropTarget( new wxDataViewDropTarget( new wxCustomDataObject( format
), this ) );
1392 void wxDataViewMainWindow::RemoveDropHint()
1397 RefreshRow( m_dropHintLine
);
1398 m_dropHintLine
= (unsigned int) -1;
1402 wxDragResult
wxDataViewMainWindow::OnDragOver( wxDataFormat format
, wxCoord x
,
1403 wxCoord y
, wxDragResult def
)
1407 m_owner
->CalcUnscrolledPosition( xx
, yy
, &xx
, &yy
);
1408 unsigned int row
= GetLineAt( yy
);
1410 if ((row
>= GetRowCount()) || (xx
> GetEndOfLastCol()))
1416 wxDataViewItem item
= GetItemByRow( row
);
1418 wxDataViewModel
*model
= GetOwner()->GetModel();
1420 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE
, m_owner
->GetId() );
1421 event
.SetEventObject( m_owner
);
1422 event
.SetItem( item
);
1423 event
.SetModel( model
);
1424 event
.SetDataFormat( format
);
1425 if (!m_owner
->HandleWindowEvent( event
))
1431 if (!event
.IsAllowed())
1438 if (m_dropHint
&& (row
!= m_dropHintLine
))
1439 RefreshRow( m_dropHintLine
);
1441 m_dropHintLine
= row
;
1447 bool wxDataViewMainWindow::OnDrop( wxDataFormat format
, wxCoord x
, wxCoord y
)
1453 m_owner
->CalcUnscrolledPosition( xx
, yy
, &xx
, &yy
);
1454 unsigned int row
= GetLineAt( yy
);
1456 if ((row
>= GetRowCount()) || (xx
> GetEndOfLastCol()))
1459 wxDataViewItem item
= GetItemByRow( row
);
1461 wxDataViewModel
*model
= GetOwner()->GetModel();
1463 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE
, m_owner
->GetId() );
1464 event
.SetEventObject( m_owner
);
1465 event
.SetItem( item
);
1466 event
.SetModel( model
);
1467 event
.SetDataFormat( format
);
1468 if (!m_owner
->HandleWindowEvent( event
))
1471 if (!event
.IsAllowed())
1477 wxDragResult
wxDataViewMainWindow::OnData( wxDataFormat format
, wxCoord x
, wxCoord y
,
1482 m_owner
->CalcUnscrolledPosition( xx
, yy
, &xx
, &yy
);
1483 unsigned int row
= GetLineAt( yy
);
1485 if ((row
>= GetRowCount()) || (xx
> GetEndOfLastCol()))
1488 wxDataViewItem item
= GetItemByRow( row
);
1490 wxDataViewModel
*model
= GetOwner()->GetModel();
1492 wxCustomDataObject
*obj
= (wxCustomDataObject
*) GetDropTarget()->GetDataObject();
1494 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_DROP
, m_owner
->GetId() );
1495 event
.SetEventObject( m_owner
);
1496 event
.SetItem( item
);
1497 event
.SetModel( model
);
1498 event
.SetDataFormat( format
);
1499 event
.SetDataSize( obj
->GetSize() );
1500 event
.SetDataBuffer( obj
->GetData() );
1501 if (!m_owner
->HandleWindowEvent( event
))
1504 if (!event
.IsAllowed())
1510 void wxDataViewMainWindow::OnLeave()
1515 wxBitmap
wxDataViewMainWindow::CreateItemBitmap( unsigned int row
, int &indent
)
1517 int height
= GetLineHeight( row
);
1519 unsigned int cols
= GetOwner()->GetColumnCount();
1521 for (col
= 0; col
< cols
; col
++)
1523 wxDataViewColumn
*column
= GetOwner()->GetColumnAt(col
);
1524 if (column
->IsHidden())
1525 continue; // skip it!
1526 width
+= column
->GetWidth();
1532 wxDataViewTreeNode
*node
= GetTreeNodeByRow(row
);
1533 indent
= GetOwner()->GetIndent() * node
->GetIndentLevel();
1534 indent
= indent
+ m_lineHeight
;
1535 // try to use the m_lineHeight as the expander space
1539 wxBitmap
bitmap( width
, height
);
1540 wxMemoryDC
dc( bitmap
);
1541 dc
.SetFont( GetFont() );
1542 dc
.SetPen( *wxBLACK_PEN
);
1543 dc
.SetBrush( *wxWHITE_BRUSH
);
1544 dc
.DrawRectangle( 0,0,width
,height
);
1546 wxDataViewModel
*model
= m_owner
->GetModel();
1548 wxDataViewColumn
*expander
= GetOwner()->GetExpanderColumn();
1551 // TODO-RTL: last column for RTL support
1552 expander
= GetOwner()->GetColumnAt( 0 );
1553 GetOwner()->SetExpanderColumn(expander
);
1558 for (col
= 0; col
< cols
; col
++)
1560 wxDataViewColumn
*column
= GetOwner()->GetColumnAt( col
);
1561 wxDataViewRenderer
*cell
= column
->GetRenderer();
1563 if (column
->IsHidden())
1564 continue; // skip it!
1566 width
= column
->GetWidth();
1568 if (column
== expander
)
1571 wxDataViewItem item
= GetItemByRow( row
);
1572 cell
->PrepareForItem(model
, item
, column
->GetModelColumn());
1574 wxRect
item_rect(x
, 0, width
, height
);
1575 item_rect
.Deflate(PADDING_RIGHTLEFT
, 0);
1577 // dc.SetClippingRegion( item_rect );
1578 cell
->WXCallRender(item_rect
, &dc
, 0);
1579 // dc.DestroyClippingRegion();
1587 #endif // wxUSE_DRAG_AND_DROP
1590 void wxDataViewMainWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
1592 wxDataViewModel
*model
= GetOwner()->GetModel();
1593 wxAutoBufferedPaintDC
dc( this );
1596 dc
.SetBrush(GetOwner()->GetBackgroundColour());
1597 dc
.SetPen( *wxTRANSPARENT_PEN
);
1598 dc
.DrawRectangle(GetClientSize());
1603 // No items to draw.
1608 GetOwner()->PrepareDC( dc
);
1609 dc
.SetFont( GetFont() );
1611 wxRect update
= GetUpdateRegion().GetBox();
1612 m_owner
->CalcUnscrolledPosition( update
.x
, update
.y
, &update
.x
, &update
.y
);
1614 // compute which items needs to be redrawn
1615 unsigned int item_start
= GetLineAt( wxMax(0,update
.y
) );
1616 unsigned int item_count
=
1617 wxMin( (int)( GetLineAt( wxMax(0,update
.y
+update
.height
) ) - item_start
+ 1),
1618 (int)(GetRowCount( ) - item_start
));
1619 unsigned int item_last
= item_start
+ item_count
;
1621 // Send the event to wxDataViewCtrl itself.
1622 wxWindow
* const parent
= GetParent();
1623 wxDataViewEvent
cache_event(wxEVT_COMMAND_DATAVIEW_CACHE_HINT
, parent
->GetId());
1624 cache_event
.SetEventObject(parent
);
1625 cache_event
.SetCache(item_start
, item_last
- 1);
1626 parent
->ProcessWindowEvent(cache_event
);
1628 // compute which columns needs to be redrawn
1629 unsigned int cols
= GetOwner()->GetColumnCount();
1632 // we assume that we have at least one column below and painting an
1633 // empty control is unnecessary anyhow
1637 unsigned int col_start
= 0;
1638 unsigned int x_start
;
1639 for (x_start
= 0; col_start
< cols
; col_start
++)
1641 wxDataViewColumn
*col
= GetOwner()->GetColumnAt(col_start
);
1642 if (col
->IsHidden())
1643 continue; // skip it!
1645 unsigned int w
= col
->GetWidth();
1646 if (x_start
+w
>= (unsigned int)update
.x
)
1652 unsigned int col_last
= col_start
;
1653 unsigned int x_last
= x_start
;
1654 for (; col_last
< cols
; col_last
++)
1656 wxDataViewColumn
*col
= GetOwner()->GetColumnAt(col_last
);
1657 if (col
->IsHidden())
1658 continue; // skip it!
1660 if (x_last
> (unsigned int)update
.GetRight())
1663 x_last
+= col
->GetWidth();
1666 // Draw horizontal rules if required
1667 if ( m_owner
->HasFlag(wxDV_HORIZ_RULES
) )
1669 dc
.SetPen(m_penRule
);
1670 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
1672 for (unsigned int i
= item_start
; i
<= item_last
; i
++)
1674 int y
= GetLineStart( i
);
1675 dc
.DrawLine(x_start
, y
, x_last
, y
);
1679 // Draw vertical rules if required
1680 if ( m_owner
->HasFlag(wxDV_VERT_RULES
) )
1682 dc
.SetPen(m_penRule
);
1683 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
1685 // NB: Vertical rules are drawn in the last pixel of a column so that
1686 // they align perfectly with native MSW wxHeaderCtrl as well as for
1687 // consistency with MSW native list control. There's no vertical
1688 // rule at the most-left side of the control.
1690 int x
= x_start
- 1;
1691 for (unsigned int i
= col_start
; i
< col_last
; i
++)
1693 wxDataViewColumn
*col
= GetOwner()->GetColumnAt(i
);
1694 if (col
->IsHidden())
1695 continue; // skip it
1697 x
+= col
->GetWidth();
1699 dc
.DrawLine(x
, GetLineStart( item_start
),
1700 x
, GetLineStart( item_last
) );
1704 // redraw the background for the items which are selected/current
1705 for (unsigned int item
= item_start
; item
< item_last
; item
++)
1707 bool selected
= m_selection
.Index( item
) != wxNOT_FOUND
;
1708 if (selected
|| item
== m_currentRow
)
1710 int flags
= selected
? (int)wxCONTROL_SELECTED
: 0;
1711 if (item
== m_currentRow
)
1712 flags
|= wxCONTROL_CURRENT
;
1714 flags
|= wxCONTROL_FOCUSED
;
1716 wxRect
rect( x_start
, GetLineStart( item
),
1717 x_last
- x_start
, GetLineHeight( item
) );
1718 wxRendererNative::Get().DrawItemSelectionRect
1728 #if wxUSE_DRAG_AND_DROP
1731 wxRect
rect( x_start
, GetLineStart( m_dropHintLine
),
1732 x_last
- x_start
, GetLineHeight( m_dropHintLine
) );
1733 dc
.SetPen( *wxBLACK_PEN
);
1734 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
1735 dc
.DrawRectangle( rect
);
1737 #endif // wxUSE_DRAG_AND_DROP
1739 wxDataViewColumn
*expander
= GetOwner()->GetExpanderColumn();
1742 // TODO-RTL: last column for RTL support
1743 expander
= GetOwner()->GetColumnAt( 0 );
1744 GetOwner()->SetExpanderColumn(expander
);
1747 // redraw all cells for all rows which must be repainted and all columns
1749 cell_rect
.x
= x_start
;
1750 for (unsigned int i
= col_start
; i
< col_last
; i
++)
1752 wxDataViewColumn
*col
= GetOwner()->GetColumnAt( i
);
1753 wxDataViewRenderer
*cell
= col
->GetRenderer();
1754 cell_rect
.width
= col
->GetWidth();
1756 if ( col
->IsHidden() || cell_rect
.width
<= 0 )
1757 continue; // skip it!
1759 for (unsigned int item
= item_start
; item
< item_last
; item
++)
1761 // get the cell value and set it into the renderer
1762 wxDataViewTreeNode
*node
= NULL
;
1763 wxDataViewItem dataitem
;
1765 if (!IsVirtualList())
1767 node
= GetTreeNodeByRow(item
);
1771 dataitem
= node
->GetItem();
1773 // Skip all columns of "container" rows except the expander
1774 // column itself unless HasContainerColumns() overrides this.
1775 if ( col
!= GetOwner()->GetExpanderColumn() &&
1776 model
->IsContainer(dataitem
) &&
1777 !model
->HasContainerColumns(dataitem
) )
1782 dataitem
= wxDataViewItem( wxUIntToPtr(item
+1) );
1785 cell
->PrepareForItem(model
, dataitem
, col
->GetModelColumn());
1788 cell_rect
.y
= GetLineStart( item
);
1789 cell_rect
.height
= GetLineHeight( item
);
1791 // deal with the expander
1793 if ((!IsList()) && (col
== expander
))
1795 // Calculate the indent first
1796 indent
= GetOwner()->GetIndent() * node
->GetIndentLevel();
1798 // we reserve m_lineHeight of horizontal space for the expander
1799 // but leave EXPANDER_MARGIN around the expander itself
1800 int exp_x
= cell_rect
.x
+ indent
+ EXPANDER_MARGIN
;
1802 indent
+= m_lineHeight
;
1804 // draw expander if needed and visible
1805 if ( node
->HasChildren() && exp_x
< cell_rect
.GetRight() )
1807 dc
.SetPen( m_penExpander
);
1808 dc
.SetBrush( wxNullBrush
);
1810 int exp_size
= m_lineHeight
- 2*EXPANDER_MARGIN
;
1811 int exp_y
= cell_rect
.y
+ (cell_rect
.height
- exp_size
)/2
1812 + EXPANDER_MARGIN
- EXPANDER_OFFSET
;
1814 const wxRect
rect(exp_x
, exp_y
, exp_size
, exp_size
);
1817 if ( m_underMouse
== node
)
1818 flag
|= wxCONTROL_CURRENT
;
1819 if ( node
->IsOpen() )
1820 flag
|= wxCONTROL_EXPANDED
;
1822 // ensure that we don't overflow the cell (which might
1823 // happen if the column is very narrow)
1824 wxDCClipper
clip(dc
, cell_rect
);
1826 wxRendererNative::Get().DrawTreeItemButton( this, dc
, rect
, flag
);
1829 // force the expander column to left-center align
1830 cell
->SetAlignment( wxALIGN_CENTER_VERTICAL
);
1833 wxRect item_rect
= cell_rect
;
1834 item_rect
.Deflate(PADDING_RIGHTLEFT
, 0);
1836 // account for the tree indent (harmless if we're not indented)
1837 item_rect
.x
+= indent
;
1838 item_rect
.width
-= indent
;
1840 if ( item_rect
.width
<= 0 )
1844 if (m_hasFocus
&& (m_selection
.Index(item
) != wxNOT_FOUND
))
1845 state
|= wxDATAVIEW_CELL_SELECTED
;
1847 // TODO: it would be much more efficient to create a clipping
1848 // region for the entire column being rendered (in the OnPaint
1849 // of wxDataViewMainWindow) instead of a single clip region for
1850 // each cell. However it would mean that each renderer should
1851 // respect the given wxRect's top & bottom coords, eventually
1852 // violating only the left & right coords - however the user can
1853 // make its own renderer and thus we cannot be sure of that.
1854 wxDCClipper
clip(dc
, item_rect
);
1856 cell
->WXCallRender(item_rect
, &dc
, state
);
1859 cell_rect
.x
+= cell_rect
.width
;
1863 void wxDataViewMainWindow::OnRenameTimer()
1865 // We have to call this here because changes may just have
1866 // been made and no screen update taken place.
1869 // TODO: use wxTheApp->SafeYieldFor(NULL, wxEVT_CATEGORY_UI) instead
1870 // (needs to be tested!)
1874 wxDataViewItem item
= GetItemByRow( m_currentRow
);
1876 wxRect labelRect
= GetItemRect(item
, m_currentCol
);
1878 m_currentCol
->GetRenderer()->StartEditing( item
, labelRect
);
1881 //-----------------------------------------------------------------------------
1882 // Helper class for do operation on the tree node
1883 //-----------------------------------------------------------------------------
1888 virtual ~DoJob() { }
1890 // The return value control how the tree-walker tranverse the tree
1891 // 0: Job done, stop tranverse and return
1892 // 1: Ignore the current node's subtree and continue
1893 // 2: Job not done, continue
1894 enum { OK
= 0 , IGR
= 1, CONT
= 2 };
1895 virtual int operator() ( wxDataViewTreeNode
* node
) = 0;
1898 bool Walker( wxDataViewTreeNode
* node
, DoJob
& func
)
1900 wxCHECK_MSG( node
, false, "can't walk NULL node" );
1902 switch( func( node
) )
1912 const wxDataViewTreeNodes
& nodes
= node
->GetNodes();
1914 for ( wxDataViewTreeNodes::const_iterator i
= nodes
.begin();
1918 if ( Walker(*i
, func
) )
1925 bool wxDataViewMainWindow::ItemAdded(const wxDataViewItem
& parent
, const wxDataViewItem
& item
)
1927 if (IsVirtualList())
1929 wxDataViewVirtualListModel
*list_model
=
1930 (wxDataViewVirtualListModel
*) GetOwner()->GetModel();
1931 m_count
= list_model
->GetCount();
1937 wxDataViewTreeNode
*parentNode
= FindNode(parent
);
1942 wxDataViewTreeNode
*itemNode
= new wxDataViewTreeNode(parentNode
, item
);
1943 itemNode
->SetHasChildren(GetOwner()->GetModel()->IsContainer(item
));
1945 parentNode
->AddNode(itemNode
);
1946 parentNode
->SetHasChildren(true);
1947 parentNode
->ChangeSubTreeCount(+1);
1952 GetOwner()->UpdateColBestWidths();
1958 static void DestroyTreeHelper( wxDataViewTreeNode
* node
);
1960 bool wxDataViewMainWindow::ItemDeleted(const wxDataViewItem
& parent
,
1961 const wxDataViewItem
& item
)
1963 if (IsVirtualList())
1965 wxDataViewVirtualListModel
*list_model
=
1966 (wxDataViewVirtualListModel
*) GetOwner()->GetModel();
1967 m_count
= list_model
->GetCount();
1969 if ( !m_selection
.empty() )
1971 const int row
= GetRowByItem(item
);
1973 int rowIndexInSelection
= wxNOT_FOUND
;
1975 const size_t selCount
= m_selection
.size();
1976 for ( size_t i
= 0; i
< selCount
; i
++ )
1978 if ( m_selection
[i
] == (unsigned)row
)
1979 rowIndexInSelection
= i
;
1980 else if ( m_selection
[i
] > (unsigned)row
)
1984 if ( rowIndexInSelection
!= wxNOT_FOUND
)
1985 m_selection
.RemoveAt(rowIndexInSelection
);
1989 else // general case
1991 wxDataViewTreeNode
*parentNode
= FindNode(parent
);
1993 // Notice that it is possible that the item being deleted is not in the
1994 // tree at all, for example we could be deleting a never shown (because
1995 // collapsed) item in a tree model. So it's not an error if we don't know
1996 // about this item, just return without doing anything then.
2000 const wxDataViewTreeNodes
& parentsChildren
= parentNode
->GetNodes();
2002 // We can't use FindNode() to find 'item', because it was already
2003 // removed from the model by the time ItemDeleted() is called, so we
2004 // have to do it manually. We keep track of its position as well for
2006 int itemPosInNode
= 0;
2007 wxDataViewTreeNode
*itemNode
= NULL
;
2008 for ( wxDataViewTreeNodes::const_iterator i
= parentsChildren
.begin();
2009 i
!= parentsChildren
.end();
2010 ++i
, ++itemPosInNode
)
2012 if( (*i
)->GetItem() == item
)
2019 // If the parent wasn't expanded, it's possible that we didn't have a
2020 // node corresponding to 'item' and so there's nothing left to do.
2023 // If this was the last child to be removed, it's possible the parent
2024 // node became a leaf. Let's ask the model about it.
2025 if ( parentNode
->GetNodes().empty() )
2026 parentNode
->SetHasChildren(GetOwner()->GetModel()->IsContainer(parent
));
2031 // Delete the item from wxDataViewTreeNode representation:
2032 const int itemsDeleted
= 1 + itemNode
->GetSubTreeCount();
2034 parentNode
->GetNodes().Remove(itemNode
);
2035 ::DestroyTreeHelper(itemNode
);
2036 parentNode
->ChangeSubTreeCount(-itemsDeleted
);
2038 // Make the row number invalid and get a new valid one when user call GetRowCount
2041 // If this was the last child to be removed, it's possible the parent
2042 // node became a leaf. Let's ask the model about it.
2043 if ( parentNode
->GetNodes().empty() )
2044 parentNode
->SetHasChildren(GetOwner()->GetModel()->IsContainer(parent
));
2046 // Update selection by removing 'item' and its entire children tree from the selection.
2047 if ( !m_selection
.empty() )
2049 // we can't call GetRowByItem() on 'item', as it's already deleted, so compute it from
2050 // the parent ('parentNode') and position in its list of children
2052 if ( itemPosInNode
== 0 )
2054 // 1st child, row number is that of the parent parentNode + 1
2055 itemRow
= GetRowByItem(parentNode
->GetItem()) + 1;
2059 // row number is that of the sibling above 'item' + its subtree if any + 1
2060 const wxDataViewTreeNode
*siblingNode
= parentNode
->GetNodes()[itemPosInNode
- 1];
2062 itemRow
= GetRowByItem(siblingNode
->GetItem()) +
2063 siblingNode
->GetSubTreeCount() +
2067 wxDataViewSelection
newsel(wxDataViewSelectionCmp
);
2069 const size_t numSelections
= m_selection
.size();
2070 for ( size_t i
= 0; i
< numSelections
; ++i
)
2072 const int s
= m_selection
[i
];
2074 newsel
.push_back(s
);
2075 else if ( s
>= itemRow
+ itemsDeleted
)
2076 newsel
.push_back(s
- itemsDeleted
);
2077 // else: deleted item, remove from selection
2080 m_selection
= newsel
;
2084 // Change the current row to the last row if the current exceed the max row number
2085 if( m_currentRow
> GetRowCount() )
2086 ChangeCurrentRow(m_count
- 1);
2088 GetOwner()->UpdateColBestWidths();
2094 bool wxDataViewMainWindow::ItemChanged(const wxDataViewItem
& item
)
2099 GetOwner()->UpdateColBestWidths();
2102 wxWindow
*parent
= GetParent();
2103 wxDataViewEvent
le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, parent
->GetId());
2104 le
.SetEventObject(parent
);
2105 le
.SetModel(GetOwner()->GetModel());
2107 parent
->GetEventHandler()->ProcessEvent(le
);
2112 bool wxDataViewMainWindow::ValueChanged( const wxDataViewItem
& item
, unsigned int model_column
)
2114 int view_column
= -1;
2115 unsigned int n_col
= m_owner
->GetColumnCount();
2116 for (unsigned i
= 0; i
< n_col
; i
++)
2118 wxDataViewColumn
*column
= m_owner
->GetColumn( i
);
2119 if (column
->GetModelColumn() == model_column
)
2121 view_column
= (int) i
;
2125 if (view_column
== -1)
2128 // NOTE: to be valid, we cannot use e.g. INT_MAX - 1
2129 /*#define MAX_VIRTUAL_WIDTH 100000
2131 wxRect rect( 0, row*m_lineHeight, MAX_VIRTUAL_WIDTH, m_lineHeight );
2132 m_owner->CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2133 Refresh( true, &rect );
2140 GetOwner()->UpdateColBestWidth(view_column
);
2143 wxWindow
*parent
= GetParent();
2144 wxDataViewEvent
le(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED
, parent
->GetId());
2145 le
.SetEventObject(parent
);
2146 le
.SetModel(GetOwner()->GetModel());
2148 le
.SetColumn(view_column
);
2149 le
.SetDataViewColumn(GetOwner()->GetColumn(view_column
));
2150 parent
->GetEventHandler()->ProcessEvent(le
);
2155 bool wxDataViewMainWindow::Cleared()
2158 m_selection
.Clear();
2161 BuildTree( GetOwner()->GetModel() );
2163 GetOwner()->UpdateColBestWidths();
2169 void wxDataViewMainWindow::UpdateDisplay()
2172 m_underMouse
= NULL
;
2175 void wxDataViewMainWindow::OnInternalIdle()
2177 wxWindow::OnInternalIdle();
2181 RecalculateDisplay();
2186 void wxDataViewMainWindow::RecalculateDisplay()
2188 wxDataViewModel
*model
= GetOwner()->GetModel();
2195 int width
= GetEndOfLastCol();
2196 int height
= GetLineStart( GetRowCount() );
2198 SetVirtualSize( width
, height
);
2199 GetOwner()->SetScrollRate( 10, m_lineHeight
);
2204 void wxDataViewMainWindow::ScrollWindow( int dx
, int dy
, const wxRect
*rect
)
2206 m_underMouse
= NULL
;
2208 wxWindow::ScrollWindow( dx
, dy
, rect
);
2210 if (GetOwner()->m_headerArea
)
2211 GetOwner()->m_headerArea
->ScrollWindow( dx
, 0 );
2214 void wxDataViewMainWindow::ScrollTo( int rows
, int column
)
2216 m_underMouse
= NULL
;
2219 m_owner
->GetScrollPixelsPerUnit( &x
, &y
);
2220 int sy
= GetLineStart( rows
)/y
;
2224 wxRect rect
= GetClientRect();
2228 m_owner
->CalcUnscrolledPosition( rect
.x
, rect
.y
, &xx
, &yy
);
2229 for (x_start
= 0; colnum
< column
; colnum
++)
2231 wxDataViewColumn
*col
= GetOwner()->GetColumnAt(colnum
);
2232 if (col
->IsHidden())
2233 continue; // skip it!
2235 w
= col
->GetWidth();
2239 int x_end
= x_start
+ w
;
2240 xe
= xx
+ rect
.width
;
2243 sx
= ( xx
+ x_end
- xe
)/x
;
2250 m_owner
->Scroll( sx
, sy
);
2253 int wxDataViewMainWindow::GetCountPerPage() const
2255 wxSize size
= GetClientSize();
2256 return size
.y
/ m_lineHeight
;
2259 int wxDataViewMainWindow::GetEndOfLastCol() const
2263 for (i
= 0; i
< GetOwner()->GetColumnCount(); i
++)
2265 const wxDataViewColumn
*c
=
2266 const_cast<wxDataViewCtrl
*>(GetOwner())->GetColumnAt( i
);
2269 width
+= c
->GetWidth();
2274 unsigned int wxDataViewMainWindow::GetFirstVisibleRow() const
2278 m_owner
->CalcUnscrolledPosition( x
, y
, &x
, &y
);
2280 return GetLineAt( y
);
2283 unsigned int wxDataViewMainWindow::GetLastVisibleRow()
2285 wxSize client_size
= GetClientSize();
2286 m_owner
->CalcUnscrolledPosition( client_size
.x
, client_size
.y
,
2287 &client_size
.x
, &client_size
.y
);
2289 // we should deal with the pixel here
2290 unsigned int row
= GetLineAt(client_size
.y
) - 1;
2292 return wxMin( GetRowCount()-1, row
);
2295 unsigned int wxDataViewMainWindow::GetRowCount()
2297 if ( m_count
== -1 )
2299 m_count
= RecalculateCount();
2305 void wxDataViewMainWindow::ChangeCurrentRow( unsigned int row
)
2312 void wxDataViewMainWindow::SelectAllRows( bool on
)
2319 m_selection
.Clear();
2320 for (unsigned int i
= 0; i
< GetRowCount(); i
++)
2321 m_selection
.Add( i
);
2326 unsigned int first_visible
= GetFirstVisibleRow();
2327 unsigned int last_visible
= GetLastVisibleRow();
2329 for (i
= 0; i
< m_selection
.GetCount(); i
++)
2331 unsigned int row
= m_selection
[i
];
2332 if ((row
>= first_visible
) && (row
<= last_visible
))
2335 m_selection
.Clear();
2339 void wxDataViewMainWindow::SelectRow( unsigned int row
, bool on
)
2341 if (m_selection
.Index( row
) == wxNOT_FOUND
)
2345 m_selection
.Add( row
);
2353 m_selection
.Remove( row
);
2359 void wxDataViewMainWindow::SelectRows( unsigned int from
, unsigned int to
, bool on
)
2363 unsigned int tmp
= from
;
2369 for (i
= from
; i
<= to
; i
++)
2371 if (m_selection
.Index( i
) == wxNOT_FOUND
)
2374 m_selection
.Add( i
);
2379 m_selection
.Remove( i
);
2382 RefreshRows( from
, to
);
2385 void wxDataViewMainWindow::Select( const wxArrayInt
& aSelections
)
2387 for (size_t i
=0; i
< aSelections
.GetCount(); i
++)
2389 int n
= aSelections
[i
];
2391 m_selection
.Add( n
);
2396 void wxDataViewMainWindow::ReverseRowSelection( unsigned int row
)
2398 if (m_selection
.Index( row
) == wxNOT_FOUND
)
2399 m_selection
.Add( row
);
2401 m_selection
.Remove( row
);
2405 bool wxDataViewMainWindow::IsRowSelected( unsigned int row
)
2407 return (m_selection
.Index( row
) != wxNOT_FOUND
);
2410 void wxDataViewMainWindow::SendSelectionChangedEvent( const wxDataViewItem
& item
)
2412 wxWindow
*parent
= GetParent();
2413 wxDataViewEvent
le(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED
, parent
->GetId());
2415 le
.SetEventObject(parent
);
2416 le
.SetModel(GetOwner()->GetModel());
2419 parent
->GetEventHandler()->ProcessEvent(le
);
2422 void wxDataViewMainWindow::RefreshRow( unsigned int row
)
2424 wxRect
rect( 0, GetLineStart( row
), GetEndOfLastCol(), GetLineHeight( row
) );
2425 m_owner
->CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2427 wxSize client_size
= GetClientSize();
2428 wxRect
client_rect( 0, 0, client_size
.x
, client_size
.y
);
2429 wxRect intersect_rect
= client_rect
.Intersect( rect
);
2430 if (intersect_rect
.width
> 0)
2431 Refresh( true, &intersect_rect
);
2434 void wxDataViewMainWindow::RefreshRows( unsigned int from
, unsigned int to
)
2438 unsigned int tmp
= to
;
2443 wxRect
rect( 0, GetLineStart( from
), GetEndOfLastCol(), GetLineStart( (to
-from
+1) ) );
2444 m_owner
->CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2446 wxSize client_size
= GetClientSize();
2447 wxRect
client_rect( 0, 0, client_size
.x
, client_size
.y
);
2448 wxRect intersect_rect
= client_rect
.Intersect( rect
);
2449 if (intersect_rect
.width
> 0)
2450 Refresh( true, &intersect_rect
);
2453 void wxDataViewMainWindow::RefreshRowsAfter( unsigned int firstRow
)
2455 wxSize client_size
= GetClientSize();
2456 int start
= GetLineStart( firstRow
);
2457 m_owner
->CalcScrolledPosition( start
, 0, &start
, NULL
);
2458 if (start
> client_size
.y
) return;
2460 wxRect
rect( 0, start
, client_size
.x
, client_size
.y
- start
);
2462 Refresh( true, &rect
);
2465 void wxDataViewMainWindow::OnArrowChar(unsigned int newCurrent
, const wxKeyEvent
& event
)
2467 wxCHECK_RET( newCurrent
< GetRowCount(),
2468 wxT("invalid item index in OnArrowChar()") );
2470 // if there is no selection, we cannot move it anywhere
2471 if (!HasCurrentRow())
2474 unsigned int oldCurrent
= m_currentRow
;
2476 // in single selection we just ignore Shift as we can't select several
2478 if ( event
.ShiftDown() && !IsSingleSel() )
2480 RefreshRow( oldCurrent
);
2482 ChangeCurrentRow( newCurrent
);
2484 // select all the items between the old and the new one
2485 if ( oldCurrent
> newCurrent
)
2487 newCurrent
= oldCurrent
;
2488 oldCurrent
= m_currentRow
;
2491 SelectRows( oldCurrent
, newCurrent
, true );
2492 if (oldCurrent
!=newCurrent
)
2493 SendSelectionChangedEvent(GetItemByRow(m_selection
[0]));
2497 RefreshRow( oldCurrent
);
2499 // all previously selected items are unselected unless ctrl is held
2500 if ( !event
.ControlDown() )
2501 SelectAllRows(false);
2503 ChangeCurrentRow( newCurrent
);
2505 if ( !event
.ControlDown() )
2507 SelectRow( m_currentRow
, true );
2508 SendSelectionChangedEvent(GetItemByRow(m_currentRow
));
2511 RefreshRow( m_currentRow
);
2514 GetOwner()->EnsureVisible( m_currentRow
, -1 );
2517 wxRect
wxDataViewMainWindow::GetLineRect( unsigned int row
) const
2521 rect
.y
= GetLineStart( row
);
2522 rect
.width
= GetEndOfLastCol();
2523 rect
.height
= GetLineHeight( row
);
2528 int wxDataViewMainWindow::GetLineStart( unsigned int row
) const
2530 const wxDataViewModel
*model
= GetOwner()->GetModel();
2532 if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT
)
2534 // TODO make more efficient
2539 for (r
= 0; r
< row
; r
++)
2541 const wxDataViewTreeNode
* node
= GetTreeNodeByRow(r
);
2542 if (!node
) return start
;
2544 wxDataViewItem item
= node
->GetItem();
2546 unsigned int cols
= GetOwner()->GetColumnCount();
2548 int height
= m_lineHeight
;
2549 for (col
= 0; col
< cols
; col
++)
2551 const wxDataViewColumn
*column
= GetOwner()->GetColumn(col
);
2552 if (column
->IsHidden())
2553 continue; // skip it!
2556 model
->IsContainer(item
) &&
2557 !model
->HasContainerColumns(item
))
2558 continue; // skip it!
2560 wxDataViewRenderer
*renderer
=
2561 const_cast<wxDataViewRenderer
*>(column
->GetRenderer());
2562 renderer
->PrepareForItem(model
, item
, column
->GetModelColumn());
2564 height
= wxMax( height
, renderer
->GetSize().y
);
2574 return row
* m_lineHeight
;
2578 int wxDataViewMainWindow::GetLineAt( unsigned int y
) const
2580 const wxDataViewModel
*model
= GetOwner()->GetModel();
2582 // check for the easy case first
2583 if ( !GetOwner()->HasFlag(wxDV_VARIABLE_LINE_HEIGHT
) )
2584 return y
/ m_lineHeight
;
2586 // TODO make more efficient
2587 unsigned int row
= 0;
2588 unsigned int yy
= 0;
2591 const wxDataViewTreeNode
* node
= GetTreeNodeByRow(row
);
2594 // not really correct...
2595 return row
+ ((y
-yy
) / m_lineHeight
);
2598 wxDataViewItem item
= node
->GetItem();
2600 unsigned int cols
= GetOwner()->GetColumnCount();
2602 int height
= m_lineHeight
;
2603 for (col
= 0; col
< cols
; col
++)
2605 const wxDataViewColumn
*column
= GetOwner()->GetColumn(col
);
2606 if (column
->IsHidden())
2607 continue; // skip it!
2610 model
->IsContainer(item
) &&
2611 !model
->HasContainerColumns(item
))
2612 continue; // skip it!
2614 wxDataViewRenderer
*renderer
=
2615 const_cast<wxDataViewRenderer
*>(column
->GetRenderer());
2616 renderer
->PrepareForItem(model
, item
, column
->GetModelColumn());
2618 height
= wxMax( height
, renderer
->GetSize().y
);
2629 int wxDataViewMainWindow::GetLineHeight( unsigned int row
) const
2631 const wxDataViewModel
*model
= GetOwner()->GetModel();
2633 if (GetOwner()->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT
)
2635 wxASSERT( !IsVirtualList() );
2637 const wxDataViewTreeNode
* node
= GetTreeNodeByRow(row
);
2638 // wxASSERT( node );
2639 if (!node
) return m_lineHeight
;
2641 wxDataViewItem item
= node
->GetItem();
2643 int height
= m_lineHeight
;
2645 unsigned int cols
= GetOwner()->GetColumnCount();
2647 for (col
= 0; col
< cols
; col
++)
2649 const wxDataViewColumn
*column
= GetOwner()->GetColumn(col
);
2650 if (column
->IsHidden())
2651 continue; // skip it!
2654 model
->IsContainer(item
) &&
2655 !model
->HasContainerColumns(item
))
2656 continue; // skip it!
2658 wxDataViewRenderer
*renderer
=
2659 const_cast<wxDataViewRenderer
*>(column
->GetRenderer());
2660 renderer
->PrepareForItem(model
, item
, column
->GetModelColumn());
2662 height
= wxMax( height
, renderer
->GetSize().y
);
2669 return m_lineHeight
;
2674 class RowToTreeNodeJob
: public DoJob
2677 RowToTreeNodeJob( unsigned int row
, int current
, wxDataViewTreeNode
* node
)
2680 this->current
= current
;
2685 virtual int operator() ( wxDataViewTreeNode
* node
)
2688 if( current
== static_cast<int>(row
))
2694 if( node
->GetSubTreeCount() + current
< static_cast<int>(row
) )
2696 current
+= node
->GetSubTreeCount();
2703 // If the current node has only leaf children, we can find the
2704 // desired node directly. This can speed up finding the node
2705 // in some cases, and will have a very good effect for list views.
2706 if ( (int)node
->GetNodes().size() == node
->GetSubTreeCount() )
2708 const int index
= static_cast<int>(row
) - current
- 1;
2709 ret
= node
->GetNodes()[index
];
2716 wxDataViewTreeNode
* GetResult() const
2722 wxDataViewTreeNode
* ret
;
2723 wxDataViewTreeNode
* parent
;
2726 wxDataViewTreeNode
* wxDataViewMainWindow::GetTreeNodeByRow(unsigned int row
) const
2728 wxASSERT( !IsVirtualList() );
2730 RowToTreeNodeJob
job( row
, -2, m_root
);
2731 Walker( m_root
, job
);
2732 return job
.GetResult();
2735 wxDataViewItem
wxDataViewMainWindow::GetItemByRow(unsigned int row
) const
2737 if (IsVirtualList())
2739 return wxDataViewItem( wxUIntToPtr(row
+1) );
2743 wxDataViewTreeNode
*node
= GetTreeNodeByRow(row
);
2744 return node
? node
->GetItem() : wxDataViewItem();
2749 wxDataViewMainWindow::SendExpanderEvent(wxEventType type
,
2750 const wxDataViewItem
& item
)
2752 wxWindow
*parent
= GetParent();
2753 wxDataViewEvent
le(type
, parent
->GetId());
2755 le
.SetEventObject(parent
);
2756 le
.SetModel(GetOwner()->GetModel());
2759 return !parent
->ProcessWindowEvent(le
) || le
.IsAllowed();
2762 bool wxDataViewMainWindow::IsExpanded( unsigned int row
) const
2767 wxDataViewTreeNode
* node
= GetTreeNodeByRow(row
);
2771 if (!node
->HasChildren())
2774 return node
->IsOpen();
2777 bool wxDataViewMainWindow::HasChildren( unsigned int row
) const
2782 wxDataViewTreeNode
* node
= GetTreeNodeByRow(row
);
2786 if (!node
->HasChildren())
2792 void wxDataViewMainWindow::Expand( unsigned int row
)
2797 wxDataViewTreeNode
* node
= GetTreeNodeByRow(row
);
2801 if (!node
->HasChildren())
2804 if (!node
->IsOpen())
2806 if ( !SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING
, node
->GetItem()) )
2808 // Vetoed by the event handler.
2814 // build the children of current node
2815 if( node
->GetNodes().empty() )
2818 ::BuildTreeHelper(GetOwner()->GetModel(), node
->GetItem(), node
);
2821 // By expanding the node all row indices that are currently in the selection list
2822 // and are greater than our node have become invalid. So we have to correct that now.
2823 const unsigned rowAdjustment
= node
->GetSubTreeCount();
2824 for(unsigned i
=0; i
<m_selection
.size(); ++i
)
2826 const unsigned testRow
= m_selection
[i
];
2827 // all rows above us are not affected, so skip them
2831 m_selection
[i
] += rowAdjustment
;
2834 if(m_currentRow
> row
)
2835 ChangeCurrentRow(m_currentRow
+ rowAdjustment
);
2839 // Send the expanded event
2840 SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED
,node
->GetItem());
2844 void wxDataViewMainWindow::Collapse(unsigned int row
)
2849 wxDataViewTreeNode
*node
= GetTreeNodeByRow(row
);
2853 if (!node
->HasChildren())
2858 if ( !SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING
,node
->GetItem()) )
2860 // Vetoed by the event handler.
2864 // Find out if there are selected items below the current node.
2865 bool selectCollapsingRow
= false;
2866 const unsigned rowAdjustment
= node
->GetSubTreeCount();
2867 unsigned maxRowToBeTested
= row
+ rowAdjustment
;
2868 for(unsigned i
=0; i
<m_selection
.size(); ++i
)
2870 const unsigned testRow
= m_selection
[i
];
2871 if(testRow
> row
&& testRow
<= maxRowToBeTested
)
2873 selectCollapsingRow
= true;
2874 // get out as soon as we have found a node that is selected
2881 // If the node to be closed has selected items the user won't see those any longer.
2882 // We select the collapsing node in this case.
2883 if(selectCollapsingRow
)
2885 SelectAllRows(false);
2886 ChangeCurrentRow(row
);
2887 SelectRow(row
, true);
2888 SendSelectionChangedEvent(GetItemByRow(row
));
2892 // if there were no selected items below our node we still need to "fix" the
2893 // selection list to adjust for the changing of the row indices.
2894 // We actually do the opposite of what we are doing in Expand().
2895 for(unsigned i
=0; i
<m_selection
.size(); ++i
)
2897 const unsigned testRow
= m_selection
[i
];
2898 // all rows above us are not affected, so skip them
2902 m_selection
[i
] -= rowAdjustment
;
2905 // if the "current row" is being collapsed away we change it to the current row ;-)
2906 if(m_currentRow
> row
&& m_currentRow
<= maxRowToBeTested
)
2907 ChangeCurrentRow(row
);
2908 else if(m_currentRow
> row
)
2909 ChangeCurrentRow(m_currentRow
- rowAdjustment
);
2914 SendExpanderEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED
,node
->GetItem());
2918 wxDataViewTreeNode
* wxDataViewMainWindow::FindNode( const wxDataViewItem
& item
)
2920 const wxDataViewModel
* model
= GetOwner()->GetModel();
2927 // Compose the parent-chain for the item we are looking for
2928 wxVector
<wxDataViewItem
> parentChain
;
2929 wxDataViewItem
it( item
);
2932 parentChain
.push_back(it
);
2933 it
= model
->GetParent(it
);
2936 // Find the item along the parent-chain.
2937 // This algorithm is designed to speed up the node-finding method
2938 wxDataViewTreeNode
* node
= m_root
;
2939 for( unsigned iter
= parentChain
.size()-1; ; --iter
)
2941 if( node
->HasChildren() )
2943 if( node
->GetNodes().empty() )
2945 // Even though the item is a container, it doesn't have any
2946 // child nodes in the control's representation yet. We have
2947 // to realize its subtree now.
2949 ::BuildTreeHelper(model
, node
->GetItem(), node
);
2952 const wxDataViewTreeNodes
& nodes
= node
->GetNodes();
2955 for (unsigned i
= 0; i
< nodes
.GetCount(); ++i
)
2957 wxDataViewTreeNode
* currentNode
= nodes
[i
];
2958 if (currentNode
->GetItem() == parentChain
[iter
])
2960 if (currentNode
->GetItem() == item
)
2980 void wxDataViewMainWindow::HitTest( const wxPoint
& point
, wxDataViewItem
& item
,
2981 wxDataViewColumn
* &column
)
2983 wxDataViewColumn
*col
= NULL
;
2984 unsigned int cols
= GetOwner()->GetColumnCount();
2985 unsigned int colnum
= 0;
2987 m_owner
->CalcUnscrolledPosition( point
.x
, point
.y
, &x
, &y
);
2988 for (unsigned x_start
= 0; colnum
< cols
; colnum
++)
2990 col
= GetOwner()->GetColumnAt(colnum
);
2991 if (col
->IsHidden())
2992 continue; // skip it!
2994 unsigned int w
= col
->GetWidth();
2995 if (x_start
+w
>= (unsigned int)x
)
3002 item
= GetItemByRow( GetLineAt( y
) );
3005 wxRect
wxDataViewMainWindow::GetItemRect( const wxDataViewItem
& item
,
3006 const wxDataViewColumn
* column
)
3011 unsigned int cols
= GetOwner()->GetColumnCount();
3012 // If column is null the loop will compute the combined width of all columns.
3013 // Otherwise, it will compute the x position of the column we are looking for.
3014 for (unsigned int i
= 0; i
< cols
; i
++)
3016 wxDataViewColumn
* col
= GetOwner()->GetColumnAt( i
);
3021 if (col
->IsHidden())
3022 continue; // skip it!
3024 xpos
+= col
->GetWidth();
3025 width
+= col
->GetWidth();
3030 // If we have a column, we need can get its width directly.
3031 if(column
->IsHidden())
3034 width
= column
->GetWidth();
3039 // If we have no column, we reset the x position back to zero.
3043 // we have to take an expander column into account and compute its indentation
3044 // to get the correct x position where the actual text is
3046 int row
= GetRowByItem(item
);
3047 if (!IsList() && (column
== 0 || GetOwner()->GetExpanderColumn() == column
) )
3049 wxDataViewTreeNode
* node
= GetTreeNodeByRow(row
);
3050 indent
= GetOwner()->GetIndent() * node
->GetIndentLevel();
3051 indent
= indent
+ m_lineHeight
; // use m_lineHeight as the width of the expander
3054 wxRect
itemRect( xpos
+ indent
,
3055 GetLineStart( row
),
3057 GetLineHeight( row
) );
3059 GetOwner()->CalcScrolledPosition( itemRect
.x
, itemRect
.y
,
3060 &itemRect
.x
, &itemRect
.y
);
3065 int wxDataViewMainWindow::RecalculateCount()
3067 if (IsVirtualList())
3069 wxDataViewVirtualListModel
*list_model
=
3070 (wxDataViewVirtualListModel
*) GetOwner()->GetModel();
3072 return list_model
->GetCount();
3076 return m_root
->GetSubTreeCount();
3080 class ItemToRowJob
: public DoJob
3083 ItemToRowJob(const wxDataViewItem
& item_
, wxVector
<wxDataViewItem
>::reverse_iterator iter
)
3090 // Maybe binary search will help to speed up this process
3091 virtual int operator() ( wxDataViewTreeNode
* node
)
3094 if( node
->GetItem() == item
)
3099 if( node
->GetItem() == *m_iter
)
3106 ret
+= node
->GetSubTreeCount();
3112 // the row number is begin from zero
3113 int GetResult() const
3117 wxVector
<wxDataViewItem
>::reverse_iterator m_iter
;
3118 wxDataViewItem item
;
3123 int wxDataViewMainWindow::GetRowByItem(const wxDataViewItem
& item
) const
3125 const wxDataViewModel
* model
= GetOwner()->GetModel();
3129 if (IsVirtualList())
3131 return wxPtrToUInt( item
.GetID() ) -1;
3138 // Compose the parent-chain of the item we are looking for
3139 wxVector
<wxDataViewItem
> parentChain
;
3140 wxDataViewItem
it( item
);
3143 parentChain
.push_back(it
);
3144 it
= model
->GetParent(it
);
3147 // add an 'invalid' item to represent our 'invisible' root node
3148 parentChain
.push_back(wxDataViewItem());
3150 // the parent chain was created by adding the deepest parent first.
3151 // so if we want to start at the root node, we have to iterate backwards through the vector
3152 ItemToRowJob
job( item
, parentChain
.rbegin() );
3153 Walker( m_root
, job
);
3154 return job
.GetResult();
3158 static void BuildTreeHelper( const wxDataViewModel
* model
, const wxDataViewItem
& item
,
3159 wxDataViewTreeNode
* node
)
3161 if( !model
->IsContainer( item
) )
3164 wxDataViewItemArray children
;
3165 unsigned int num
= model
->GetChildren( item
, children
);
3167 for ( unsigned int index
= 0; index
< num
; index
++ )
3169 wxDataViewTreeNode
*n
= new wxDataViewTreeNode(node
, children
[index
]);
3171 if( model
->IsContainer(children
[index
]) )
3172 n
->SetHasChildren( true );
3177 wxASSERT( node
->IsOpen() );
3178 node
->ChangeSubTreeCount(+num
);
3181 void wxDataViewMainWindow::BuildTree(wxDataViewModel
* model
)
3185 if (GetOwner()->GetModel()->IsVirtualListModel())
3191 m_root
= wxDataViewTreeNode::CreateRootNode();
3193 // First we define a invalid item to fetch the top-level elements
3194 wxDataViewItem item
;
3196 BuildTreeHelper( model
, item
, m_root
);
3200 static void DestroyTreeHelper( wxDataViewTreeNode
* node
)
3202 wxDataViewTreeNodes
& nodes
= node
->GetNodes();
3204 if( !nodes
.empty() )
3206 const int len
= nodes
.size();
3207 for (int i
= 0; i
< len
; i
++)
3208 DestroyTreeHelper(nodes
[i
]);
3213 void wxDataViewMainWindow::DestroyTree()
3215 if (!IsVirtualList())
3217 ::DestroyTreeHelper(m_root
);
3223 void wxDataViewMainWindow::OnChar( wxKeyEvent
&event
)
3225 wxWindow
* const parent
= GetParent();
3227 // propagate the char event upwards
3228 wxKeyEvent
eventForParent(event
);
3229 eventForParent
.SetEventObject(parent
);
3230 if ( parent
->ProcessWindowEvent(eventForParent
) )
3233 if ( parent
->HandleAsNavigationKey(event
) )
3236 // no item -> nothing to do
3237 if (!HasCurrentRow())
3243 // don't use m_linesPerPage directly as it might not be computed yet
3244 const int pageSize
= GetCountPerPage();
3245 wxCHECK_RET( pageSize
, wxT("should have non zero page size") );
3247 switch ( event
.GetKeyCode() )
3251 wxDataViewEvent
le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED
,
3253 le
.SetItem( GetItemByRow(m_currentRow
) );
3254 le
.SetEventObject(parent
);
3255 le
.SetModel(GetOwner()->GetModel());
3257 parent
->GetEventHandler()->ProcessEvent(le
);
3262 if ( m_currentRow
> 0 )
3263 OnArrowChar( m_currentRow
- 1, event
);
3267 if ( m_currentRow
+ 1 < GetRowCount() )
3268 OnArrowChar( m_currentRow
+ 1, event
);
3270 // Add the process for tree expanding/collapsing
3276 wxDataViewTreeNode
* node
= GetTreeNodeByRow(m_currentRow
);
3280 if (node
->HasChildren() && node
->IsOpen())
3282 Collapse(m_currentRow
);
3284 else // if the node is already closed we move the selection to its parent
3286 wxDataViewTreeNode
*parent_node
= node
->GetParent();
3290 int parent
= GetRowByItem( parent_node
->GetItem() );
3293 unsigned int row
= m_currentRow
;
3294 SelectRow( row
, false);
3295 SelectRow( parent
, true );
3296 ChangeCurrentRow( parent
);
3297 GetOwner()->EnsureVisible( parent
, -1 );
3298 SendSelectionChangedEvent( parent_node
->GetItem() );
3306 if (!IsExpanded( m_currentRow
))
3307 Expand( m_currentRow
);
3310 unsigned int row
= m_currentRow
;
3311 SelectRow( row
, false );
3312 SelectRow( row
+ 1, true );
3313 ChangeCurrentRow( row
+ 1 );
3314 GetOwner()->EnsureVisible( row
+ 1, -1 );
3315 SendSelectionChangedEvent( GetItemByRow(row
+1) );
3322 OnArrowChar( GetRowCount() - 1, event
);
3327 OnArrowChar( 0, event
);
3332 int steps
= pageSize
- 1;
3333 int index
= m_currentRow
- steps
;
3337 OnArrowChar( index
, event
);
3343 int steps
= pageSize
- 1;
3344 unsigned int index
= m_currentRow
+ steps
;
3345 unsigned int count
= GetRowCount();
3346 if ( index
>= count
)
3349 OnArrowChar( index
, event
);
3355 if(m_selection
.size() == 1)
3357 // TODO: we need to revise that when we have a concept for a 'current column'
3358 GetOwner()->StartEditor(GetItemByRow(m_selection
[0]), 0);
3368 void wxDataViewMainWindow::OnMouse( wxMouseEvent
&event
)
3370 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
3372 // let the base handle mouse wheel events.
3377 // set the focus to ourself if any of the mouse buttons are pressed
3378 if(event
.ButtonDown() && !HasFocus())
3381 int x
= event
.GetX();
3382 int y
= event
.GetY();
3383 m_owner
->CalcUnscrolledPosition( x
, y
, &x
, &y
);
3384 wxDataViewColumn
*col
= NULL
;
3387 unsigned int cols
= GetOwner()->GetColumnCount();
3389 for (i
= 0; i
< cols
; i
++)
3391 wxDataViewColumn
*c
= GetOwner()->GetColumnAt( i
);
3393 continue; // skip it!
3395 if (x
< xpos
+ c
->GetWidth())
3400 xpos
+= c
->GetWidth();
3408 wxDataViewRenderer
*cell
= col
->GetRenderer();
3409 unsigned int current
= GetLineAt( y
);
3410 if ((current
>= GetRowCount()) || (x
> GetEndOfLastCol()))
3412 // Unselect all if below the last row ?
3417 // Test whether the mouse is hovering over the expander (a.k.a tree "+"
3418 // button) and also determine the offset of the real cell start, skipping
3419 // the indentation and the expander itself.
3420 bool hoverOverExpander
= false;
3421 int expanderOffset
= 0;
3422 if ((!IsList()) && (GetOwner()->GetExpanderColumn() == col
))
3424 wxDataViewTreeNode
* node
= GetTreeNodeByRow(current
);
3425 if( node
!=NULL
&& node
->HasChildren() )
3427 int indent
= node
->GetIndentLevel();
3428 indent
= GetOwner()->GetIndent()*indent
;
3430 // we make the rectangle we are looking in a bit bigger than the actual
3431 // visual expander so the user can hit that little thing reliably
3432 wxRect
rect( xpos
+ indent
,
3433 GetLineStart( current
) + (GetLineHeight(current
) - m_lineHeight
)/2,
3434 m_lineHeight
, m_lineHeight
);
3436 expanderOffset
= indent
+ m_lineHeight
;
3438 if( rect
.Contains(x
, y
) )
3440 // So the mouse is over the expander
3441 hoverOverExpander
= true;
3442 if (m_underMouse
&& m_underMouse
!= node
)
3444 // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
3445 RefreshRow(GetRowByItem(m_underMouse
->GetItem()));
3447 if (m_underMouse
!= node
)
3449 // wxLogMessage("Do the row: %d", current);
3450 RefreshRow(current
);
3452 m_underMouse
= node
;
3456 if (!hoverOverExpander
)
3458 if (m_underMouse
!= NULL
)
3460 // wxLogMessage("Undo the row: %d", GetRowByItem(m_underMouse->GetItem()));
3461 RefreshRow(GetRowByItem(m_underMouse
->GetItem()));
3462 m_underMouse
= NULL
;
3466 wxDataViewModel
*model
= GetOwner()->GetModel();
3468 #if wxUSE_DRAG_AND_DROP
3469 if (event
.Dragging())
3471 if (m_dragCount
== 0)
3473 // we have to report the raw, physical coords as we want to be
3474 // able to call HitTest(event.m_pointDrag) from the user code to
3475 // get the item being dragged
3476 m_dragStart
= event
.GetPosition();
3481 if (m_dragCount
!= 3)
3484 if (event
.LeftIsDown())
3486 m_owner
->CalcUnscrolledPosition( m_dragStart
.x
, m_dragStart
.y
,
3487 &m_dragStart
.x
, &m_dragStart
.y
);
3488 unsigned int drag_item_row
= GetLineAt( m_dragStart
.y
);
3489 wxDataViewItem item
= GetItemByRow( drag_item_row
);
3491 // Notify cell about drag
3492 wxDataViewEvent
event( wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG
, m_owner
->GetId() );
3493 event
.SetEventObject( m_owner
);
3494 event
.SetItem( item
);
3495 event
.SetModel( model
);
3496 if (!m_owner
->HandleWindowEvent( event
))
3499 if (!event
.IsAllowed())
3502 wxDataObject
*obj
= event
.GetDataObject();
3506 wxDataViewDropSource
drag( this, drag_item_row
);
3507 drag
.SetData( *obj
);
3508 /* wxDragResult res = */ drag
.DoDragDrop();
3517 #endif // wxUSE_DRAG_AND_DROP
3519 bool simulateClick
= false;
3521 if (event
.ButtonDClick())
3523 m_renameTimer
->Stop();
3524 m_lastOnSame
= false;
3527 wxDataViewItem item
= GetItemByRow(current
);
3528 bool ignore_other_columns
=
3529 ((GetOwner()->GetExpanderColumn() != col
) &&
3530 (model
->IsContainer(item
)) &&
3531 (!model
->HasContainerColumns(item
)));
3533 if (event
.LeftDClick())
3535 if(hoverOverExpander
)
3537 // a double click on the expander will be converted into a "simulated" normal click
3538 simulateClick
= true;
3540 else if ( current
== m_lineLastClicked
)
3542 if ((!ignore_other_columns
) && (cell
->GetMode() == wxDATAVIEW_CELL_ACTIVATABLE
))
3544 const unsigned colIdx
= col
->GetModelColumn();
3546 cell
->PrepareForItem(model
, item
, colIdx
);
3548 wxRect
cell_rect( xpos
, GetLineStart( current
),
3549 col
->GetWidth(), GetLineHeight( current
) );
3550 cell
->WXOnActivate( cell_rect
, model
, item
, colIdx
);
3554 wxWindow
*parent
= GetParent();
3555 wxDataViewEvent
le(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED
, parent
->GetId());
3557 le
.SetColumn( col
->GetModelColumn() );
3558 le
.SetDataViewColumn( col
);
3559 le
.SetEventObject(parent
);
3560 le
.SetModel(GetOwner()->GetModel());
3562 parent
->GetEventHandler()->ProcessEvent(le
);
3568 // The first click was on another item, so don't interpret this as
3569 // a double click, but as a simple click instead
3570 simulateClick
= true;
3574 if (event
.LeftUp() && !hoverOverExpander
)
3576 if (m_lineSelectSingleOnUp
!= (unsigned int)-1)
3578 // select single line
3579 SelectAllRows( false );
3580 SelectRow( m_lineSelectSingleOnUp
, true );
3581 SendSelectionChangedEvent( GetItemByRow(m_lineSelectSingleOnUp
) );
3584 // If the user click the expander, we do not do editing even if the column
3585 // with expander are editable
3586 if (m_lastOnSame
&& !ignore_other_columns
)
3588 if ((col
== m_currentCol
) && (current
== m_currentRow
) &&
3589 (cell
->GetMode() & wxDATAVIEW_CELL_EDITABLE
) )
3591 m_renameTimer
->Start( 100, true );
3595 m_lastOnSame
= false;
3596 m_lineSelectSingleOnUp
= (unsigned int)-1;
3598 else if(!event
.LeftUp())
3600 // This is necessary, because after a DnD operation in
3601 // from and to ourself, the up event is swallowed by the
3602 // DnD code. So on next non-up event (which means here and
3603 // now) m_lineSelectSingleOnUp should be reset.
3604 m_lineSelectSingleOnUp
= (unsigned int)-1;
3607 if (event
.RightDown())
3609 m_lineBeforeLastClicked
= m_lineLastClicked
;
3610 m_lineLastClicked
= current
;
3612 // If the item is already selected, do not update the selection.
3613 // Multi-selections should not be cleared if a selected item is clicked.
3614 if (!IsRowSelected(current
))
3616 SelectAllRows(false);
3617 const unsigned oldCurrent
= m_currentRow
;
3618 ChangeCurrentRow(current
);
3619 SelectRow(m_currentRow
,true);
3620 RefreshRow(oldCurrent
);
3621 SendSelectionChangedEvent(GetItemByRow( m_currentRow
) );
3624 else if (event
.RightUp())
3627 model
->GetValue( value
, item
, col
->GetModelColumn() );
3628 wxWindow
*parent
= GetParent();
3629 wxDataViewEvent
le(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU
, parent
->GetId());
3631 le
.SetColumn( col
->GetModelColumn() );
3632 le
.SetDataViewColumn( col
);
3633 le
.SetEventObject(parent
);
3634 le
.SetModel(GetOwner()->GetModel());
3636 parent
->GetEventHandler()->ProcessEvent(le
);
3638 else if (event
.MiddleDown())
3642 if((event
.LeftDown() || simulateClick
) && hoverOverExpander
)
3644 wxDataViewTreeNode
* node
= GetTreeNodeByRow(current
);
3646 // hoverOverExpander being true tells us that our node must be
3647 // valid and have children.
3648 // So we don't need any extra checks.
3649 if( node
->IsOpen() )
3654 else if ((event
.LeftDown() || simulateClick
) && !hoverOverExpander
)
3656 m_lineBeforeLastClicked
= m_lineLastClicked
;
3657 m_lineLastClicked
= current
;
3659 unsigned int oldCurrentRow
= m_currentRow
;
3660 bool oldWasSelected
= IsRowSelected(m_currentRow
);
3662 bool cmdModifierDown
= event
.CmdDown();
3663 if ( IsSingleSel() || !(cmdModifierDown
|| event
.ShiftDown()) )
3665 if ( IsSingleSel() || !IsRowSelected(current
) )
3667 SelectAllRows( false );
3668 ChangeCurrentRow(current
);
3669 SelectRow(m_currentRow
,true);
3670 SendSelectionChangedEvent(GetItemByRow( m_currentRow
) );
3672 else // multi sel & current is highlighted & no mod keys
3674 m_lineSelectSingleOnUp
= current
;
3675 ChangeCurrentRow(current
); // change focus
3678 else // multi sel & either ctrl or shift is down
3680 if (cmdModifierDown
)
3682 ChangeCurrentRow(current
);
3683 ReverseRowSelection(m_currentRow
);
3684 SendSelectionChangedEvent(GetItemByRow(m_currentRow
));
3686 else if (event
.ShiftDown())
3688 ChangeCurrentRow(current
);
3690 unsigned int lineFrom
= oldCurrentRow
,
3693 if ( lineTo
< lineFrom
)
3696 lineFrom
= m_currentRow
;
3699 SelectRows(lineFrom
, lineTo
, true);
3700 SendSelectionChangedEvent(GetItemByRow(m_selection
[0]) );
3702 else // !ctrl, !shift
3704 // test in the enclosing if should make it impossible
3705 wxFAIL_MSG( wxT("how did we get here?") );
3709 if (m_currentRow
!= oldCurrentRow
)
3710 RefreshRow( oldCurrentRow
);
3712 wxDataViewColumn
*oldCurrentCol
= m_currentCol
;
3714 // Update selection here...
3717 m_lastOnSame
= !simulateClick
&& ((col
== oldCurrentCol
) &&
3718 (current
== oldCurrentRow
)) && oldWasSelected
;
3720 // Call LeftClick after everything else as under GTK+
3721 if (cell
->GetMode() & wxDATAVIEW_CELL_ACTIVATABLE
)
3723 // notify cell about click
3724 cell
->PrepareForItem(model
, item
, col
->GetModelColumn());
3726 wxRect
cell_rect( xpos
+ expanderOffset
,
3727 GetLineStart( current
),
3728 col
->GetWidth() - expanderOffset
,
3729 GetLineHeight( current
) );
3731 // Report position relative to the cell's custom area, i.e.
3732 // no the entire space as given by the control but the one
3733 // used by the renderer after calculation of alignment etc.
3735 // adjust the rectangle ourselves to account for the alignment
3736 wxRect rectItem
= cell_rect
;
3737 const int align
= cell
->GetAlignment();
3738 if ( align
!= wxDVR_DEFAULT_ALIGNMENT
)
3740 const wxSize size
= cell
->GetSize();
3742 if ( size
.x
>= 0 && size
.x
< cell_rect
.width
)
3744 if ( align
& wxALIGN_CENTER_HORIZONTAL
)
3745 rectItem
.x
+= (cell_rect
.width
- size
.x
)/2;
3746 else if ( align
& wxALIGN_RIGHT
)
3747 rectItem
.x
+= cell_rect
.width
- size
.x
;
3748 // else: wxALIGN_LEFT is the default
3751 if ( size
.y
>= 0 && size
.y
< cell_rect
.height
)
3753 if ( align
& wxALIGN_CENTER_VERTICAL
)
3754 rectItem
.y
+= (cell_rect
.height
- size
.y
)/2;
3755 else if ( align
& wxALIGN_BOTTOM
)
3756 rectItem
.y
+= cell_rect
.height
- size
.y
;
3757 // else: wxALIGN_TOP is the default
3761 wxPoint
pos( event
.GetPosition() );
3762 pos
.x
-= rectItem
.x
;
3763 pos
.y
-= rectItem
.y
;
3765 m_owner
->CalcUnscrolledPosition( pos
.x
, pos
.y
, &pos
.x
, &pos
.y
);
3767 /* ignore ret */ cell
->WXOnLeftClick( pos
, cell_rect
,
3768 model
, item
, col
->GetModelColumn());
3773 void wxDataViewMainWindow::OnSetFocus( wxFocusEvent
&event
)
3777 if (HasCurrentRow())
3783 void wxDataViewMainWindow::OnKillFocus( wxFocusEvent
&event
)
3787 if (HasCurrentRow())
3793 //-----------------------------------------------------------------------------
3795 //-----------------------------------------------------------------------------
3797 WX_DEFINE_LIST(wxDataViewColumnList
)
3799 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl
, wxDataViewCtrlBase
)
3800 BEGIN_EVENT_TABLE(wxDataViewCtrl
, wxDataViewCtrlBase
)
3801 EVT_SIZE(wxDataViewCtrl::OnSize
)
3804 wxDataViewCtrl::~wxDataViewCtrl()
3807 GetModel()->RemoveNotifier( m_notifier
);
3810 m_colsBestWidths
.clear();
3813 void wxDataViewCtrl::Init()
3815 m_cols
.DeleteContents(true);
3818 // No sorting column at start
3819 m_sortingColumnIdx
= wxNOT_FOUND
;
3821 m_headerArea
= NULL
;
3824 bool wxDataViewCtrl::Create(wxWindow
*parent
,
3829 const wxValidator
& validator
,
3830 const wxString
& name
)
3832 // if ( (style & wxBORDER_MASK) == 0)
3833 // style |= wxBORDER_SUNKEN;
3837 if (!wxControl::Create( parent
, id
, pos
, size
,
3838 style
| wxScrolledWindowStyle
, validator
, name
))
3841 SetInitialSize(size
);
3844 MacSetClipChildren( true );
3847 m_clientArea
= new wxDataViewMainWindow( this, wxID_ANY
);
3849 // We use the cursor keys for moving the selection, not scrolling, so call
3850 // this method to ensure wxScrollHelperEvtHandler doesn't catch all
3851 // keyboard events forwarded to us from wxListMainWindow.
3852 DisableKeyboardScrolling();
3854 if (HasFlag(wxDV_NO_HEADER
))
3855 m_headerArea
= NULL
;
3857 m_headerArea
= new wxDataViewHeaderWindow(this);
3859 SetTargetWindow( m_clientArea
);
3861 wxBoxSizer
*sizer
= new wxBoxSizer( wxVERTICAL
);
3863 sizer
->Add( m_headerArea
, 0, wxGROW
);
3864 sizer
->Add( m_clientArea
, 1, wxGROW
);
3870 wxBorder
wxDataViewCtrl::GetDefaultBorder() const
3872 return wxBORDER_THEME
;
3876 WXLRESULT
wxDataViewCtrl::MSWWindowProc(WXUINT nMsg
,
3880 WXLRESULT rc
= wxDataViewCtrlBase::MSWWindowProc(nMsg
, wParam
, lParam
);
3883 // we need to process arrows ourselves for scrolling
3884 if ( nMsg
== WM_GETDLGCODE
)
3886 rc
|= DLGC_WANTARROWS
;
3894 wxSize
wxDataViewCtrl::GetSizeAvailableForScrollTarget(const wxSize
& size
)
3896 wxSize newsize
= size
;
3897 if (!HasFlag(wxDV_NO_HEADER
) && (m_headerArea
))
3898 newsize
.y
-= m_headerArea
->GetSize().y
;
3903 void wxDataViewCtrl::OnSize( wxSizeEvent
&WXUNUSED(event
) )
3905 // We need to override OnSize so that our scrolled
3906 // window a) does call Layout() to use sizers for
3907 // positioning the controls but b) does not query
3908 // the sizer for their size and use that for setting
3909 // the scrollable area as set that ourselves by
3910 // calling SetScrollbar() further down.
3916 // We must redraw the headers if their height changed. Normally this
3917 // shouldn't happen as the control shouldn't let itself be resized beneath
3918 // its minimal height but avoid the display artefacts that appear if it
3919 // does happen, e.g. because there is really not enough vertical space.
3920 if ( !HasFlag(wxDV_NO_HEADER
) && m_headerArea
&&
3921 m_headerArea
->GetSize().y
<= m_headerArea
->GetBestSize(). y
)
3923 m_headerArea
->Refresh();
3927 void wxDataViewCtrl::SetFocus()
3930 m_clientArea
->SetFocus();
3933 bool wxDataViewCtrl::AssociateModel( wxDataViewModel
*model
)
3935 if (!wxDataViewCtrlBase::AssociateModel( model
))
3938 m_notifier
= new wxGenericDataViewModelNotifier( m_clientArea
);
3940 model
->AddNotifier( m_notifier
);
3942 m_clientArea
->DestroyTree();
3944 m_clientArea
->BuildTree(model
);
3946 m_clientArea
->UpdateDisplay();
3951 #if wxUSE_DRAG_AND_DROP
3953 bool wxDataViewCtrl::EnableDragSource( const wxDataFormat
&format
)
3955 return m_clientArea
->EnableDragSource( format
);
3958 bool wxDataViewCtrl::EnableDropTarget( const wxDataFormat
&format
)
3960 return m_clientArea
->EnableDropTarget( format
);
3963 #endif // wxUSE_DRAG_AND_DROP
3965 bool wxDataViewCtrl::AppendColumn( wxDataViewColumn
*col
)
3967 if (!wxDataViewCtrlBase::AppendColumn(col
))
3970 m_cols
.Append( col
);
3971 m_colsBestWidths
.push_back(0);
3972 OnColumnsCountChanged();
3976 bool wxDataViewCtrl::PrependColumn( wxDataViewColumn
*col
)
3978 if (!wxDataViewCtrlBase::PrependColumn(col
))
3981 m_cols
.Insert( col
);
3982 m_colsBestWidths
.insert(m_colsBestWidths
.begin(), 0);
3983 OnColumnsCountChanged();
3987 bool wxDataViewCtrl::InsertColumn( unsigned int pos
, wxDataViewColumn
*col
)
3989 if (!wxDataViewCtrlBase::InsertColumn(pos
,col
))
3992 m_cols
.Insert( pos
, col
);
3993 m_colsBestWidths
.insert(m_colsBestWidths
.begin() + pos
, 0);
3994 OnColumnsCountChanged();
3998 void wxDataViewCtrl::OnColumnChange(unsigned int idx
)
4001 m_headerArea
->UpdateColumn(idx
);
4003 m_clientArea
->UpdateDisplay();
4006 void wxDataViewCtrl::OnColumnsCountChanged()
4009 m_headerArea
->SetColumnCount(GetColumnCount());
4011 m_clientArea
->UpdateDisplay();
4014 void wxDataViewCtrl::DoSetExpanderColumn()
4016 m_clientArea
->UpdateDisplay();
4019 void wxDataViewCtrl::DoSetIndent()
4021 m_clientArea
->UpdateDisplay();
4024 unsigned int wxDataViewCtrl::GetColumnCount() const
4026 return m_cols
.GetCount();
4029 bool wxDataViewCtrl::SetRowHeight( int lineHeight
)
4031 if ( !m_clientArea
)
4034 m_clientArea
->SetRowHeight(lineHeight
);
4039 wxDataViewColumn
* wxDataViewCtrl::GetColumn( unsigned int idx
) const
4044 wxDataViewColumn
*wxDataViewCtrl::GetColumnAt(unsigned int pos
) const
4046 // columns can't be reordered if there is no header window which allows
4048 const unsigned idx
= m_headerArea
? m_headerArea
->GetColumnsOrder()[pos
]
4051 return GetColumn(idx
);
4054 int wxDataViewCtrl::GetColumnIndex(const wxDataViewColumn
*column
) const
4056 const unsigned count
= m_cols
.size();
4057 for ( unsigned n
= 0; n
< count
; n
++ )
4059 if ( m_cols
[n
] == column
)
4066 unsigned int wxDataViewCtrl::GetBestColumnWidth(int idx
) const
4068 if ( m_colsBestWidths
[idx
] != 0 )
4069 return m_colsBestWidths
[idx
];
4071 const int count
= m_clientArea
->GetRowCount();
4072 wxDataViewColumn
*column
= GetColumn(idx
);
4073 wxDataViewRenderer
*renderer
=
4074 const_cast<wxDataViewRenderer
*>(column
->GetRenderer());
4076 class MaxWidthCalculator
4079 MaxWidthCalculator(wxDataViewMainWindow
*clientArea
,
4080 wxDataViewRenderer
*renderer
,
4081 const wxDataViewModel
*model
,
4084 m_clientArea(clientArea
),
4085 m_renderer(renderer
),
4091 void UpdateWithWidth(int width
)
4093 m_width
= wxMax(m_width
, width
);
4096 void UpdateWithRow(int row
)
4098 wxDataViewItem item
= m_clientArea
->GetItemByRow(row
);
4099 m_renderer
->PrepareForItem(m_model
, item
, m_column
);
4100 m_width
= wxMax(m_width
, m_renderer
->GetSize().x
);
4103 int GetMaxWidth() const { return m_width
; }
4107 wxDataViewMainWindow
*m_clientArea
;
4108 wxDataViewRenderer
*m_renderer
;
4109 const wxDataViewModel
*m_model
;
4113 MaxWidthCalculator
calculator(m_clientArea
, renderer
,
4114 GetModel(), column
->GetModelColumn());
4118 int header_width
= m_headerArea
->GetTextExtent(column
->GetTitle()).x
;
4119 // Labels on native MSW header are indented on both sides
4121 wxRendererNative::Get().GetHeaderButtonMargin(m_headerArea
);
4122 calculator
.UpdateWithWidth(header_width
);
4125 // The code below deserves some explanation. For very large controls, we
4126 // simply can't afford to calculate sizes for all items, it takes too
4127 // long. So the best we can do is to check the first and the last N/2
4128 // items in the control for some sufficiently large N and calculate best
4129 // sizes from that. That can result in the calculated best width being too
4130 // small for some outliers, but it's better to get slightly imperfect
4131 // result than to wait several seconds after every update. To avoid highly
4132 // visible miscalculations, we also include all currently visible items
4133 // no matter what. Finally, the value of N is determined dynamically by
4134 // measuring how much time we spent on the determining item widths so far.
4137 int top_part_end
= count
;
4138 static const long CALC_TIMEOUT
= 20/*ms*/;
4139 // don't call wxStopWatch::Time() too often
4140 static const unsigned CALC_CHECK_FREQ
= 100;
4143 // use some hard-coded limit, that's the best we can do without timer
4144 int top_part_end
= wxMin(500, count
);
4145 #endif // wxUSE_STOPWATCH/!wxUSE_STOPWATCH
4149 for ( row
= 0; row
< top_part_end
; row
++ )
4152 if ( row
% CALC_CHECK_FREQ
== CALC_CHECK_FREQ
-1 &&
4153 timer
.Time() > CALC_TIMEOUT
)
4155 #endif // wxUSE_STOPWATCH
4156 calculator
.UpdateWithRow(row
);
4159 // row is the first unmeasured item now; that's our value of N/2
4165 // add bottom N/2 items now:
4166 const int bottom_part_start
= wxMax(row
, count
- row
);
4167 for ( row
= bottom_part_start
; row
< count
; row
++ )
4169 calculator
.UpdateWithRow(row
);
4172 // finally, include currently visible items in the calculation:
4173 const wxPoint origin
= CalcUnscrolledPosition(wxPoint(0, 0));
4174 int first_visible
= m_clientArea
->GetLineAt(origin
.y
);
4175 int last_visible
= m_clientArea
->GetLineAt(origin
.y
+ GetClientSize().y
);
4177 first_visible
= wxMax(first_visible
, top_part_end
);
4178 last_visible
= wxMin(bottom_part_start
, last_visible
);
4180 for ( row
= first_visible
; row
< last_visible
; row
++ )
4182 calculator
.UpdateWithRow(row
);
4185 wxLogTrace("dataview",
4186 "determined best size from %d top, %d bottom plus %d more visible items out of %d total",
4188 count
- bottom_part_start
,
4189 wxMax(0, last_visible
- first_visible
),
4193 int max_width
= calculator
.GetMaxWidth();
4194 if ( max_width
> 0 )
4195 max_width
+= 2 * PADDING_RIGHTLEFT
;
4197 const_cast<wxDataViewCtrl
*>(this)->m_colsBestWidths
[idx
] = max_width
;
4201 void wxDataViewCtrl::ColumnMoved(wxDataViewColumn
* WXUNUSED(col
),
4202 unsigned int WXUNUSED(new_pos
))
4204 // do _not_ reorder m_cols elements here, they should always be in the
4205 // order in which columns were added, we only display the columns in
4207 m_clientArea
->UpdateDisplay();
4210 bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn
*column
)
4212 wxDataViewColumnList::compatibility_iterator ret
= m_cols
.Find( column
);
4216 m_colsBestWidths
.erase(m_colsBestWidths
.begin() + GetColumnIndex(column
));
4218 OnColumnsCountChanged();
4223 bool wxDataViewCtrl::ClearColumns()
4226 m_colsBestWidths
.clear();
4227 OnColumnsCountChanged();
4231 void wxDataViewCtrl::UpdateColBestWidth(int idx
)
4233 m_colsBestWidths
[idx
] = 0;
4236 m_headerArea
->UpdateColumn(idx
);
4239 void wxDataViewCtrl::UpdateColBestWidths()
4241 m_colsBestWidths
.clear();
4242 m_colsBestWidths
.resize(m_cols
.size());
4246 const unsigned cols
= m_headerArea
->GetColumnCount();
4247 for ( unsigned i
= 0; i
< cols
; i
++ )
4248 m_headerArea
->UpdateColumn(i
);
4252 int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn
*column
) const
4255 unsigned int len
= GetColumnCount();
4256 for ( unsigned int i
= 0; i
< len
; i
++ )
4258 wxDataViewColumn
* col
= GetColumnAt(i
);
4265 // This returns the position in pixels which is not what we want.
4268 unsigned int len
= GetColumnCount();
4269 for ( unsigned int i
= 0; i
< len
; i
++ )
4271 wxDataViewColumn
* col
= GetColumnAt(i
);
4272 if (col
->IsHidden())
4274 ret
+= col
->GetWidth();
4277 CalcScrolledPosition( ret
, dummy
, &ret
, &dummy
);
4285 wxDataViewColumn
*wxDataViewCtrl::GetSortingColumn() const
4287 return m_sortingColumnIdx
== wxNOT_FOUND
? NULL
4288 : GetColumn(m_sortingColumnIdx
);
4291 wxDataViewItem
wxDataViewCtrl::DoGetCurrentItem() const
4293 return GetItemByRow(m_clientArea
->GetCurrentRow());
4296 void wxDataViewCtrl::DoSetCurrentItem(const wxDataViewItem
& item
)
4298 const int row
= m_clientArea
->GetRowByItem(item
);
4300 const unsigned oldCurrent
= m_clientArea
->GetCurrentRow();
4301 if ( static_cast<unsigned>(row
) != oldCurrent
)
4303 m_clientArea
->ChangeCurrentRow(row
);
4304 m_clientArea
->RefreshRow(oldCurrent
);
4305 m_clientArea
->RefreshRow(row
);
4309 int wxDataViewCtrl::GetSelectedItemsCount() const
4311 return m_clientArea
->GetSelections().size();
4314 int wxDataViewCtrl::GetSelections( wxDataViewItemArray
& sel
) const
4317 const wxDataViewSelection
& selections
= m_clientArea
->GetSelections();
4319 const size_t len
= selections
.size();
4320 for ( size_t i
= 0; i
< len
; i
++ )
4322 wxDataViewItem item
= m_clientArea
->GetItemByRow(selections
[i
]);
4329 wxFAIL_MSG( "invalid item in selection - bad internal state" );
4336 void wxDataViewCtrl::SetSelections( const wxDataViewItemArray
& sel
)
4338 wxDataViewSelection
selection(wxDataViewSelectionCmp
);
4340 wxDataViewItem last_parent
;
4342 int len
= sel
.GetCount();
4343 for( int i
= 0; i
< len
; i
++ )
4345 wxDataViewItem item
= sel
[i
];
4346 wxDataViewItem parent
= GetModel()->GetParent( item
);
4349 if (parent
!= last_parent
)
4350 ExpandAncestors(item
);
4353 last_parent
= parent
;
4354 int row
= m_clientArea
->GetRowByItem( item
);
4356 selection
.Add( static_cast<unsigned int>(row
) );
4359 m_clientArea
->SetSelections( selection
);
4362 void wxDataViewCtrl::Select( const wxDataViewItem
& item
)
4364 ExpandAncestors( item
);
4366 int row
= m_clientArea
->GetRowByItem( item
);
4369 // Unselect all rows before select another in the single select mode
4370 if (m_clientArea
->IsSingleSel())
4371 m_clientArea
->SelectAllRows(false);
4373 m_clientArea
->SelectRow(row
, true);
4375 // Also set focus to the selected item
4376 m_clientArea
->ChangeCurrentRow( row
);
4380 void wxDataViewCtrl::Unselect( const wxDataViewItem
& item
)
4382 int row
= m_clientArea
->GetRowByItem( item
);
4384 m_clientArea
->SelectRow(row
, false);
4387 bool wxDataViewCtrl::IsSelected( const wxDataViewItem
& item
) const
4389 int row
= m_clientArea
->GetRowByItem( item
);
4392 return m_clientArea
->IsRowSelected(row
);
4397 void wxDataViewCtrl::SelectAll()
4399 m_clientArea
->SelectAllRows(true);
4402 void wxDataViewCtrl::UnselectAll()
4404 m_clientArea
->SelectAllRows(false);
4407 void wxDataViewCtrl::EnsureVisible( int row
, int column
)
4411 if( row
> (int) m_clientArea
->GetRowCount() )
4412 row
= m_clientArea
->GetRowCount();
4414 int first
= m_clientArea
->GetFirstVisibleRow();
4415 int last
= m_clientArea
->GetLastVisibleRow();
4417 m_clientArea
->ScrollTo( row
, column
);
4418 else if( row
> last
)
4419 m_clientArea
->ScrollTo( row
- last
+ first
, column
);
4421 m_clientArea
->ScrollTo( first
, column
);
4424 void wxDataViewCtrl::EnsureVisible( const wxDataViewItem
& item
, const wxDataViewColumn
* column
)
4426 ExpandAncestors( item
);
4428 m_clientArea
->RecalculateDisplay();
4430 int row
= m_clientArea
->GetRowByItem(item
);
4433 if( column
== NULL
)
4434 EnsureVisible(row
, -1);
4436 EnsureVisible( row
, GetColumnIndex(column
) );
4441 void wxDataViewCtrl::HitTest( const wxPoint
& point
, wxDataViewItem
& item
,
4442 wxDataViewColumn
* &column
) const
4444 m_clientArea
->HitTest(point
, item
, column
);
4447 wxRect
wxDataViewCtrl::GetItemRect( const wxDataViewItem
& item
,
4448 const wxDataViewColumn
* column
) const
4450 return m_clientArea
->GetItemRect(item
, column
);
4453 wxDataViewItem
wxDataViewCtrl::GetItemByRow( unsigned int row
) const
4455 return m_clientArea
->GetItemByRow( row
);
4458 int wxDataViewCtrl::GetRowByItem( const wxDataViewItem
& item
) const
4460 return m_clientArea
->GetRowByItem( item
);
4463 void wxDataViewCtrl::Expand( const wxDataViewItem
& item
)
4465 ExpandAncestors( item
);
4467 int row
= m_clientArea
->GetRowByItem( item
);
4469 m_clientArea
->Expand(row
);
4472 void wxDataViewCtrl::Collapse( const wxDataViewItem
& item
)
4474 int row
= m_clientArea
->GetRowByItem( item
);
4476 m_clientArea
->Collapse(row
);
4479 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem
& item
) const
4481 int row
= m_clientArea
->GetRowByItem( item
);
4483 return m_clientArea
->IsExpanded(row
);
4487 void wxDataViewCtrl::StartEditor( const wxDataViewItem
& item
, unsigned int column
)
4489 wxDataViewColumn
* col
= GetColumn( column
);
4493 wxRect itemRect
= GetItemRect(item
, col
);
4494 wxDataViewRenderer
* renderer
= col
->GetRenderer();
4495 if (renderer
->GetMode() == wxDATAVIEW_CELL_EDITABLE
)
4496 renderer
->StartEditing(item
, itemRect
);
4499 #endif // !wxUSE_GENERICDATAVIEWCTRL
4501 #endif // wxUSE_DATAVIEWCTRL