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