]> git.saurik.com Git - wxWidgets.git/blob - wxPython/contrib/gizmos/wxCode/src/treelistctrl.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove debug code.
[wxWidgets.git] / wxPython / contrib / gizmos / wxCode / src / treelistctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: treelistctrl.cpp
3 // Purpose: multi column tree control implementation
4 // Author: Robert Roebling
5 // Maintainer: Otto Wyss
6 // Created: 01/02/97
7 // RCS-ID: $Id$
8 // Copyright: (c) 2004 Robert Roebling, Julian Smart, Alberto Griggio,
9 // Vadim Zeitlin, Otto Wyss
10 // Licence: wxWindows
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ===========================================================================
14 // declarations
15 // ===========================================================================
16
17 // ---------------------------------------------------------------------------
18 // headers
19 // ---------------------------------------------------------------------------
20
21 #if defined(__GNUG__) && !defined(__APPLE__)
22 #pragma implementation "treelistctrl.h"
23 #endif
24
25 // For compilers that support precompilation, includes "wx.h".
26 #include "wx/wxprec.h"
27
28 #ifdef __BORLANDC__
29 #pragma hdrstop
30 #endif
31
32
33 #include <wx/treebase.h>
34 #include <wx/timer.h>
35 #include <wx/textctrl.h>
36 #include <wx/imaglist.h>
37 #include <wx/settings.h>
38 #include <wx/dcclient.h>
39 #include <wx/dcscreen.h>
40 #include <wx/scrolwin.h>
41 #if wxCHECK_VERSION(2, 7, 0)
42 #include <wx/renderer.h>
43 #endif
44
45 #ifdef __WXMAC__
46 #include "wx/mac/private.h"
47 #endif
48
49 #include "wx/treelistctrl.h"
50
51
52 // ---------------------------------------------------------------------------
53 // array types
54 // ---------------------------------------------------------------------------
55
56 class wxTreeListItem;
57
58 #if !wxCHECK_VERSION(2, 5, 0)
59 WX_DEFINE_ARRAY(wxTreeListItem *, wxArrayTreeListItems);
60 #else
61 WX_DEFINE_ARRAY_PTR(wxTreeListItem *, wxArrayTreeListItems);
62 #endif
63
64 #include <wx/dynarray.h>
65 WX_DECLARE_OBJARRAY(wxTreeListColumnInfo, wxArrayTreeListColumnInfo);
66 #include <wx/arrimpl.cpp>
67 WX_DEFINE_OBJARRAY(wxArrayTreeListColumnInfo);
68
69
70 // --------------------------------------------------------------------------
71 // constants
72 // --------------------------------------------------------------------------
73
74 static const int NO_IMAGE = -1;
75
76 static const int LINEHEIGHT = 10;
77 static const int LINEATROOT = 5;
78 static const int MARGIN = 2;
79 static const int MININDENT = 16;
80 static const int BTNWIDTH = 9;
81 static const int BTNHEIGHT = 9;
82 static const int EXTRA_WIDTH = 4;
83 static const int EXTRA_HEIGHT = 4;
84 static const int HEADER_OFFSET_X = 1;
85 static const int HEADER_OFFSET_Y = 1;
86
87 static const int DRAG_TIMER_TICKS = 250; // minimum drag wait time in ms
88 static const int FIND_TIMER_TICKS = 500; // minimum find wait time in ms
89 static const int RENAME_TIMER_TICKS = 250; // minimum rename wait time in ms
90
91 const wxChar* wxTreeListCtrlNameStr = _T("treelistctrl");
92
93 static wxTreeListColumnInfo wxInvalidTreeListColumnInfo;
94
95
96 // ---------------------------------------------------------------------------
97 // private classes
98 // ---------------------------------------------------------------------------
99 //-----------------------------------------------------------------------------
100 // wxTreeListHeaderWindow (internal)
101 //-----------------------------------------------------------------------------
102
103 class wxTreeListHeaderWindow : public wxWindow
104 {
105 protected:
106 wxTreeListMainWindow *m_owner;
107 const wxCursor *m_currentCursor;
108 const wxCursor *m_resizeCursor;
109 bool m_isDragging;
110
111 // column being resized
112 int m_column;
113
114 // divider line position in logical (unscrolled) coords
115 int m_currentX;
116
117 // minimal position beyond which the divider line can't be dragged in
118 // logical coords
119 int m_minX;
120
121 wxArrayTreeListColumnInfo m_columns;
122
123 // total width of the columns
124 int m_total_col_width;
125
126 #if wxCHECK_VERSION_FULL(2, 7, 0, 1)
127 // which col header is currently highlighted with mouse-over
128 int m_hotTrackCol;
129
130 int XToCol(int x);
131 void RefreshColLabel(int col);
132 #endif
133
134 public:
135 wxTreeListHeaderWindow();
136
137 wxTreeListHeaderWindow( wxWindow *win,
138 wxWindowID id,
139 wxTreeListMainWindow *owner,
140 const wxPoint &pos = wxDefaultPosition,
141 const wxSize &size = wxDefaultSize,
142 long style = 0,
143 const wxString &name = _T("wxtreelistctrlcolumntitles") );
144
145 virtual ~wxTreeListHeaderWindow();
146
147 void DoDrawRect( wxDC *dc, int x, int y, int w, int h );
148 void DrawCurrent();
149 void AdjustDC(wxDC& dc);
150
151 void OnPaint( wxPaintEvent &event );
152 void OnMouse( wxMouseEvent &event );
153 void OnSetFocus( wxFocusEvent &event );
154
155 // total width of all columns
156 int GetWidth() const { return m_total_col_width; }
157
158 // column manipulation
159 int GetColumnCount() const { return m_columns.GetCount(); }
160
161 void AddColumn (const wxTreeListColumnInfo& colInfo);
162
163 void InsertColumn (int before, const wxTreeListColumnInfo& colInfo);
164
165 void RemoveColumn (int column);
166
167 // column information manipulation
168 const wxTreeListColumnInfo& GetColumn (int column) const{
169 wxCHECK_MSG ((column >= 0) && (column < GetColumnCount()),
170 wxInvalidTreeListColumnInfo, _T("Invalid column"));
171 return m_columns[column];
172 }
173 wxTreeListColumnInfo& GetColumn (int column) {
174 wxCHECK_MSG ((column >= 0) && (column < GetColumnCount()),
175 wxInvalidTreeListColumnInfo, _T("Invalid column"));
176 return m_columns[column];
177 }
178 void SetColumn (int column, const wxTreeListColumnInfo& info);
179
180 wxString GetColumnText (int column) const {
181 wxCHECK_MSG ((column >= 0) && (column < GetColumnCount()),
182 wxEmptyString, _T("Invalid column"));
183 return m_columns[column].GetText();
184 }
185 void SetColumnText (int column, const wxString& text) {
186 wxCHECK_RET ((column >= 0) && (column < GetColumnCount()),
187 _T("Invalid column"));
188 m_columns[column].SetText (text);
189 }
190
191 int GetColumnAlignment (int column) const {
192 wxCHECK_MSG ((column >= 0) && (column < GetColumnCount()),
193 wxALIGN_LEFT, _T("Invalid column"));
194 return m_columns[column].GetAlignment();
195 }
196 void SetColumnAlignment (int column, int flag) {
197 wxCHECK_RET ((column >= 0) && (column < GetColumnCount()),
198 _T("Invalid column"));
199 m_columns[column].SetAlignment (flag);
200 }
201
202 int GetColumnWidth (int column) const {
203 wxCHECK_MSG ((column >= 0) && (column < GetColumnCount()),
204 -1, _T("Invalid column"));
205 return m_columns[column].GetWidth();
206 }
207 void SetColumnWidth (int column, int width);
208
209 bool IsColumnEditable (int column) const {
210 wxCHECK_MSG ((column >= 0) && (column < GetColumnCount()),
211 false, _T("Invalid column"));
212 return m_columns[column].IsEditable();
213 }
214
215 bool IsColumnShown (int column) const {
216 wxCHECK_MSG ((column >= 0) && (column < GetColumnCount()),
217 true, _T("Invalid column"));
218 return m_columns[column].IsShown();
219 }
220
221 // needs refresh
222 bool m_dirty;
223
224 private:
225 // common part of all ctors
226 void Init();
227
228 void SendListEvent(wxEventType type, wxPoint pos);
229
230 DECLARE_DYNAMIC_CLASS(wxTreeListHeaderWindow)
231 DECLARE_EVENT_TABLE()
232 };
233
234
235 // this is the "true" control
236 class wxTreeListMainWindow: public wxScrolledWindow
237 {
238 public:
239 // creation
240 // --------
241 wxTreeListMainWindow() { Init(); }
242
243 wxTreeListMainWindow (wxTreeListCtrl *parent, wxWindowID id = -1,
244 const wxPoint& pos = wxDefaultPosition,
245 const wxSize& size = wxDefaultSize,
246 long style = wxTR_DEFAULT_STYLE,
247 const wxValidator &validator = wxDefaultValidator,
248 const wxString& name = _T("wxtreelistmainwindow"))
249 {
250 Init();
251 Create (parent, id, pos, size, style, validator, name);
252 }
253
254 virtual ~wxTreeListMainWindow();
255
256 bool Create(wxTreeListCtrl *parent, wxWindowID id = -1,
257 const wxPoint& pos = wxDefaultPosition,
258 const wxSize& size = wxDefaultSize,
259 long style = wxTR_DEFAULT_STYLE,
260 const wxValidator &validator = wxDefaultValidator,
261 const wxString& name = _T("wxtreelistctrl"));
262
263 // accessors
264 // ---------
265
266 // return true if this is a virtual list control
267 bool IsVirtual() const { return HasFlag(wxTR_VIRTUAL); }
268
269 // get the total number of items in the control
270 size_t GetCount() const;
271
272 // indent is the number of pixels the children are indented relative to
273 // the parents position. SetIndent() also redraws the control
274 // immediately.
275 unsigned int GetIndent() const { return m_indent; }
276 void SetIndent(unsigned int indent);
277
278 // see wxTreeListCtrl for the meaning
279 unsigned int GetLineSpacing() const { return m_linespacing; }
280 void SetLineSpacing(unsigned int spacing);
281
282 // image list: these functions allow to associate an image list with
283 // the control and retrieve it. Note that when assigned with
284 // SetImageList, the control does _not_ delete
285 // the associated image list when it's deleted in order to allow image
286 // lists to be shared between different controls. If you use
287 // AssignImageList, the control _does_ delete the image list.
288
289 // The normal image list is for the icons which correspond to the
290 // normal tree item state (whether it is selected or not).
291 // Additionally, the application might choose to show a state icon
292 // which corresponds to an app-defined item state (for example,
293 // checked/unchecked) which are taken from the state image list.
294 wxImageList *GetImageList() const { return m_imageListNormal; }
295 wxImageList *GetStateImageList() const { return m_imageListState; }
296 wxImageList *GetButtonsImageList() const { return m_imageListButtons; }
297
298 void SetImageList(wxImageList *imageList);
299 void SetStateImageList(wxImageList *imageList);
300 void SetButtonsImageList(wxImageList *imageList);
301 void AssignImageList(wxImageList *imageList);
302 void AssignStateImageList(wxImageList *imageList);
303 void AssignButtonsImageList(wxImageList *imageList);
304
305 // Functions to work with tree ctrl items.
306
307 // accessors
308 // ---------
309
310 // retrieve item's label
311 wxString GetItemText (const wxTreeItemId& item) const
312 { return GetItemText (item, GetMainColumn()); }
313 wxString GetItemText (const wxTreeItemId& item, int column) const;
314 wxString GetItemText (wxTreeItemData* item, int column) const;
315
316 // get one of the images associated with the item (normal by default)
317 int GetItemImage (const wxTreeItemId& item,
318 wxTreeItemIcon which = wxTreeItemIcon_Normal) const
319 { return GetItemImage (item, GetMainColumn(), which); }
320 int GetItemImage (const wxTreeItemId& item, int column,
321 wxTreeItemIcon which = wxTreeItemIcon_Normal) const;
322
323 // get the data associated with the item
324 wxTreeItemData *GetItemData(const wxTreeItemId& item) const;
325
326 bool GetItemBold(const wxTreeItemId& item) const;
327 wxColour GetItemTextColour(const wxTreeItemId& item) const;
328 wxColour GetItemBackgroundColour(const wxTreeItemId& item) const;
329 wxFont GetItemFont(const wxTreeItemId& item) const;
330
331 // modifiers
332 // ---------
333
334 // set item's label
335 void SetItemText (const wxTreeItemId& item, const wxString& text)
336 { SetItemText (item, GetMainColumn(), text); }
337 void SetItemText (const wxTreeItemId& item, int column, const wxString& text);
338
339 // get one of the images associated with the item (normal by default)
340 void SetItemImage (const wxTreeItemId& item, int image,
341 wxTreeItemIcon which = wxTreeItemIcon_Normal)
342 { SetItemImage (item, GetMainColumn(), image, which); }
343 void SetItemImage (const wxTreeItemId& item, int column, int image,
344 wxTreeItemIcon which = wxTreeItemIcon_Normal);
345
346 // associate some data with the item
347 void SetItemData(const wxTreeItemId& item, wxTreeItemData *data);
348
349 // force appearance of [+] button near the item. This is useful to
350 // allow the user to expand the items which don't have any children now
351 // - but instead add them only when needed, thus minimizing memory
352 // usage and loading time.
353 void SetItemHasChildren(const wxTreeItemId& item, bool has = true);
354
355 // the item will be shown in bold
356 void SetItemBold(const wxTreeItemId& item, bool bold = true);
357
358 // set the item's text colour
359 void SetItemTextColour(const wxTreeItemId& item, const wxColour& colour);
360
361 // set the item's background colour
362 void SetItemBackgroundColour(const wxTreeItemId& item, const wxColour& colour);
363
364 // set the item's font (should be of the same height for all items)
365 void SetItemFont(const wxTreeItemId& item, const wxFont& font);
366
367 // set the window font
368 virtual bool SetFont( const wxFont &font );
369
370 // set the styles. No need to specify a GetWindowStyle here since
371 // the base wxWindow member function will do it for us
372 void SetWindowStyle(const long styles);
373
374 // item status inquiries
375 // ---------------------
376
377 // is the item visible (it might be outside the view or not expanded)?
378 bool IsVisible(const wxTreeItemId& item, bool fullRow) const;
379 // does the item has any children?
380 bool HasChildren(const wxTreeItemId& item) const;
381 // is the item expanded (only makes sense if HasChildren())?
382 bool IsExpanded(const wxTreeItemId& item) const;
383 // is this item currently selected (the same as has focus)?
384 bool IsSelected(const wxTreeItemId& item) const;
385 // is item text in bold font?
386 bool IsBold(const wxTreeItemId& item) const;
387 // does the layout include space for a button?
388
389 // number of children
390 // ------------------
391
392 // if 'recursively' is false, only immediate children count, otherwise
393 // the returned number is the number of all items in this branch
394 size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = true);
395
396 // navigation
397 // ----------
398
399 // wxTreeItemId.IsOk() will return false if there is no such item
400
401 // get the root tree item
402 wxTreeItemId GetRootItem() const { return m_rootItem; }
403
404 // get the item currently selected, only if a single item is selected
405 wxTreeItemId GetSelection() const { return m_selectItem; }
406
407 // get all the items currently selected, return count of items
408 size_t GetSelections(wxArrayTreeItemIds&) const;
409
410 // get the parent of this item (may return NULL if root)
411 wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
412
413 // for this enumeration function you must pass in a "cookie" parameter
414 // which is opaque for the application but is necessary for the library
415 // to make these functions reentrant (i.e. allow more than one
416 // enumeration on one and the same object simultaneously). Of course,
417 // the "cookie" passed to GetFirstChild() and GetNextChild() should be
418 // the same!
419
420 // get child of this item
421 #if !wxCHECK_VERSION(2, 5, 0)
422 wxTreeItemId GetFirstChild(const wxTreeItemId& item, long& cookie) const;
423 wxTreeItemId GetNextChild(const wxTreeItemId& item, long& cookie) const;
424 wxTreeItemId GetPrevChild(const wxTreeItemId& item, long& cookie) const;
425 wxTreeItemId GetLastChild(const wxTreeItemId& item, long& cookie) const;
426 #else
427 wxTreeItemId GetFirstChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
428 wxTreeItemId GetNextChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
429 wxTreeItemId GetPrevChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
430 wxTreeItemId GetLastChild(const wxTreeItemId& item, wxTreeItemIdValue& cookie) const;
431 #endif
432
433 // get sibling of this item
434 wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
435 wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
436
437 // get item in the full tree (currently only for internal use)
438 wxTreeItemId GetNext(const wxTreeItemId& item, bool fulltree = true) const;
439 wxTreeItemId GetPrev(const wxTreeItemId& item, bool fulltree = true) const;
440
441 // get expanded item, see IsExpanded()
442 wxTreeItemId GetFirstExpandedItem() const;
443 wxTreeItemId GetNextExpanded(const wxTreeItemId& item) const;
444 wxTreeItemId GetPrevExpanded(const wxTreeItemId& item) const;
445
446 // get visible item, see IsVisible()
447 wxTreeItemId GetFirstVisibleItem(bool fullRow) const;
448 wxTreeItemId GetNextVisible(const wxTreeItemId& item, bool fullRow) const;
449 wxTreeItemId GetPrevVisible(const wxTreeItemId& item, bool fullRow) const;
450
451 // operations
452 // ----------
453
454 // add the root node to the tree
455 wxTreeItemId AddRoot (const wxString& text,
456 int image = -1, int selectedImage = -1,
457 wxTreeItemData *data = NULL);
458
459 // insert a new item in as the first child of the parent
460 wxTreeItemId PrependItem(const wxTreeItemId& parent,
461 const wxString& text,
462 int image = -1, int selectedImage = -1,
463 wxTreeItemData *data = NULL);
464
465 // insert a new item after a given one
466 wxTreeItemId InsertItem(const wxTreeItemId& parent,
467 const wxTreeItemId& idPrevious,
468 const wxString& text,
469 int image = -1, int selectedImage = -1,
470 wxTreeItemData *data = NULL);
471
472 // insert a new item before the one with the given index
473 wxTreeItemId InsertItem(const wxTreeItemId& parent,
474 size_t index,
475 const wxString& text,
476 int image = -1, int selectedImage = -1,
477 wxTreeItemData *data = NULL);
478
479 // insert a new item in as the last child of the parent
480 wxTreeItemId AppendItem(const wxTreeItemId& parent,
481 const wxString& text,
482 int image = -1, int selectedImage = -1,
483 wxTreeItemData *data = NULL);
484
485 // delete this item and associated data if any
486 void Delete(const wxTreeItemId& item);
487 // delete all children (but don't delete the item itself)
488 // NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
489 void DeleteChildren(const wxTreeItemId& item);
490 // delete the root and all its children from the tree
491 // NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
492 void DeleteRoot();
493
494 // expand this item
495 void Expand(const wxTreeItemId& item);
496 // expand this item and all subitems recursively
497 void ExpandAll(const wxTreeItemId& item);
498 // collapse the item without removing its children
499 void Collapse(const wxTreeItemId& item);
500 // collapse the item and remove all children
501 void CollapseAndReset(const wxTreeItemId& item);
502 // toggles the current state
503 void Toggle(const wxTreeItemId& item);
504
505 // remove the selection from currently selected item (if any)
506 void Unselect();
507 void UnselectAll();
508 // select this item
509 void SelectItem(const wxTreeItemId& item, const wxTreeItemId& prev = (wxTreeItemId*)NULL,
510 bool unselect_others = true);
511 void SelectAll();
512 // make sure this item is visible (expanding the parent item and/or
513 // scrolling to this item if necessary)
514 void EnsureVisible(const wxTreeItemId& item);
515 // scroll to this item (but don't expand its parent)
516 void ScrollTo(const wxTreeItemId& item);
517 void AdjustMyScrollbars();
518
519 // The first function is more portable (because easier to implement
520 // on other platforms), but the second one returns some extra info.
521 wxTreeItemId HitTest (const wxPoint& point)
522 { int flags; int column; return HitTest (point, flags, column); }
523 wxTreeItemId HitTest (const wxPoint& point, int& flags)
524 { int column; return HitTest (point, flags, column); }
525 wxTreeItemId HitTest (const wxPoint& point, int& flags, int& column);
526
527
528 // get the bounding rectangle of the item (or of its label only)
529 bool GetBoundingRect(const wxTreeItemId& item,
530 wxRect& rect,
531 bool textOnly = false) const;
532
533 // Start editing the item label: this (temporarily) replaces the item
534 // with a one line edit control. The item will be selected if it hadn't
535 // been before.
536 void EditLabel (const wxTreeItemId& item, int column);
537
538 // sorting
539 // this function is called to compare 2 items and should return -1, 0
540 // or +1 if the first item is less than, equal to or greater than the
541 // second one. The base class version performs alphabetic comparaison
542 // of item labels (GetText)
543 virtual int OnCompareItems(const wxTreeItemId& item1,
544 const wxTreeItemId& item2);
545 // sort the children of this item using OnCompareItems
546 //
547 // NB: this function is not reentrant and not MT-safe (FIXME)!
548 void SortChildren(const wxTreeItemId& item);
549
550 // searching
551 wxTreeItemId FindItem (const wxTreeItemId& item, const wxString& str, int mode = 0);
552
553 // implementation only from now on
554
555 // overridden base class virtuals
556 virtual bool SetBackgroundColour(const wxColour& colour);
557 virtual bool SetForegroundColour(const wxColour& colour);
558
559 // drop over item
560 void SetDragItem (const wxTreeItemId& item = (wxTreeItemId*)NULL);
561
562 // callbacks
563 void OnPaint( wxPaintEvent &event );
564 void OnSetFocus( wxFocusEvent &event );
565 void OnKillFocus( wxFocusEvent &event );
566 void OnChar( wxKeyEvent &event );
567 void OnMouse( wxMouseEvent &event );
568 void OnIdle( wxIdleEvent &event );
569 void OnScroll(wxScrollWinEvent& event);
570
571 // implementation helpers
572 void SendDeleteEvent(wxTreeListItem *itemBeingDeleted);
573
574 int GetColumnCount() const
575 { return m_owner->GetHeaderWindow()->GetColumnCount(); }
576
577 void SetMainColumn (int column)
578 { if ((column >= 0) && (column < GetColumnCount())) m_main_column = column; }
579
580 int GetMainColumn() const { return m_main_column; }
581
582 int GetBestColumnWidth (int column, wxTreeItemId parent = wxTreeItemId());
583 int GetItemWidth (int column, wxTreeListItem *item);
584 wxFont GetItemFont (wxTreeListItem *item);
585
586 void SetFocus();
587
588 protected:
589 wxTreeListCtrl* m_owner;
590
591 int m_main_column;
592
593 friend class wxTreeListItem;
594 friend class wxTreeListRenameTimer;
595 friend class wxEditTextCtrl;
596
597 wxFont m_normalFont;
598 wxFont m_boldFont;
599
600 wxTreeListItem *m_rootItem; // root item
601 wxTreeListItem *m_curItem; // current item, either selected or marked
602 wxTreeListItem *m_shiftItem; // item, where the shift key was pressed
603 wxTreeListItem *m_editItem; // item, which is currently edited
604 wxTreeListItem *m_selectItem; // current selected item, not with wxTR_MULTIPLE
605
606 int m_curColumn;
607
608 int m_btnWidth, m_btnWidth2;
609 int m_btnHeight, m_btnHeight2;
610 int m_imgWidth, m_imgWidth2;
611 int m_imgHeight, m_imgHeight2;
612 unsigned short m_indent;
613 int m_lineHeight;
614 unsigned short m_linespacing;
615 wxPen m_dottedPen;
616 wxBrush *m_hilightBrush,
617 *m_hilightUnfocusedBrush;
618 bool m_hasFocus;
619 public:
620 bool m_dirty;
621 protected:
622 bool m_ownsImageListNormal,
623 m_ownsImageListState,
624 m_ownsImageListButtons;
625 bool m_isDragging; // true between BEGIN/END drag events
626 bool m_renameAccept;
627 bool m_lastOnSame; // last click on the same item as prev
628 bool m_left_down_selection;
629
630 wxImageList *m_imageListNormal,
631 *m_imageListState,
632 *m_imageListButtons;
633
634 int m_dragCount;
635 wxTimer *m_dragTimer;
636 wxTreeListItem *m_dragItem;
637
638 wxTimer *m_renameTimer;
639 wxString m_renameRes;
640
641 // char navigation
642 wxTimer *m_findTimer;
643 wxString m_findStr;
644
645 // the common part of all ctors
646 void Init();
647
648 // misc helpers
649 wxTreeItemId DoInsertItem(const wxTreeItemId& parent,
650 size_t previous,
651 const wxString& text,
652 int image, int selectedImage,
653 wxTreeItemData *data);
654 bool HasButtons(void) const
655 { return (m_imageListButtons) || HasFlag (wxTR_TWIST_BUTTONS|wxTR_HAS_BUTTONS); }
656
657 protected:
658 void CalculateLineHeight();
659 int GetLineHeight(wxTreeListItem *item) const;
660 void PaintLevel( wxTreeListItem *item, wxDC& dc, int level, int &y,
661 int x_maincol);
662 void PaintItem( wxTreeListItem *item, wxDC& dc);
663
664 void CalculateLevel( wxTreeListItem *item, wxDC &dc, int level, int &y,
665 int x_maincol);
666 void CalculatePositions();
667 void CalculateSize( wxTreeListItem *item, wxDC &dc );
668
669 void RefreshSubtree (wxTreeListItem *item);
670 void RefreshLine (wxTreeListItem *item);
671
672 // redraw all selected items
673 void RefreshSelected();
674
675 // RefreshSelected() recursive helper
676 void RefreshSelectedUnder (wxTreeListItem *item);
677
678 void OnRenameTimer();
679 void OnRenameAccept();
680
681 void FillArray(wxTreeListItem*, wxArrayTreeItemIds&) const;
682 bool TagAllChildrenUntilLast (wxTreeListItem *crt_item, wxTreeListItem *last_item);
683 bool TagNextChildren (wxTreeListItem *crt_item, wxTreeListItem *last_item);
684 void UnselectAllChildren (wxTreeListItem *item );
685
686 private:
687 DECLARE_EVENT_TABLE()
688 DECLARE_DYNAMIC_CLASS(wxTreeListMainWindow)
689 };
690
691
692 // timer used for enabling in-place edit
693 class wxTreeListRenameTimer: public wxTimer
694 {
695 public:
696 wxTreeListRenameTimer( wxTreeListMainWindow *owner );
697
698 void Notify();
699
700 private:
701 wxTreeListMainWindow *m_owner;
702 };
703
704 // control used for in-place edit
705 class wxEditTextCtrl: public wxTextCtrl
706 {
707 public:
708 wxEditTextCtrl (wxWindow *parent,
709 const wxWindowID id,
710 bool *accept,
711 wxString *res,
712 wxTreeListMainWindow *owner,
713 const wxString &value = wxEmptyString,
714 const wxPoint &pos = wxDefaultPosition,
715 const wxSize &size = wxDefaultSize,
716 int style = 0,
717 const wxValidator& validator = wxDefaultValidator,
718 const wxString &name = wxTextCtrlNameStr );
719
720 void OnChar( wxKeyEvent &event );
721 void OnKeyUp( wxKeyEvent &event );
722 void OnKillFocus( wxFocusEvent &event );
723
724 private:
725 bool *m_accept;
726 wxString *m_res;
727 wxTreeListMainWindow *m_owner;
728 wxString m_startValue;
729 bool m_finished;
730
731 DECLARE_EVENT_TABLE()
732 };
733
734 // a tree item
735 class wxTreeListItem
736 {
737 public:
738 // ctors & dtor
739 wxTreeListItem() { m_data = NULL; }
740 wxTreeListItem( wxTreeListMainWindow *owner,
741 wxTreeListItem *parent,
742 const wxArrayString& text,
743 int image,
744 int selImage,
745 wxTreeItemData *data );
746
747 ~wxTreeListItem();
748
749 // trivial accessors
750 wxArrayTreeListItems& GetChildren() { return m_children; }
751
752 const wxString GetText() const
753 {
754 return GetText(0);
755 }
756 const wxString GetText (int column) const
757 {
758 if(m_text.GetCount() > 0)
759 {
760 if( IsVirtual() ) return m_owner->GetItemText( m_data, column );
761 else return m_text[column];
762 }
763 return wxEmptyString;
764 }
765
766 int GetImage (wxTreeItemIcon which = wxTreeItemIcon_Normal) const
767 { return m_images[which]; }
768 int GetImage (int column, wxTreeItemIcon which=wxTreeItemIcon_Normal) const
769 {
770 if(column == m_owner->GetMainColumn()) return m_images[which];
771 if(column < (int)m_col_images.GetCount()) return m_col_images[column];
772 return NO_IMAGE;
773 }
774
775 wxTreeItemData *GetData() const { return m_data; }
776
777 // returns the current image for the item (depending on its
778 // selected/expanded/whatever state)
779 int GetCurrentImage() const;
780
781 void SetText (const wxString &text );
782 void SetText (int column, const wxString& text)
783 {
784 if (column < (int)m_text.GetCount()) {
785 m_text[column] = text;
786 }else if (column < m_owner->GetColumnCount()) {
787 int howmany = m_owner->GetColumnCount();
788 for (int i = m_text.GetCount(); i < howmany; ++i) m_text.Add (wxEmptyString);
789 m_text[column] = text;
790 }
791 }
792 void SetImage (int image, wxTreeItemIcon which) { m_images[which] = image; }
793 void SetImage (int column, int image, wxTreeItemIcon which)
794 {
795 if (column == m_owner->GetMainColumn()) {
796 m_images[which] = image;
797 }else if (column < (int)m_col_images.GetCount()) {
798 m_col_images[column] = image;
799 }else if (column < m_owner->GetColumnCount()) {
800 int howmany = m_owner->GetColumnCount();
801 for (int i = m_col_images.GetCount(); i < howmany; ++i) m_col_images.Add (NO_IMAGE);
802 m_col_images[column] = image;
803 }
804 }
805
806 void SetData(wxTreeItemData *data) { m_data = data; }
807
808 void SetHasPlus(bool has = true) { m_hasPlus = has; }
809
810 void SetBold(bool bold) { m_isBold = bold; }
811
812 int GetX() const { return m_x; }
813 int GetY() const { return m_y; }
814
815 void SetX (int x) { m_x = x; }
816 void SetY (int y) { m_y = y; }
817
818 int GetHeight() const { return m_height; }
819 int GetWidth() const { return m_width; }
820
821 void SetHeight (int height) { m_height = height; }
822 void SetWidth (int width) { m_width = width; }
823
824 int GetTextX() const { return m_text_x; }
825 void SetTextX (int text_x) { m_text_x = text_x; }
826
827 wxTreeListItem *GetItemParent() const { return m_parent; }
828
829 // operations
830 // deletes all children notifying the treectrl about it if !NULL
831 // pointer given
832 void DeleteChildren(wxTreeListMainWindow *tree = NULL);
833
834 // get count of all children (and grand children if 'recursively')
835 size_t GetChildrenCount(bool recursively = true) const;
836
837 void Insert(wxTreeListItem *child, size_t index)
838 { m_children.Insert(child, index); }
839
840 void GetSize( int &x, int &y, const wxTreeListMainWindow* );
841
842 // return the item at given position (or NULL if no item), onButton is
843 // true if the point belongs to the item's button, otherwise it lies
844 // on the button's label
845 wxTreeListItem *HitTest (const wxPoint& point,
846 const wxTreeListMainWindow *,
847 int &flags, int& column, int level);
848
849 void Expand() { m_isCollapsed = false; }
850 void Collapse() { m_isCollapsed = true; }
851
852 void SetHilight( bool set = true ) { m_hasHilight = set; }
853
854 // status inquiries
855 bool HasChildren() const { return !m_children.IsEmpty(); }
856 bool IsSelected() const { return m_hasHilight != 0; }
857 bool IsExpanded() const { return !m_isCollapsed; }
858 bool HasPlus() const { return m_hasPlus || HasChildren(); }
859 bool IsBold() const { return m_isBold != 0; }
860 bool IsVirtual() const { return m_owner->IsVirtual(); }
861
862 // attributes
863 // get them - may be NULL
864 wxTreeItemAttr *GetAttributes() const { return m_attr; }
865 // get them ensuring that the pointer is not NULL
866 wxTreeItemAttr& Attr()
867 {
868 if ( !m_attr )
869 {
870 m_attr = new wxTreeItemAttr;
871 m_ownsAttr = true;
872 }
873 return *m_attr;
874 }
875 // set them
876 void SetAttributes(wxTreeItemAttr *attr)
877 {
878 if ( m_ownsAttr ) delete m_attr;
879 m_attr = attr;
880 m_ownsAttr = false;
881 }
882 // set them and delete when done
883 void AssignAttributes(wxTreeItemAttr *attr)
884 {
885 SetAttributes(attr);
886 m_ownsAttr = true;
887 }
888
889 private:
890 wxTreeListMainWindow *m_owner; // control the item belongs to
891
892 // since there can be very many of these, we save size by chosing
893 // the smallest representation for the elements and by ordering
894 // the members to avoid padding.
895 wxArrayString m_text; // labels to be rendered for item
896
897 wxTreeItemData *m_data; // user-provided data
898
899 wxArrayTreeListItems m_children; // list of children
900 wxTreeListItem *m_parent; // parent of this item
901
902 wxTreeItemAttr *m_attr; // attributes???
903
904 // tree ctrl images for the normal, selected, expanded and
905 // expanded+selected states
906 short m_images[wxTreeItemIcon_Max];
907 wxArrayShort m_col_images; // images for the various columns (!= main)
908
909 // main column item positions
910 wxCoord m_x; // (virtual) offset from left (vertical line)
911 wxCoord m_y; // (virtual) offset from top
912 wxCoord m_text_x; // item offset from left
913 short m_width; // width of this item
914 unsigned char m_height; // height of this item
915
916 // use bitfields to save size
917 int m_isCollapsed :1;
918 int m_hasHilight :1; // same as focused
919 int m_hasPlus :1; // used for item which doesn't have
920 // children but has a [+] button
921 int m_isBold :1; // render the label in bold font
922 int m_ownsAttr :1; // delete attribute when done
923 };
924
925 // ===========================================================================
926 // implementation
927 // ===========================================================================
928
929 // ---------------------------------------------------------------------------
930 // wxTreeListRenameTimer (internal)
931 // ---------------------------------------------------------------------------
932
933 wxTreeListRenameTimer::wxTreeListRenameTimer( wxTreeListMainWindow *owner )
934 {
935 m_owner = owner;
936 }
937
938 void wxTreeListRenameTimer::Notify()
939 {
940 m_owner->OnRenameTimer();
941 }
942
943 //-----------------------------------------------------------------------------
944 // wxEditTextCtrl (internal)
945 //-----------------------------------------------------------------------------
946
947 BEGIN_EVENT_TABLE (wxEditTextCtrl,wxTextCtrl)
948 EVT_CHAR (wxEditTextCtrl::OnChar)
949 EVT_KEY_UP (wxEditTextCtrl::OnKeyUp)
950 EVT_KILL_FOCUS (wxEditTextCtrl::OnKillFocus)
951 END_EVENT_TABLE()
952
953 wxEditTextCtrl::wxEditTextCtrl (wxWindow *parent,
954 const wxWindowID id,
955 bool *accept,
956 wxString *res,
957 wxTreeListMainWindow *owner,
958 const wxString &value,
959 const wxPoint &pos,
960 const wxSize &size,
961 int style,
962 const wxValidator& validator,
963 const wxString &name)
964 : wxTextCtrl (parent, id, value, pos, size, style|wxSIMPLE_BORDER, validator, name)
965 {
966 m_res = res;
967 m_accept = accept;
968 m_owner = owner;
969 (*m_accept) = false;
970 (*m_res) = wxEmptyString;
971 m_startValue = value;
972 m_finished = false;
973 }
974
975 void wxEditTextCtrl::OnChar( wxKeyEvent &event )
976 {
977 if (event.GetKeyCode() == WXK_RETURN)
978 {
979 (*m_accept) = true;
980 (*m_res) = GetValue();
981
982 if ((*m_res) != m_startValue)
983 m_owner->OnRenameAccept();
984
985 if (!wxPendingDelete.Member(this))
986 wxPendingDelete.Append(this);
987
988 m_finished = true;
989 m_owner->SetFocus(); // This doesn't work. TODO.
990
991 return;
992 }
993 if (event.GetKeyCode() == WXK_ESCAPE)
994 {
995 (*m_accept) = false;
996 (*m_res) = wxEmptyString;
997
998 if (!wxPendingDelete.Member(this))
999 wxPendingDelete.Append(this);
1000
1001 m_finished = true;
1002 m_owner->SetFocus(); // This doesn't work. TODO.
1003
1004 return;
1005 }
1006 event.Skip();
1007 }
1008
1009 void wxEditTextCtrl::OnKeyUp( wxKeyEvent &event )
1010 {
1011 if (m_finished)
1012 {
1013 event.Skip();
1014 return;
1015 }
1016
1017 // auto-grow the textctrl:
1018 wxSize parentSize = m_owner->GetSize();
1019 wxPoint myPos = GetPosition();
1020 wxSize mySize = GetSize();
1021 int sx, sy;
1022 GetTextExtent(GetValue() + _T("M"), &sx, &sy);
1023 if (myPos.x + sx > parentSize.x) sx = parentSize.x - myPos.x;
1024 if (mySize.x > sx) sx = mySize.x;
1025 SetSize(sx, -1);
1026
1027 event.Skip();
1028 }
1029
1030 void wxEditTextCtrl::OnKillFocus( wxFocusEvent &event )
1031 {
1032 if (m_finished)
1033 {
1034 event.Skip();
1035 return;
1036 }
1037
1038 if (!wxPendingDelete.Member(this))
1039 wxPendingDelete.Append(this);
1040
1041 (*m_accept) = true;
1042 (*m_res) = GetValue();
1043
1044 if ((*m_res) != m_startValue)
1045 m_owner->OnRenameAccept();
1046 }
1047
1048 //-----------------------------------------------------------------------------
1049 // wxTreeListHeaderWindow
1050 //-----------------------------------------------------------------------------
1051
1052 IMPLEMENT_DYNAMIC_CLASS(wxTreeListHeaderWindow,wxWindow);
1053
1054 BEGIN_EVENT_TABLE(wxTreeListHeaderWindow,wxWindow)
1055 EVT_PAINT (wxTreeListHeaderWindow::OnPaint)
1056 EVT_MOUSE_EVENTS (wxTreeListHeaderWindow::OnMouse)
1057 EVT_SET_FOCUS (wxTreeListHeaderWindow::OnSetFocus)
1058 END_EVENT_TABLE()
1059
1060 void wxTreeListHeaderWindow::Init()
1061 {
1062 m_currentCursor = (wxCursor *) NULL;
1063 m_isDragging = false;
1064 m_dirty = false;
1065 m_total_col_width = 0;
1066 m_hotTrackCol = -1;
1067 }
1068
1069 wxTreeListHeaderWindow::wxTreeListHeaderWindow()
1070 {
1071 Init();
1072
1073 m_owner = (wxTreeListMainWindow *) NULL;
1074 m_resizeCursor = (wxCursor *) NULL;
1075 }
1076
1077 wxTreeListHeaderWindow::wxTreeListHeaderWindow( wxWindow *win,
1078 wxWindowID id,
1079 wxTreeListMainWindow *owner,
1080 const wxPoint& pos,
1081 const wxSize& size,
1082 long style,
1083 const wxString &name )
1084 : wxWindow( win, id, pos, size, style, name )
1085 {
1086 Init();
1087
1088 m_owner = owner;
1089 m_resizeCursor = new wxCursor(wxCURSOR_SIZEWE);
1090
1091 #if !wxCHECK_VERSION(2, 5, 0)
1092 SetBackgroundColour (wxSystemSettings::GetSystemColour (wxSYS_COLOUR_BTNFACE));
1093 #else
1094 SetBackgroundColour (wxSystemSettings::GetColour (wxSYS_COLOUR_BTNFACE));
1095 #endif
1096 }
1097
1098 wxTreeListHeaderWindow::~wxTreeListHeaderWindow()
1099 {
1100 delete m_resizeCursor;
1101 }
1102
1103 void wxTreeListHeaderWindow::DoDrawRect( wxDC *dc, int x, int y, int w, int h )
1104 {
1105 #if !wxCHECK_VERSION(2, 5, 0)
1106 wxPen pen (wxSystemSettings::GetSystemColour (wxSYS_COLOUR_BTNSHADOW ), 1, wxSOLID);
1107 #else
1108 wxPen pen (wxSystemSettings::GetColour (wxSYS_COLOUR_BTNSHADOW ), 1, wxSOLID);
1109 #endif
1110
1111 const int m_corner = 1;
1112
1113 dc->SetBrush( *wxTRANSPARENT_BRUSH );
1114 #if defined( __WXMAC__ )
1115 dc->SetPen (pen);
1116 #else // !GTK, !Mac
1117 dc->SetPen( *wxBLACK_PEN );
1118 #endif
1119 dc->DrawLine( x+w-m_corner+1, y, x+w, y+h ); // right (outer)
1120 dc->DrawRectangle( x, y+h, w+1, 1 ); // bottom (outer)
1121
1122 #if defined( __WXMAC__ )
1123 pen = wxPen( wxColour( 0x88 , 0x88 , 0x88 ), 1, wxSOLID );
1124 #endif
1125 dc->SetPen( pen );
1126 dc->DrawLine( x+w-m_corner, y, x+w-1, y+h ); // right (inner)
1127 dc->DrawRectangle( x+1, y+h-1, w-2, 1 ); // bottom (inner)
1128
1129 dc->SetPen( *wxWHITE_PEN );
1130 dc->DrawRectangle( x, y, w-m_corner+1, 1 ); // top (outer)
1131 dc->DrawRectangle( x, y, 1, h ); // left (outer)
1132 dc->DrawLine( x, y+h-1, x+1, y+h-1 );
1133 dc->DrawLine( x+w-1, y, x+w-1, y+1 );
1134 }
1135
1136 // shift the DC origin to match the position of the main window horz
1137 // scrollbar: this allows us to always use logical coords
1138 void wxTreeListHeaderWindow::AdjustDC(wxDC& dc)
1139 {
1140 int xpix;
1141 m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
1142 int x;
1143 m_owner->GetViewStart( &x, NULL );
1144
1145 // account for the horz scrollbar offset
1146 dc.SetDeviceOrigin( -x * xpix, 0 );
1147 }
1148
1149 void wxTreeListHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1150 {
1151 #ifdef __WXGTK__
1152 wxClientDC dc( this );
1153 #else
1154 wxPaintDC dc( this );
1155 #endif
1156
1157 PrepareDC( dc );
1158 AdjustDC( dc );
1159
1160 int x = HEADER_OFFSET_X;
1161
1162 // width and height of the entire header window
1163 int w, h;
1164 GetClientSize( &w, &h );
1165 m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1166 dc.SetBackgroundMode(wxTRANSPARENT);
1167
1168 #if wxCHECK_VERSION_FULL(2, 7, 0, 1)
1169 int numColumns = GetColumnCount();
1170 for ( int i = 0; i < numColumns && x < w; i++ )
1171 {
1172 if (!IsColumnShown (i)) continue; // do next column if not shown
1173
1174 wxHeaderButtonParams params;
1175
1176 // TODO: columnInfo should have label colours...
1177 params.m_labelColour = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
1178 params.m_labelFont = GetFont();
1179
1180 wxTreeListColumnInfo& column = GetColumn(i);
1181 int wCol = column.GetWidth();
1182 int flags = 0;
1183 wxRect rect(x, 0, wCol, h);
1184 x += wCol;
1185
1186 if ( i == m_hotTrackCol)
1187 flags |= wxCONTROL_CURRENT;
1188
1189 params.m_labelText = column.GetText();
1190 params.m_labelAlignment = column.GetAlignment();
1191
1192 int image = column.GetImage();
1193 wxImageList* imageList = m_owner->GetImageList();
1194 if ((image != -1) && imageList)
1195 params.m_labelBitmap = imageList->GetBitmap(image);
1196
1197 wxRendererNative::Get().DrawHeaderButton(this, dc, rect, flags,
1198 wxHDR_SORT_ICON_NONE, &params);
1199 }
1200
1201 if (x < w) {
1202 wxRect rect(x, 0, w-x, h);
1203 wxRendererNative::Get().DrawHeaderButton(this, dc, rect);
1204 }
1205
1206 #else // not 2.7.0.1+
1207
1208 dc.SetFont( GetFont() );
1209
1210 // do *not* use the listctrl colour for headers - one day we will have a
1211 // function to set it separately
1212 //dc.SetTextForeground( *wxBLACK );
1213 #if !wxCHECK_VERSION(2, 5, 0)
1214 dc.SetTextForeground (wxSystemSettings::GetSystemColour( wxSYS_COLOUR_WINDOWTEXT ));
1215 #else
1216 dc.SetTextForeground (wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ));
1217 #endif
1218
1219 int numColumns = GetColumnCount();
1220 for ( int i = 0; i < numColumns && x < w; i++ )
1221 {
1222 if (!IsColumnShown (i)) continue; // do next column if not shown
1223
1224 wxTreeListColumnInfo& column = GetColumn(i);
1225 int wCol = column.GetWidth();
1226
1227 // the width of the rect to draw: make it smaller to fit entirely
1228 // inside the column rect
1229 int cw = wCol - 2;
1230
1231 #if !wxCHECK_VERSION(2, 7, 0)
1232 dc.SetPen( *wxWHITE_PEN );
1233 DoDrawRect( &dc, x, HEADER_OFFSET_Y, cw, h-2 );
1234 #else
1235 wxRect rect(x, HEADER_OFFSET_Y, cw, h-2);
1236 wxRendererNative::GetDefault().DrawHeaderButton (this, dc, rect);
1237 #endif
1238
1239 // if we have an image, draw it on the right of the label
1240 int image = column.GetImage(); //item.m_image;
1241 int ix = -2, iy = 0;
1242 wxImageList* imageList = m_owner->GetImageList();
1243 if ((image != -1) && imageList) {
1244 imageList->GetSize (image, ix, iy);
1245 }
1246
1247 // extra margins around the text label
1248 int text_width = 0;
1249 int text_x = x;
1250 int image_offset = cw - ix - 1;
1251
1252 switch(column.GetAlignment()) {
1253 case wxALIGN_LEFT:
1254 text_x += EXTRA_WIDTH;
1255 cw -= ix + 2;
1256 break;
1257 case wxALIGN_RIGHT:
1258 dc.GetTextExtent (column.GetText(), &text_width, NULL);
1259 text_x += cw - text_width - EXTRA_WIDTH - MARGIN;
1260 image_offset = 0;
1261 break;
1262 case wxALIGN_CENTER:
1263 dc.GetTextExtent(column.GetText(), &text_width, NULL);
1264 text_x += (cw - text_width)/2 + ix + 2;
1265 image_offset = (cw - text_width - ix - 2)/2 - MARGIN;
1266 break;
1267 }
1268
1269 // draw the image
1270 if ((image != -1) && imageList) {
1271 imageList->Draw (image, dc, x + image_offset/*cw - ix - 1*/,
1272 HEADER_OFFSET_Y + (h - 4 - iy)/2,
1273 wxIMAGELIST_DRAW_TRANSPARENT);
1274 }
1275
1276 // draw the text clipping it so that it doesn't overwrite the column boundary
1277 wxDCClipper clipper(dc, x, HEADER_OFFSET_Y, cw, h - 4 );
1278 dc.DrawText (column.GetText(), text_x, HEADER_OFFSET_Y + EXTRA_HEIGHT );
1279
1280 // next column
1281 x += wCol;
1282 }
1283
1284 int more_w = m_owner->GetSize().x - x - HEADER_OFFSET_X;
1285 if (more_w > 0) {
1286 #if !wxCHECK_VERSION(2, 7, 0)
1287 DoDrawRect (&dc, x, HEADER_OFFSET_Y, more_w, h-2 );
1288 #else
1289 wxRect rect (x, HEADER_OFFSET_Y, more_w, h-2);
1290 wxRendererNative::GetDefault().DrawHeaderButton (this, dc, rect);
1291 #endif
1292 }
1293 #endif // 2.7.0.1
1294 }
1295
1296 void wxTreeListHeaderWindow::DrawCurrent()
1297 {
1298 int x1 = m_currentX;
1299 int y1 = 0;
1300 ClientToScreen (&x1, &y1);
1301
1302 int x2 = m_currentX-1;
1303 #ifdef __WXMSW__
1304 ++x2; // but why ????
1305 #endif
1306 int y2 = 0;
1307 m_owner->GetClientSize( NULL, &y2 );
1308 m_owner->ClientToScreen( &x2, &y2 );
1309
1310 wxScreenDC dc;
1311 dc.SetLogicalFunction (wxINVERT);
1312 dc.SetPen (wxPen (*wxBLACK, 2, wxSOLID));
1313 dc.SetBrush (*wxTRANSPARENT_BRUSH);
1314
1315 AdjustDC(dc);
1316 dc.DrawLine (x1, y1, x2, y2);
1317 dc.SetLogicalFunction (wxCOPY);
1318 dc.SetPen (wxNullPen);
1319 dc.SetBrush (wxNullBrush);
1320 }
1321
1322 #if wxCHECK_VERSION_FULL(2, 7, 0, 1)
1323 int wxTreeListHeaderWindow::XToCol(int x)
1324 {
1325 int colLeft = 0;
1326 int numColumns = GetColumnCount();
1327 for ( int col = 0; col < numColumns; col++ )
1328 {
1329 if (!IsColumnShown(col)) continue;
1330 wxTreeListColumnInfo& column = GetColumn(col);
1331
1332 if ( x < (colLeft + column.GetWidth()) )
1333 return col;
1334
1335 colLeft += column.GetWidth();
1336 }
1337 return -1;
1338 }
1339
1340
1341 void wxTreeListHeaderWindow::RefreshColLabel(int col)
1342 {
1343 if ( col > GetColumnCount() )
1344 return;
1345
1346 int x = 0;
1347 int width = 0;
1348 int idx = 0;
1349 do {
1350 if (!IsColumnShown(idx)) continue;
1351 wxTreeListColumnInfo& column = GetColumn(idx);
1352 x += width;
1353 width = column.GetWidth();
1354 } while (++idx <= col);
1355
1356 m_owner->CalcScrolledPosition(x, 0, &x, NULL);
1357 RefreshRect(wxRect(x, 0, width, GetSize().GetHeight()));
1358 }
1359 #endif
1360
1361
1362 void wxTreeListHeaderWindow::OnMouse (wxMouseEvent &event) {
1363
1364 // we want to work with logical coords
1365 int x;
1366 m_owner->CalcUnscrolledPosition(event.GetX(), 0, &x, NULL);
1367 int y = event.GetY();
1368
1369 #if wxCHECK_VERSION_FULL(2, 7, 0, 1)
1370 if ( event.Moving() )
1371 {
1372 int col = XToCol(x);
1373 if ( col != m_hotTrackCol )
1374 {
1375 // Refresh the col header so it will be painted with hot tracking
1376 // (if supported by the native renderer.)
1377 RefreshColLabel(col);
1378
1379 // Also refresh the old hot header
1380 if ( m_hotTrackCol >= 0 )
1381 RefreshColLabel(m_hotTrackCol);
1382
1383 m_hotTrackCol = col;
1384 }
1385 }
1386
1387 if ( event.Leaving() && m_hotTrackCol >= 0 )
1388 {
1389 // Leaving the window so clear any hot tracking indicator that may be present
1390 RefreshColLabel(m_hotTrackCol);
1391 m_hotTrackCol = -1;
1392 }
1393 #endif
1394
1395 if (m_isDragging) {
1396
1397 SendListEvent (wxEVT_COMMAND_LIST_COL_DRAGGING, event.GetPosition());
1398
1399 // we don't draw the line beyond our window, but we allow dragging it
1400 // there
1401 int w = 0;
1402 GetClientSize( &w, NULL );
1403 m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1404 w -= 6;
1405
1406 // erase the line if it was drawn
1407 if (m_currentX < w) DrawCurrent();
1408
1409 if (event.ButtonUp()) {
1410 m_isDragging = false;
1411 if (HasCapture()) ReleaseMouse();
1412 m_dirty = true;
1413 SetColumnWidth (m_column, m_currentX - m_minX);
1414 Refresh();
1415 SendListEvent (wxEVT_COMMAND_LIST_COL_END_DRAG, event.GetPosition());
1416 }else{
1417 m_currentX = wxMax (m_minX + 7, x);
1418
1419 // draw in the new location
1420 if (m_currentX < w) DrawCurrent();
1421 }
1422
1423 }else{ // not dragging
1424
1425 m_minX = 0;
1426 bool hit_border = false;
1427
1428 // end of the current column
1429 int xpos = 0;
1430
1431 // find the column where this event occured
1432 int countCol = GetColumnCount();
1433 for (int column = 0; column < countCol; column++) {
1434 if (!IsColumnShown (column)) continue; // do next if not shown
1435
1436 xpos += GetColumnWidth (column);
1437 m_column = column;
1438 if ((abs (x-xpos) < 3) && (y < 22)) {
1439 // near the column border
1440 hit_border = true;
1441 break;
1442 }
1443
1444 if (x < xpos) {
1445 // inside the column
1446 break;
1447 }
1448
1449 m_minX = xpos;
1450 }
1451
1452 if (event.LeftDown() || event.RightUp()) {
1453 if (hit_border && event.LeftDown()) {
1454 m_isDragging = true;
1455 CaptureMouse();
1456 m_currentX = x;
1457 DrawCurrent();
1458 SendListEvent (wxEVT_COMMAND_LIST_COL_BEGIN_DRAG, event.GetPosition());
1459 }else{ // click on a column
1460 wxEventType evt = event.LeftDown()? wxEVT_COMMAND_LIST_COL_CLICK:
1461 wxEVT_COMMAND_LIST_COL_RIGHT_CLICK;
1462 SendListEvent (evt, event.GetPosition());
1463 }
1464 }else if (event.LeftDClick() && hit_border) {
1465 SetColumnWidth (m_column, m_owner->GetBestColumnWidth (m_column));
1466 Refresh();
1467
1468 }else if (event.Moving()) {
1469 bool setCursor;
1470 if (hit_border) {
1471 setCursor = m_currentCursor == wxSTANDARD_CURSOR;
1472 m_currentCursor = m_resizeCursor;
1473 }else{
1474 setCursor = m_currentCursor != wxSTANDARD_CURSOR;
1475 m_currentCursor = wxSTANDARD_CURSOR;
1476 }
1477 if (setCursor) SetCursor (*m_currentCursor);
1478 }
1479
1480 }
1481 }
1482
1483 void wxTreeListHeaderWindow::OnSetFocus (wxFocusEvent &WXUNUSED(event)) {
1484 m_owner->SetFocus();
1485 }
1486
1487 void wxTreeListHeaderWindow::SendListEvent (wxEventType type, wxPoint pos) {
1488 wxWindow *parent = GetParent();
1489 wxListEvent le (type, parent->GetId());
1490 le.SetEventObject (parent);
1491 le.m_pointDrag = pos;
1492
1493 // the position should be relative to the parent window, not
1494 // this one for compatibility with MSW and common sense: the
1495 // user code doesn't know anything at all about this header
1496 // window, so why should it get positions relative to it?
1497 le.m_pointDrag.y -= GetSize().y;
1498 le.m_col = m_column;
1499 parent->GetEventHandler()->ProcessEvent (le);
1500 }
1501
1502 void wxTreeListHeaderWindow::AddColumn (const wxTreeListColumnInfo& colInfo) {
1503 m_columns.Add (colInfo);
1504 m_total_col_width += colInfo.GetWidth();
1505 m_owner->AdjustMyScrollbars();
1506 m_owner->m_dirty = true;
1507 }
1508
1509 void wxTreeListHeaderWindow::SetColumnWidth (int column, int width) {
1510 wxCHECK_RET ((column >= 0) && (column < GetColumnCount()), _T("Invalid column"));
1511 m_total_col_width -= m_columns[column].GetWidth();
1512 m_columns[column].SetWidth(width);
1513 m_total_col_width += width;
1514 m_owner->AdjustMyScrollbars();
1515 m_owner->m_dirty = true;
1516 }
1517
1518 void wxTreeListHeaderWindow::InsertColumn (int before, const wxTreeListColumnInfo& colInfo) {
1519 wxCHECK_RET ((before >= 0) && (before < GetColumnCount()), _T("Invalid column"));
1520 m_columns.Insert (colInfo, before);
1521 m_total_col_width += colInfo.GetWidth();
1522 m_owner->AdjustMyScrollbars();
1523 m_owner->m_dirty = true;
1524 }
1525
1526 void wxTreeListHeaderWindow::RemoveColumn (int column) {
1527 wxCHECK_RET ((column >= 0) && (column < GetColumnCount()), _T("Invalid column"));
1528 m_total_col_width -= m_columns[column].GetWidth();
1529 m_columns.RemoveAt (column);
1530 m_owner->AdjustMyScrollbars();
1531 m_owner->m_dirty = true;
1532 }
1533
1534 void wxTreeListHeaderWindow::SetColumn (int column, const wxTreeListColumnInfo& info) {
1535 wxCHECK_RET ((column >= 0) && (column < GetColumnCount()), _T("Invalid column"));
1536 int w = m_columns[column].GetWidth();
1537 m_columns[column] = info;
1538 if (w != info.GetWidth()) {
1539 m_total_col_width += info.GetWidth() - w;
1540 m_owner->AdjustMyScrollbars();
1541 }
1542 m_owner->m_dirty = true;
1543 }
1544
1545 // ---------------------------------------------------------------------------
1546 // wxTreeListItem
1547 // ---------------------------------------------------------------------------
1548
1549 wxTreeListItem::wxTreeListItem (wxTreeListMainWindow *owner,
1550 wxTreeListItem *parent,
1551 const wxArrayString& text,
1552 int image, int selImage,
1553 wxTreeItemData *data)
1554 : m_text (text) {
1555
1556 m_images[wxTreeItemIcon_Normal] = image;
1557 m_images[wxTreeItemIcon_Selected] = selImage;
1558 m_images[wxTreeItemIcon_Expanded] = NO_IMAGE;
1559 m_images[wxTreeItemIcon_SelectedExpanded] = NO_IMAGE;
1560
1561 m_data = data;
1562 m_x = 0;
1563 m_y = 0;
1564 m_text_x = 0;
1565
1566 m_isCollapsed = true;
1567 m_hasHilight = false;
1568 m_hasPlus = false;
1569 m_isBold = false;
1570
1571 m_owner = owner;
1572 m_parent = parent;
1573
1574 m_attr = (wxTreeItemAttr *)NULL;
1575 m_ownsAttr = false;
1576
1577 // We don't know the height here yet.
1578 m_width = 0;
1579 m_height = 0;
1580 }
1581
1582 wxTreeListItem::~wxTreeListItem() {
1583 delete m_data;
1584 if (m_ownsAttr) delete m_attr;
1585
1586 wxASSERT_MSG( m_children.IsEmpty(), _T("please call DeleteChildren() before destructor"));
1587 }
1588
1589 void wxTreeListItem::DeleteChildren (wxTreeListMainWindow *tree) {
1590 size_t count = m_children.Count();
1591 for (size_t n = 0; n < count; n++) {
1592 wxTreeListItem *child = m_children[n];
1593 if (tree) {
1594 tree->SendDeleteEvent (child);
1595 if (tree->m_selectItem == child) tree->m_selectItem = (wxTreeListItem*)NULL;
1596 }
1597 child->DeleteChildren (tree);
1598 delete child;
1599 }
1600 m_children.Empty();
1601 }
1602
1603 void wxTreeListItem::SetText (const wxString &text) {
1604 if (m_text.GetCount() > 0) {
1605 m_text[0] = text;
1606 }else{
1607 m_text.Add (text);
1608 }
1609 }
1610
1611 size_t wxTreeListItem::GetChildrenCount (bool recursively) const {
1612 size_t count = m_children.Count();
1613 if (!recursively) return count;
1614
1615 size_t total = count;
1616 for (size_t n = 0; n < count; ++n) {
1617 total += m_children[n]->GetChildrenCount();
1618 }
1619 return total;
1620 }
1621
1622 void wxTreeListItem::GetSize (int &x, int &y, const wxTreeListMainWindow *theButton) {
1623 int bottomY = m_y + theButton->GetLineHeight (this);
1624 if (y < bottomY) y = bottomY;
1625 int width = m_x + m_width;
1626 if ( x < width ) x = width;
1627
1628 if (IsExpanded()) {
1629 size_t count = m_children.Count();
1630 for (size_t n = 0; n < count; ++n ) {
1631 m_children[n]->GetSize (x, y, theButton);
1632 }
1633 }
1634 }
1635
1636 wxTreeListItem *wxTreeListItem::HitTest (const wxPoint& point,
1637 const wxTreeListMainWindow *theCtrl,
1638 int &flags, int& column, int level) {
1639
1640 // for a hidden root node, don't evaluate it, but do evaluate children
1641 if (!theCtrl->HasFlag(wxTR_HIDE_ROOT) || (level > 0)) {
1642
1643 // reset any previous hit infos
1644 flags = 0;
1645 column = -1;
1646 wxTreeListHeaderWindow* header_win = theCtrl->m_owner->GetHeaderWindow();
1647
1648 // check for right of all columns (outside)
1649 if (point.x > header_win->GetWidth()) return (wxTreeListItem*) NULL;
1650
1651 // evaluate if y-pos is okay
1652 int h = theCtrl->GetLineHeight (this);
1653 if ((point.y >= m_y) && (point.y <= m_y + h)) {
1654
1655 int maincol = theCtrl->GetMainColumn();
1656
1657 // check for above/below middle
1658 int y_mid = m_y + h/2;
1659 if (point.y < y_mid) {
1660 flags |= wxTREE_HITTEST_ONITEMUPPERPART;
1661 }else{
1662 flags |= wxTREE_HITTEST_ONITEMLOWERPART;
1663 }
1664
1665 // check for button hit
1666 if (HasPlus() && theCtrl->HasButtons()) {
1667 int bntX = m_x - theCtrl->m_btnWidth2;
1668 int bntY = y_mid - theCtrl->m_btnHeight2;
1669 if ((point.x >= bntX) && (point.x <= (bntX + theCtrl->m_btnWidth)) &&
1670 (point.y >= bntY) && (point.y <= (bntY + theCtrl->m_btnHeight))) {
1671 flags |= wxTREE_HITTEST_ONITEMBUTTON;
1672 column = maincol;
1673 return this;
1674 }
1675 }
1676
1677 // check for image hit
1678 if (theCtrl->m_imgWidth > 0) {
1679 int imgX = m_text_x - theCtrl->m_imgWidth - MARGIN;
1680 int imgY = y_mid - theCtrl->m_imgHeight2;
1681 if ((point.x >= imgX) && (point.x <= (imgX + theCtrl->m_imgWidth)) &&
1682 (point.y >= imgY) && (point.y <= (imgY + theCtrl->m_imgHeight))) {
1683 flags |= wxTREE_HITTEST_ONITEMICON;
1684 column = maincol;
1685 return this;
1686 }
1687 }
1688
1689 // check for label hit
1690 if ((point.x >= m_text_x) && (point.x <= (m_text_x + m_width))) {
1691 flags |= wxTREE_HITTEST_ONITEMLABEL;
1692 column = maincol;
1693 return this;
1694 }
1695
1696 // check for indent hit after button and image hit
1697 if (point.x < m_x) {
1698 flags |= wxTREE_HITTEST_ONITEMINDENT;
1699 column = -1; // considered not belonging to main column
1700 return this;
1701 }
1702
1703 // check for right of label
1704 int end = 0;
1705 for (int i = 0; i <= maincol; ++i) end += header_win->GetColumnWidth (i);
1706 if ((point.x > (m_text_x + m_width)) && (point.x <= end)) {
1707 flags |= wxTREE_HITTEST_ONITEMRIGHT;
1708 column = -1; // considered not belonging to main column
1709 return this;
1710 }
1711
1712 // else check for each column except main
1713 int x = 0;
1714 for (int j = 0; j < theCtrl->GetColumnCount(); ++j) {
1715 if (!header_win->IsColumnShown(j)) continue;
1716 int w = header_win->GetColumnWidth (j);
1717 if ((j != maincol) && (point.x >= x && point.x < x+w)) {
1718 flags |= wxTREE_HITTEST_ONITEMCOLUMN;
1719 column = j;
1720 return this;
1721 }
1722 x += w;
1723 }
1724
1725 // no special flag or column found
1726 return this;
1727
1728 }
1729
1730 // if children not expanded, return no item
1731 if (!IsExpanded()) return (wxTreeListItem*) NULL;
1732 }
1733
1734 // in any case evaluate children
1735 wxTreeListItem *child;
1736 size_t count = m_children.Count();
1737 for (size_t n = 0; n < count; n++) {
1738 child = m_children[n]->HitTest (point, theCtrl, flags, column, level+1);
1739 if (child) return child;
1740 }
1741
1742 // not found
1743 return (wxTreeListItem*) NULL;
1744 }
1745
1746 int wxTreeListItem::GetCurrentImage() const {
1747 int image = NO_IMAGE;
1748 if (IsExpanded()) {
1749 if (IsSelected()) {
1750 image = GetImage (wxTreeItemIcon_SelectedExpanded);
1751 }else{
1752 image = GetImage (wxTreeItemIcon_Expanded);
1753 }
1754 }else{ // not expanded
1755 if (IsSelected()) {
1756 image = GetImage (wxTreeItemIcon_Selected);
1757 }else{
1758 image = GetImage (wxTreeItemIcon_Normal);
1759 }
1760 }
1761
1762 // maybe it doesn't have the specific image, try the default one instead
1763 if (image == NO_IMAGE) image = GetImage();
1764
1765 return image;
1766 }
1767
1768 // ---------------------------------------------------------------------------
1769 // wxTreeListMainWindow implementation
1770 // ---------------------------------------------------------------------------
1771
1772 IMPLEMENT_DYNAMIC_CLASS(wxTreeListMainWindow, wxScrolledWindow)
1773
1774 BEGIN_EVENT_TABLE(wxTreeListMainWindow, wxScrolledWindow)
1775 EVT_PAINT (wxTreeListMainWindow::OnPaint)
1776 EVT_MOUSE_EVENTS (wxTreeListMainWindow::OnMouse)
1777 EVT_CHAR (wxTreeListMainWindow::OnChar)
1778 EVT_SET_FOCUS (wxTreeListMainWindow::OnSetFocus)
1779 EVT_KILL_FOCUS (wxTreeListMainWindow::OnKillFocus)
1780 EVT_IDLE (wxTreeListMainWindow::OnIdle)
1781 EVT_SCROLLWIN (wxTreeListMainWindow::OnScroll)
1782 END_EVENT_TABLE()
1783
1784
1785 // ---------------------------------------------------------------------------
1786 // construction/destruction
1787 // ---------------------------------------------------------------------------
1788
1789 void wxTreeListMainWindow::Init() {
1790
1791 m_rootItem = (wxTreeListItem*)NULL;
1792 m_curItem = (wxTreeListItem*)NULL;
1793 m_shiftItem = (wxTreeListItem*)NULL;
1794 m_editItem = (wxTreeListItem*)NULL;
1795 m_selectItem = (wxTreeListItem*)NULL;
1796
1797 m_curColumn = -1; // no current column
1798
1799 m_hasFocus = false;
1800 m_dirty = false;
1801
1802 m_lineHeight = LINEHEIGHT;
1803 m_indent = MININDENT; // min. indent
1804 m_linespacing = 4;
1805
1806 #if !wxCHECK_VERSION(2, 5, 0)
1807 m_hilightBrush = new wxBrush (wxSystemSettings::GetSystemColour (wxSYS_COLOUR_HIGHLIGHT), wxSOLID);
1808 m_hilightUnfocusedBrush = new wxBrush (wxSystemSettings::GetSystemColour (wxSYS_COLOUR_BTNSHADOW), wxSOLID);
1809 #else
1810 m_hilightBrush = new wxBrush (wxSystemSettings::GetColour (wxSYS_COLOUR_HIGHLIGHT), wxSOLID);
1811 m_hilightUnfocusedBrush = new wxBrush (wxSystemSettings::GetColour (wxSYS_COLOUR_BTNSHADOW), wxSOLID);
1812 #endif
1813
1814 m_imageListNormal = (wxImageList *) NULL;
1815 m_imageListButtons = (wxImageList *) NULL;
1816 m_imageListState = (wxImageList *) NULL;
1817 m_ownsImageListNormal = m_ownsImageListButtons =
1818 m_ownsImageListState = false;
1819
1820 m_imgWidth = 0, m_imgWidth2 = 0;
1821 m_imgHeight = 0, m_imgHeight2 = 0;
1822 m_btnWidth = 0, m_btnWidth2 = 0;
1823 m_btnHeight = 0, m_btnHeight2 = 0;
1824
1825 m_dragCount = 0;
1826 m_isDragging = false;
1827 m_dragTimer = new wxTimer (this, -1);
1828 m_dragItem = (wxTreeListItem*)NULL;
1829
1830 m_renameTimer = new wxTreeListRenameTimer (this);
1831 m_lastOnSame = false;
1832 m_left_down_selection = false;
1833
1834 m_findTimer = new wxTimer (this, -1);
1835
1836 #if defined( __WXMAC__ ) && defined(__WXMAC_CARBON__)
1837 m_normalFont.MacCreateThemeFont (kThemeViewsFont);
1838 #else
1839 m_normalFont = wxSystemSettings::GetFont (wxSYS_DEFAULT_GUI_FONT);
1840 #endif
1841 m_boldFont = wxFont( m_normalFont.GetPointSize(),
1842 m_normalFont.GetFamily(),
1843 m_normalFont.GetStyle(),
1844 wxBOLD,
1845 m_normalFont.GetUnderlined(),
1846 m_normalFont.GetFaceName(),
1847 m_normalFont.GetEncoding());
1848 }
1849
1850 bool wxTreeListMainWindow::Create (wxTreeListCtrl *parent,
1851 wxWindowID id,
1852 const wxPoint& pos,
1853 const wxSize& size,
1854 long style,
1855 const wxValidator &validator,
1856 const wxString& name) {
1857
1858 #ifdef __WXMAC__
1859 if (style & wxTR_HAS_BUTTONS) style |= wxTR_MAC_BUTTONS;
1860 if (style & wxTR_HAS_BUTTONS) style &= ~wxTR_HAS_BUTTONS;
1861 style &= ~wxTR_LINES_AT_ROOT;
1862 style |= wxTR_NO_LINES;
1863
1864 int major,minor;
1865 wxGetOsVersion( &major, &minor );
1866 if (major < 10) style |= wxTR_ROW_LINES;
1867 #endif
1868
1869 wxScrolledWindow::Create (parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name);
1870
1871 #if wxUSE_VALIDATORS
1872 SetValidator(validator);
1873 #endif
1874
1875 #if !wxCHECK_VERSION(2, 5, 0)
1876 SetBackgroundColour (wxSystemSettings::GetSystemColour (wxSYS_COLOUR_LISTBOX));
1877 #else
1878 SetBackgroundColour (wxSystemSettings::GetColour (wxSYS_COLOUR_LISTBOX));
1879 #endif
1880
1881 #ifdef __WXMSW__
1882 {
1883 int i, j;
1884 wxBitmap bmp(8, 8);
1885 wxMemoryDC bdc;
1886 bdc.SelectObject(bmp);
1887 bdc.SetPen(*wxGREY_PEN);
1888 bdc.DrawRectangle(-1, -1, 10, 10);
1889 for (i = 0; i < 8; i++) {
1890 for (j = 0; j < 8; j++) {
1891 if (!((i + j) & 1)) {
1892 bdc.DrawPoint(i, j);
1893 }
1894 }
1895 }
1896
1897 m_dottedPen = wxPen(bmp, 1);
1898 }
1899 #else
1900 //? m_dottedPen = wxPen( *wxGREY_PEN, 1, wxDOT ); // too slow under XFree86
1901 m_dottedPen = wxPen( _T("grey"), 0, 0 ); // Bitmap based pen is not supported by GTK!
1902 #endif
1903
1904 m_owner = parent;
1905 m_main_column = 0;
1906
1907 return true;
1908 }
1909
1910 wxTreeListMainWindow::~wxTreeListMainWindow() {
1911 delete m_hilightBrush;
1912 delete m_hilightUnfocusedBrush;
1913
1914 delete m_dragTimer;
1915 delete m_renameTimer;
1916 delete m_findTimer;
1917 if (m_ownsImageListNormal) delete m_imageListNormal;
1918 if (m_ownsImageListState) delete m_imageListState;
1919 if (m_ownsImageListButtons) delete m_imageListButtons;
1920
1921 DeleteRoot();
1922 }
1923
1924
1925 //-----------------------------------------------------------------------------
1926 // accessors
1927 //-----------------------------------------------------------------------------
1928
1929 size_t wxTreeListMainWindow::GetCount() const {
1930 return m_rootItem == NULL? 0: m_rootItem->GetChildrenCount();
1931 }
1932
1933 void wxTreeListMainWindow::SetIndent (unsigned int indent) {
1934 m_indent = wxMax ((unsigned)MININDENT, indent);
1935 m_dirty = true;
1936 }
1937
1938 void wxTreeListMainWindow::SetLineSpacing (unsigned int spacing) {
1939 m_linespacing = spacing;
1940 m_dirty = true;
1941 CalculateLineHeight();
1942 }
1943
1944 size_t wxTreeListMainWindow::GetChildrenCount (const wxTreeItemId& item,
1945 bool recursively) {
1946 wxCHECK_MSG (item.IsOk(), 0u, _T("invalid tree item"));
1947 return ((wxTreeListItem*)item.m_pItem)->GetChildrenCount (recursively);
1948 }
1949
1950 void wxTreeListMainWindow::SetWindowStyle (const long styles) {
1951 // right now, just sets the styles. Eventually, we may
1952 // want to update the inherited styles, but right now
1953 // none of the parents has updatable styles
1954 m_windowStyle = styles;
1955 m_dirty = true;
1956 }
1957
1958 //-----------------------------------------------------------------------------
1959 // functions to work with tree items
1960 //-----------------------------------------------------------------------------
1961
1962 int wxTreeListMainWindow::GetItemImage (const wxTreeItemId& item, int column,
1963 wxTreeItemIcon which) const {
1964 wxCHECK_MSG (item.IsOk(), -1, _T("invalid tree item"));
1965 return ((wxTreeListItem*) item.m_pItem)->GetImage (column, which);
1966 }
1967
1968 wxTreeItemData *wxTreeListMainWindow::GetItemData (const wxTreeItemId& item) const {
1969 wxCHECK_MSG (item.IsOk(), NULL, _T("invalid tree item"));
1970 return ((wxTreeListItem*) item.m_pItem)->GetData();
1971 }
1972
1973 bool wxTreeListMainWindow::GetItemBold (const wxTreeItemId& item) const {
1974 wxCHECK_MSG(item.IsOk(), false, _T("invalid tree item"));
1975 return ((wxTreeListItem *)item.m_pItem)->IsBold();
1976 }
1977
1978 wxColour wxTreeListMainWindow::GetItemTextColour (const wxTreeItemId& item) const {
1979 wxCHECK_MSG (item.IsOk(), wxNullColour, _T("invalid tree item"));
1980 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
1981 return pItem->Attr().GetTextColour();
1982 }
1983
1984 wxColour wxTreeListMainWindow::GetItemBackgroundColour (const wxTreeItemId& item) const {
1985 wxCHECK_MSG (item.IsOk(), wxNullColour, _T("invalid tree item"));
1986 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
1987 return pItem->Attr().GetBackgroundColour();
1988 }
1989
1990 wxFont wxTreeListMainWindow::GetItemFont (const wxTreeItemId& item) const {
1991 wxCHECK_MSG (item.IsOk(), wxNullFont, _T("invalid tree item"));
1992 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
1993 return pItem->Attr().GetFont();
1994 }
1995
1996 void wxTreeListMainWindow::SetItemImage (const wxTreeItemId& item, int column,
1997 int image, wxTreeItemIcon which) {
1998 wxCHECK_RET (item.IsOk(), _T("invalid tree item"));
1999 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2000 pItem->SetImage (column, image, which);
2001 wxClientDC dc (this);
2002 CalculateSize (pItem, dc);
2003 RefreshLine (pItem);
2004 }
2005
2006 void wxTreeListMainWindow::SetItemData (const wxTreeItemId& item,
2007 wxTreeItemData *data) {
2008 wxCHECK_RET (item.IsOk(), _T("invalid tree item"));
2009 ((wxTreeListItem*) item.m_pItem)->SetData(data);
2010 }
2011
2012 void wxTreeListMainWindow::SetItemHasChildren (const wxTreeItemId& item,
2013 bool has) {
2014 wxCHECK_RET (item.IsOk(), _T("invalid tree item"));
2015 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2016 pItem->SetHasPlus (has);
2017 RefreshLine (pItem);
2018 }
2019
2020 void wxTreeListMainWindow::SetItemBold (const wxTreeItemId& item, bool bold) {
2021 wxCHECK_RET (item.IsOk(), _T("invalid tree item"));
2022 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2023 if (pItem->IsBold() != bold) { // avoid redrawing if no real change
2024 pItem->SetBold (bold);
2025 RefreshLine (pItem);
2026 }
2027 }
2028
2029 void wxTreeListMainWindow::SetItemTextColour (const wxTreeItemId& item,
2030 const wxColour& colour) {
2031 wxCHECK_RET (item.IsOk(), _T("invalid tree item"));
2032 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2033 pItem->Attr().SetTextColour (colour);
2034 RefreshLine (pItem);
2035 }
2036
2037 void wxTreeListMainWindow::SetItemBackgroundColour (const wxTreeItemId& item,
2038 const wxColour& colour) {
2039 wxCHECK_RET (item.IsOk(), _T("invalid tree item"));
2040 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2041 pItem->Attr().SetBackgroundColour (colour);
2042 RefreshLine (pItem);
2043 }
2044
2045 void wxTreeListMainWindow::SetItemFont (const wxTreeItemId& item,
2046 const wxFont& font) {
2047 wxCHECK_RET (item.IsOk(), _T("invalid tree item"));
2048 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2049 pItem->Attr().SetFont (font);
2050 RefreshLine (pItem);
2051 }
2052
2053 bool wxTreeListMainWindow::SetFont (const wxFont &font) {
2054 wxScrolledWindow::SetFont (font);
2055 m_normalFont = font;
2056 m_boldFont = wxFont (m_normalFont.GetPointSize(),
2057 m_normalFont.GetFamily(),
2058 m_normalFont.GetStyle(),
2059 wxBOLD,
2060 m_normalFont.GetUnderlined(),
2061 m_normalFont.GetFaceName());
2062 CalculateLineHeight();
2063 return true;
2064 }
2065
2066
2067 // ----------------------------------------------------------------------------
2068 // item status inquiries
2069 // ----------------------------------------------------------------------------
2070
2071 bool wxTreeListMainWindow::IsVisible (const wxTreeItemId& item, bool fullRow) const {
2072 wxCHECK_MSG (item.IsOk(), false, _T("invalid tree item"));
2073
2074 // An item is only visible if it's not a descendant of a collapsed item
2075 wxTreeListItem *pItem = (wxTreeListItem*) item.m_pItem;
2076 wxTreeListItem* parent = pItem->GetItemParent();
2077 while (parent) {
2078 if (parent == m_rootItem && HasFlag(wxTR_HIDE_ROOT)) break;
2079 if (!parent->IsExpanded()) return false;
2080 parent = parent->GetItemParent();
2081 }
2082
2083 wxSize clientSize = GetClientSize();
2084 wxRect rect;
2085 if ((!GetBoundingRect (item, rect)) ||
2086 ((!fullRow && rect.GetWidth() == 0) || rect.GetHeight() == 0) ||
2087 (rect.GetBottom() < 0 || rect.GetTop() > clientSize.y) ||
2088 (!fullRow && (rect.GetRight() < 0 || rect.GetLeft() > clientSize.x))) return false;
2089
2090 return true;
2091 }
2092
2093 bool wxTreeListMainWindow::HasChildren (const wxTreeItemId& item) const {
2094 wxCHECK_MSG (item.IsOk(), false, _T("invalid tree item"));
2095
2096 // consider that the item does have children if it has the "+" button: it
2097 // might not have them (if it had never been expanded yet) but then it
2098 // could have them as well and it's better to err on this side rather than
2099 // disabling some operations which are restricted to the items with
2100 // children for an item which does have them
2101 return ((wxTreeListItem*) item.m_pItem)->HasPlus();
2102 }
2103
2104 bool wxTreeListMainWindow::IsExpanded (const wxTreeItemId& item) const {
2105 wxCHECK_MSG (item.IsOk(), false, _T("invalid tree item"));
2106 return ((wxTreeListItem*) item.m_pItem)->IsExpanded();
2107 }
2108
2109 bool wxTreeListMainWindow::IsSelected (const wxTreeItemId& item) const {
2110 wxCHECK_MSG (item.IsOk(), false, _T("invalid tree item"));
2111 return ((wxTreeListItem*) item.m_pItem)->IsSelected();
2112 }
2113
2114 bool wxTreeListMainWindow::IsBold (const wxTreeItemId& item) const {
2115 wxCHECK_MSG (item.IsOk(), false, _T("invalid tree item"));
2116 return ((wxTreeListItem*) item.m_pItem)->IsBold();
2117 }
2118
2119 // ----------------------------------------------------------------------------
2120 // navigation
2121 // ----------------------------------------------------------------------------
2122
2123 wxTreeItemId wxTreeListMainWindow::GetItemParent (const wxTreeItemId& item) const {
2124 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2125 return ((wxTreeListItem*) item.m_pItem)->GetItemParent();
2126 }
2127
2128 #if !wxCHECK_VERSION(2, 5, 0)
2129 wxTreeItemId wxTreeListMainWindow::GetFirstChild (const wxTreeItemId& item,
2130 long& cookie) const {
2131 #else
2132 wxTreeItemId wxTreeListMainWindow::GetFirstChild (const wxTreeItemId& item,
2133 wxTreeItemIdValue& cookie) const {
2134 #endif
2135 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2136 wxArrayTreeListItems& children = ((wxTreeListItem*) item.m_pItem)->GetChildren();
2137 cookie = 0;
2138 return (!children.IsEmpty())? wxTreeItemId(children.Item(0)): wxTreeItemId();
2139 }
2140
2141 #if !wxCHECK_VERSION(2, 5, 0)
2142 wxTreeItemId wxTreeListMainWindow::GetNextChild (const wxTreeItemId& item,
2143 long& cookie) const {
2144 #else
2145 wxTreeItemId wxTreeListMainWindow::GetNextChild (const wxTreeItemId& item,
2146 wxTreeItemIdValue& cookie) const {
2147 #endif
2148 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2149 wxArrayTreeListItems& children = ((wxTreeListItem*) item.m_pItem)->GetChildren();
2150 // it's ok to cast cookie to long, we never have indices which overflow "void*"
2151 long *pIndex = ((long*)&cookie);
2152 return ((*pIndex)+1 < (long)children.Count())? wxTreeItemId(children.Item(++(*pIndex))): wxTreeItemId();
2153 }
2154
2155 #if !wxCHECK_VERSION(2, 5, 0)
2156 wxTreeItemId wxTreeListMainWindow::GetPrevChild (const wxTreeItemId& item,
2157 long& cookie) const {
2158 #else
2159 wxTreeItemId wxTreeListMainWindow::GetPrevChild (const wxTreeItemId& item,
2160 wxTreeItemIdValue& cookie) const {
2161 #endif
2162 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2163 wxArrayTreeListItems& children = ((wxTreeListItem*) item.m_pItem)->GetChildren();
2164 // it's ok to cast cookie to long, we never have indices which overflow "void*"
2165 long *pIndex = (long*)&cookie;
2166 return ((*pIndex)-1 >= 0)? wxTreeItemId(children.Item(--(*pIndex))): wxTreeItemId();
2167 }
2168
2169 #if !wxCHECK_VERSION(2, 5, 0)
2170 wxTreeItemId wxTreeListMainWindow::GetLastChild (const wxTreeItemId& item,
2171 long& cookie) const {
2172 #else
2173 wxTreeItemId wxTreeListMainWindow::GetLastChild (const wxTreeItemId& item,
2174 wxTreeItemIdValue& cookie) const {
2175 #endif
2176 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2177 wxArrayTreeListItems& children = ((wxTreeListItem*) item.m_pItem)->GetChildren();
2178 // it's ok to cast cookie to long, we never have indices which overflow "void*"
2179 long *pIndex = ((long*)&cookie);
2180 (*pIndex) = children.Count();
2181 return (!children.IsEmpty())? wxTreeItemId(children.Last()): wxTreeItemId();
2182 }
2183
2184 wxTreeItemId wxTreeListMainWindow::GetNextSibling (const wxTreeItemId& item) const {
2185 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2186
2187 // get parent
2188 wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
2189 wxTreeListItem *parent = i->GetItemParent();
2190 if (!parent) return wxTreeItemId(); // root item doesn't have any siblings
2191
2192 // get index
2193 wxArrayTreeListItems& siblings = parent->GetChildren();
2194 size_t index = siblings.Index (i);
2195 wxASSERT (index != (size_t)wxNOT_FOUND); // I'm not a child of my parent?
2196 return (index < siblings.Count()-1)? wxTreeItemId(siblings[index+1]): wxTreeItemId();
2197 }
2198
2199 wxTreeItemId wxTreeListMainWindow::GetPrevSibling (const wxTreeItemId& item) const {
2200 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2201
2202 // get parent
2203 wxTreeListItem *i = (wxTreeListItem*) item.m_pItem;
2204 wxTreeListItem *parent = i->GetItemParent();
2205 if (!parent) return wxTreeItemId(); // root item doesn't have any siblings
2206
2207 // get index
2208 wxArrayTreeListItems& siblings = parent->GetChildren();
2209 size_t index = siblings.Index(i);
2210 wxASSERT (index != (size_t)wxNOT_FOUND); // I'm not a child of my parent?
2211 return (index >= 1)? wxTreeItemId(siblings[index-1]): wxTreeItemId();
2212 }
2213
2214 // Only for internal use right now, but should probably be public
2215 wxTreeItemId wxTreeListMainWindow::GetNext (const wxTreeItemId& item, bool fulltree) const {
2216 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2217
2218 // if there are any children, return first child
2219 if (fulltree || ((wxTreeListItem*)item.m_pItem)->IsExpanded()) {
2220 wxArrayTreeListItems& children = ((wxTreeListItem*)item.m_pItem)->GetChildren();
2221 if (children.GetCount() > 0) return children.Item (0);
2222 }
2223
2224 // get sibling of this item or of the ancestors instead
2225 wxTreeItemId next;
2226 wxTreeItemId parent = item;
2227 do {
2228 next = GetNextSibling (parent);
2229 parent = GetItemParent (parent);
2230 } while (!next.IsOk() && parent.IsOk());
2231 return next;
2232 }
2233
2234 // Only for internal use right now, but should probably be public
2235 wxTreeItemId wxTreeListMainWindow::GetPrev (const wxTreeItemId& item, bool fulltree) const {
2236 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2237
2238 // if there are any children, return last child
2239 if (fulltree || ((wxTreeListItem*)item.m_pItem)->IsExpanded()) {
2240 wxArrayTreeListItems& children = ((wxTreeListItem*)item.m_pItem)->GetChildren();
2241 if (children.GetCount() > 0) return children.Item (children.GetCount()-1);
2242 }
2243
2244 // get sibling of this item or of the ancestors instead
2245 wxTreeItemId next;
2246 wxTreeItemId parent = item;
2247 do {
2248 next = GetPrevSibling (parent);
2249 parent = GetItemParent (parent);
2250 } while (!next.IsOk() && parent.IsOk());
2251 return next;
2252 }
2253
2254 wxTreeItemId wxTreeListMainWindow::GetFirstExpandedItem() const {
2255 return GetNextExpanded (GetRootItem());
2256 }
2257
2258 wxTreeItemId wxTreeListMainWindow::GetNextExpanded (const wxTreeItemId& item) const {
2259 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2260 return GetNext (item, false);
2261 }
2262
2263 wxTreeItemId wxTreeListMainWindow::GetPrevExpanded (const wxTreeItemId& item) const {
2264 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2265 return GetPrev (item, false);
2266 }
2267
2268 wxTreeItemId wxTreeListMainWindow::GetFirstVisibleItem (bool fullRow) const {
2269 return GetNextVisible (GetRootItem(), fullRow);
2270 }
2271
2272 wxTreeItemId wxTreeListMainWindow::GetNextVisible (const wxTreeItemId& item, bool fullRow) const {
2273 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2274 wxTreeItemId id = GetNext (item, false);
2275 while (id.IsOk()) {
2276 if (IsVisible (id, fullRow)) return id;
2277 id = GetNext (id, false);
2278 }
2279 return wxTreeItemId();
2280 }
2281
2282 wxTreeItemId wxTreeListMainWindow::GetPrevVisible (const wxTreeItemId& item, bool fullRow) const {
2283 wxCHECK_MSG (item.IsOk(), wxTreeItemId(), _T("invalid tree item"));
2284 wxTreeItemId id = GetPrev (item, true);
2285 while (id.IsOk()) {
2286 if (IsVisible (id, fullRow)) return id;
2287 id = GetPrev(id, true);
2288 }
2289 return wxTreeItemId();
2290 }
2291
2292 // ----------------------------------------------------------------------------
2293 // operations
2294 // ----------------------------------------------------------------------------
2295
2296 wxTreeItemId wxTreeListMainWindow::DoInsertItem (const wxTreeItemId& parentId,
2297 size_t previous,
2298 const wxString& text,
2299 int image, int selImage,
2300 wxTreeItemData *data) {
2301 wxTreeListItem *parent = (wxTreeListItem*)parentId.m_pItem;
2302 wxCHECK_MSG (parent, wxTreeItemId(), _T("item must have a parent, at least root!") );
2303 m_dirty = true; // do this first so stuff below doesn't cause flicker
2304
2305 wxArrayString arr;
2306 arr.Alloc (GetColumnCount());
2307 for (int i = 0; i < (int)GetColumnCount(); ++i) arr.Add (wxEmptyString);
2308 arr[m_main_column] = text;
2309 wxTreeListItem *item = new wxTreeListItem (this, parent, arr, image, selImage, data);
2310 if (data != NULL) {
2311 #if !wxCHECK_VERSION(2, 5, 0)
2312 data->SetId ((long)item);
2313 #else
2314 data->SetId (item);
2315 #endif
2316 }
2317 parent->Insert (item, previous);
2318
2319 return item;
2320 }
2321
2322 wxTreeItemId wxTreeListMainWindow::AddRoot (const wxString& text,
2323 int image, int selImage,
2324 wxTreeItemData *data) {
2325 wxCHECK_MSG(!m_rootItem, wxTreeItemId(), _T("tree can have only one root"));
2326 wxCHECK_MSG(GetColumnCount(), wxTreeItemId(), _T("Add column(s) before adding the root item"));
2327 m_dirty = true; // do this first so stuff below doesn't cause flicker
2328
2329 wxArrayString arr;
2330 arr.Alloc (GetColumnCount());
2331 for (int i = 0; i < (int)GetColumnCount(); ++i) arr.Add (wxEmptyString);
2332 arr[m_main_column] = text;
2333 m_rootItem = new wxTreeListItem (this, (wxTreeListItem *)NULL, arr, image, selImage, data);
2334 if (data != NULL) {
2335 #if !wxCHECK_VERSION(2, 5, 0)
2336 data->SetId((long)m_rootItem);
2337 #else
2338 data->SetId(m_rootItem);
2339 #endif
2340 }
2341 if (HasFlag(wxTR_HIDE_ROOT)) {
2342 // if we will hide the root, make sure children are visible
2343 m_rootItem->SetHasPlus();
2344 m_rootItem->Expand();
2345 #if !wxCHECK_VERSION(2, 5, 0)
2346 long cookie = 0;
2347 #else
2348 wxTreeItemIdValue cookie = 0;
2349 #endif
2350 m_curItem = (wxTreeListItem*)GetFirstChild (m_rootItem, cookie).m_pItem;
2351 }
2352 return m_rootItem;
2353 }
2354
2355 wxTreeItemId wxTreeListMainWindow::PrependItem (const wxTreeItemId& parent,
2356 const wxString& text,
2357 int image, int selImage,
2358 wxTreeItemData *data) {
2359 return DoInsertItem (parent, 0u, text, image, selImage, data);
2360 }
2361
2362 wxTreeItemId wxTreeListMainWindow::InsertItem (const wxTreeItemId& parentId,
2363 const wxTreeItemId& idPrevious,
2364 const wxString& text,
2365 int image, int selImage,
2366 wxTreeItemData *data) {
2367 wxTreeListItem *parent = (wxTreeListItem*)parentId.m_pItem;
2368 wxCHECK_MSG (parent, wxTreeItemId(), _T("item must have a parent, at least root!") );
2369
2370 int index = parent->GetChildren().Index((wxTreeListItem*) idPrevious.m_pItem);
2371 wxASSERT_MSG( index != wxNOT_FOUND,
2372 _T("previous item in wxTreeListMainWindow::InsertItem() is not a sibling") );
2373
2374 return DoInsertItem (parentId, ++index, text, image, selImage, data);
2375 }
2376
2377 wxTreeItemId wxTreeListMainWindow::InsertItem (const wxTreeItemId& parentId,
2378 size_t before,
2379 const wxString& text,
2380 int image, int selImage,
2381 wxTreeItemData *data) {
2382 wxTreeListItem *parent = (wxTreeListItem*)parentId.m_pItem;
2383 wxCHECK_MSG (parent, wxTreeItemId(), _T("item must have a parent, at least root!") );
2384
2385 return DoInsertItem (parentId, before, text, image, selImage, data);
2386 }
2387
2388 wxTreeItemId wxTreeListMainWindow::AppendItem (const wxTreeItemId& parentId,
2389 const wxString& text,
2390 int image, int selImage,
2391 wxTreeItemData *data) {
2392 wxTreeListItem *parent = (wxTreeListItem*) parentId.m_pItem;
2393 wxCHECK_MSG (parent, wxTreeItemId(), _T("item must have a parent, at least root!") );
2394
2395 return DoInsertItem (parent, parent->GetChildren().Count(), text, image, selImage, data);
2396 }
2397
2398 void wxTreeListMainWindow::SendDeleteEvent (wxTreeListItem *item) {
2399 // send event to user code
2400 wxTreeEvent event (wxEVT_COMMAND_TREE_DELETE_ITEM, m_owner->GetId());
2401 #if !wxCHECK_VERSION(2, 5, 0)
2402 event.SetItem ((long)item);
2403 #else
2404 event.SetItem (item);
2405 #endif
2406 event.SetEventObject (m_owner);
2407 m_owner->ProcessEvent (event);
2408 }
2409
2410 void wxTreeListMainWindow::Delete (const wxTreeItemId& itemId) {
2411 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2412 wxCHECK_RET (item != m_rootItem, _T("invalid item, root may not be deleted this way!"));
2413 m_dirty = true; // do this first so stuff below doesn't cause flicker
2414
2415 // don't stay with invalid m_shiftItem or we will crash in the next call to OnChar()
2416 bool changeKeyCurrent = false;
2417 wxTreeListItem *itemKey = m_shiftItem;
2418 while (itemKey) {
2419 if (itemKey == item) { // m_shiftItem is a descendant of the item being deleted
2420 changeKeyCurrent = true;
2421 break;
2422 }
2423 itemKey = itemKey->GetItemParent();
2424 }
2425
2426 wxTreeListItem *parent = item->GetItemParent();
2427 if (parent) {
2428 parent->GetChildren().Remove (item); // remove by value
2429 }
2430 if (changeKeyCurrent) m_shiftItem = parent;
2431
2432 SendDeleteEvent (item);
2433 if (m_selectItem == item) m_selectItem = (wxTreeListItem*)NULL;
2434 item->DeleteChildren (this);
2435 delete item;
2436 }
2437
2438 void wxTreeListMainWindow::DeleteChildren (const wxTreeItemId& itemId) {
2439 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2440 m_dirty = true; // do this first so stuff below doesn't cause flicker
2441
2442 item->DeleteChildren (this);
2443 }
2444
2445 void wxTreeListMainWindow::DeleteRoot() {
2446 if (m_rootItem) {
2447 m_dirty = true;
2448 SendDeleteEvent (m_rootItem);
2449 m_curItem = (wxTreeListItem*)NULL;
2450 m_selectItem= (wxTreeListItem*)NULL;
2451 m_rootItem->DeleteChildren (this);
2452 delete m_rootItem;
2453 m_rootItem = NULL;
2454 }
2455 }
2456
2457 void wxTreeListMainWindow::Expand (const wxTreeItemId& itemId) {
2458 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2459 wxCHECK_RET (item, _T("invalid item in wxTreeListMainWindow::Expand") );
2460
2461 if (!item->HasPlus() || item->IsExpanded()) return;
2462
2463 // send event to user code
2464 wxTreeEvent event (wxEVT_COMMAND_TREE_ITEM_EXPANDING, m_owner->GetId());
2465 #if !wxCHECK_VERSION(2, 5, 0)
2466 event.SetItem ((long)item);
2467 #else
2468 event.SetItem (item);
2469 #endif
2470 event.SetEventObject (m_owner);
2471 if (m_owner->ProcessEvent (event) && !event.IsAllowed()) return; // expand canceled
2472
2473 item->Expand();
2474 m_dirty = true;
2475
2476 // send event to user code
2477 event.SetEventType (wxEVT_COMMAND_TREE_ITEM_EXPANDED);
2478 m_owner->ProcessEvent (event);
2479 }
2480
2481 void wxTreeListMainWindow::ExpandAll (const wxTreeItemId& itemId) {
2482 Expand (itemId);
2483 if (!IsExpanded (itemId)) return;
2484 #if !wxCHECK_VERSION(2, 5, 0)
2485 long cookie;
2486 #else
2487 wxTreeItemIdValue cookie;
2488 #endif
2489 wxTreeItemId child = GetFirstChild (itemId, cookie);
2490 while (child.IsOk()) {
2491 ExpandAll (child);
2492 child = GetNextChild (itemId, cookie);
2493 }
2494 }
2495
2496 void wxTreeListMainWindow::Collapse (const wxTreeItemId& itemId) {
2497 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2498 wxCHECK_RET (item, _T("invalid item in wxTreeListMainWindow::Collapse") );
2499
2500 if (!item->HasPlus() || !item->IsExpanded()) return;
2501
2502 // send event to user code
2503 wxTreeEvent event (wxEVT_COMMAND_TREE_ITEM_COLLAPSING, m_owner->GetId() );
2504 #if !wxCHECK_VERSION(2, 5, 0)
2505 event.SetItem ((long)item);
2506 #else
2507 event.SetItem (item);
2508 #endif
2509 event.SetEventObject (m_owner);
2510 if (m_owner->ProcessEvent (event) && !event.IsAllowed()) return; // collapse canceled
2511
2512 item->Collapse();
2513 m_dirty = true;
2514
2515 // send event to user code
2516 event.SetEventType (wxEVT_COMMAND_TREE_ITEM_COLLAPSED);
2517 ProcessEvent (event);
2518 }
2519
2520 void wxTreeListMainWindow::CollapseAndReset (const wxTreeItemId& item) {
2521 Collapse (item);
2522 DeleteChildren (item);
2523 }
2524
2525 void wxTreeListMainWindow::Toggle (const wxTreeItemId& itemId) {
2526 if (IsExpanded (itemId)) {
2527 Collapse (itemId);
2528 }else{
2529 Expand (itemId);
2530 }
2531 }
2532
2533 void wxTreeListMainWindow::Unselect() {
2534 if (m_selectItem) {
2535 m_selectItem->SetHilight (false);
2536 RefreshLine (m_selectItem);
2537 m_selectItem = (wxTreeListItem*)NULL;
2538 }
2539 }
2540
2541 void wxTreeListMainWindow::UnselectAllChildren (wxTreeListItem *item) {
2542 if (item->IsSelected()) {
2543 item->SetHilight (false);
2544 RefreshLine (item);
2545 if (item == m_selectItem) m_selectItem = (wxTreeListItem*)NULL;
2546 }
2547 if (item->HasChildren()) {
2548 wxArrayTreeListItems& children = item->GetChildren();
2549 size_t count = children.Count();
2550 for (size_t n = 0; n < count; ++n) {
2551 UnselectAllChildren (children[n]);
2552 }
2553 }
2554 }
2555
2556 void wxTreeListMainWindow::UnselectAll() {
2557 UnselectAllChildren ((wxTreeListItem*)GetRootItem().m_pItem);
2558 }
2559
2560 // Recursive function !
2561 // To stop we must have crt_item<last_item
2562 // Algorithm :
2563 // Tag all next children, when no more children,
2564 // Move to parent (not to tag)
2565 // Keep going... if we found last_item, we stop.
2566 bool wxTreeListMainWindow::TagNextChildren (wxTreeListItem *crt_item,
2567 wxTreeListItem *last_item) {
2568 wxTreeListItem *parent = crt_item->GetItemParent();
2569
2570 if (!parent) {// This is root item
2571 return TagAllChildrenUntilLast (crt_item, last_item);
2572 }
2573
2574 wxArrayTreeListItems& children = parent->GetChildren();
2575 int index = children.Index(crt_item);
2576 wxASSERT (index != wxNOT_FOUND); // I'm not a child of my parent?
2577
2578 if ((parent->HasChildren() && parent->IsExpanded()) ||
2579 ((parent == (wxTreeListItem*)GetRootItem().m_pItem) && HasFlag(wxTR_HIDE_ROOT))) {
2580 size_t count = children.Count();
2581 for (size_t n = (index+1); n < count; ++n) {
2582 if (TagAllChildrenUntilLast (children[n], last_item)) return true;
2583 }
2584 }
2585
2586 return TagNextChildren (parent, last_item);
2587 }
2588
2589 bool wxTreeListMainWindow::TagAllChildrenUntilLast (wxTreeListItem *crt_item,
2590 wxTreeListItem *last_item) {
2591 crt_item->SetHilight (true);
2592 RefreshLine(crt_item);
2593
2594 if (crt_item==last_item) return true;
2595
2596 if (crt_item->HasChildren() && crt_item->IsExpanded()) {
2597 wxArrayTreeListItems& children = crt_item->GetChildren();
2598 size_t count = children.Count();
2599 for (size_t n = 0; n < count; ++n) {
2600 if (TagAllChildrenUntilLast (children[n], last_item)) return true;
2601 }
2602 }
2603
2604 return false;
2605 }
2606
2607 void wxTreeListMainWindow::SelectItem (const wxTreeItemId& itemId,
2608 const wxTreeItemId& lastId,
2609 bool unselect_others) {
2610 wxCHECK_RET (itemId.IsOk(), _T("invalid tree item") );
2611
2612 bool is_single = !HasFlag(wxTR_MULTIPLE);
2613 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2614
2615 // single selection requires unselect others
2616 if (is_single) unselect_others = true;
2617
2618 // send event to the user code
2619 wxTreeEvent event( wxEVT_COMMAND_TREE_SEL_CHANGING, m_owner->GetId() );
2620 #if !wxCHECK_VERSION(2, 5, 0)
2621 event.SetItem ((long)item);
2622 event.SetOldItem ((long)m_curItem);
2623 #else
2624 event.SetItem (item);
2625 event.SetOldItem (m_curItem);
2626 #endif
2627 event.SetEventObject (m_owner);
2628 if (m_owner->GetEventHandler()->ProcessEvent (event) && !event.IsAllowed()) return;
2629
2630 // unselect all if unselect other items
2631 bool unselected = false; // see that UnselectAll is done only once
2632 if (unselect_others) {
2633 if (is_single) {
2634 Unselect(); // to speed up thing
2635 }else{
2636 UnselectAll();
2637 unselected = true;
2638 }
2639 }
2640
2641 // select item or item range
2642 if (lastId.IsOk() && (itemId != lastId)) {
2643
2644 if (!unselected) UnselectAll();
2645 wxTreeListItem *last = (wxTreeListItem*) lastId.m_pItem;
2646
2647 // ensure that the position of the item it calculated in any case
2648 if (m_dirty) CalculatePositions();
2649
2650 // select item range according Y-position
2651 if (last->GetY() < item->GetY()) {
2652 if (!TagAllChildrenUntilLast (last, item)) {
2653 TagNextChildren (last, item);
2654 }
2655 }else{
2656 if (!TagAllChildrenUntilLast (item, last)) {
2657 TagNextChildren (item, last);
2658 }
2659 }
2660
2661 }else{
2662
2663 // select item according its old selection
2664 item->SetHilight (!item->IsSelected());
2665 RefreshLine (item);
2666 if (unselect_others) {
2667 m_selectItem = (item->IsSelected())? item: (wxTreeListItem*)NULL;
2668 }
2669
2670 }
2671
2672 // send event to user code
2673 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
2674 m_owner->GetEventHandler()->ProcessEvent (event);
2675 }
2676
2677 void wxTreeListMainWindow::SelectAll() {
2678 wxCHECK_RET (HasFlag(wxTR_MULTIPLE), _T("invalid tree style"));
2679
2680 // send event to user code
2681 wxTreeEvent event (wxEVT_COMMAND_TREE_SEL_CHANGING, m_owner->GetId());
2682 event.SetItem (GetRootItem());
2683 #if !wxCHECK_VERSION(2, 5, 0)
2684 event.SetOldItem ((long)m_curItem);
2685 #else
2686 event.SetOldItem (m_curItem);
2687 #endif
2688 event.SetEventObject (m_owner);
2689 if (m_owner->GetEventHandler()->ProcessEvent (event) && !event.IsAllowed()) return;
2690
2691 #if !wxCHECK_VERSION(2, 5, 0)
2692 long cookie = 0;
2693 #else
2694 wxTreeItemIdValue cookie = 0;
2695 #endif
2696 wxTreeItemId root = GetRootItem();
2697 wxTreeListItem *first = (wxTreeListItem *)GetFirstChild (root, cookie).m_pItem;
2698 wxTreeListItem *last = (wxTreeListItem *)GetLastChild (root, cookie).m_pItem;
2699 if (!TagAllChildrenUntilLast (first, last)) {
2700 TagNextChildren (first, last);
2701 }
2702
2703 // send event to user code
2704 event.SetEventType (wxEVT_COMMAND_TREE_SEL_CHANGED);
2705 m_owner->GetEventHandler()->ProcessEvent (event);
2706 }
2707
2708 void wxTreeListMainWindow::FillArray (wxTreeListItem *item,
2709 wxArrayTreeItemIds &array) const {
2710 if (item->IsSelected()) array.Add (wxTreeItemId(item));
2711
2712 if (item->HasChildren()) {
2713 wxArrayTreeListItems& children = item->GetChildren();
2714 size_t count = children.GetCount();
2715 for (size_t n = 0; n < count; ++n) FillArray (children[n], array);
2716 }
2717 }
2718
2719 size_t wxTreeListMainWindow::GetSelections (wxArrayTreeItemIds &array) const {
2720 array.Empty();
2721 wxTreeItemId idRoot = GetRootItem();
2722 if (idRoot.IsOk()) FillArray ((wxTreeListItem*) idRoot.m_pItem, array);
2723 return array.Count();
2724 }
2725
2726 void wxTreeListMainWindow::EnsureVisible (const wxTreeItemId& item) {
2727 if (!item.IsOk()) return; // do nothing if no item
2728
2729 // first expand all parent branches
2730 wxTreeListItem *gitem = (wxTreeListItem*) item.m_pItem;
2731 wxTreeListItem *parent = gitem->GetItemParent();
2732 while (parent) {
2733 Expand (parent);
2734 parent = parent->GetItemParent();
2735 }
2736
2737 ScrollTo (item);
2738 RefreshLine (gitem);
2739 }
2740
2741 void wxTreeListMainWindow::ScrollTo (const wxTreeItemId &item) {
2742 if (!item.IsOk()) return; // do nothing if no item
2743
2744 // ensure that the position of the item it calculated in any case
2745 if (m_dirty) CalculatePositions();
2746
2747 wxTreeListItem *gitem = (wxTreeListItem*) item.m_pItem;
2748
2749 // now scroll to the item
2750 int item_y = gitem->GetY();
2751
2752 int xUnit, yUnit;
2753 GetScrollPixelsPerUnit (&xUnit, &yUnit);
2754 int start_x = 0;
2755 int start_y = 0;
2756 GetViewStart (&start_x, &start_y);
2757 start_y *= yUnit;
2758
2759 int client_h = 0;
2760 int client_w = 0;
2761 GetClientSize (&client_w, &client_h);
2762
2763 int x = 0;
2764 int y = 0;
2765 m_rootItem->GetSize (x, y, this);
2766 x = m_owner->GetHeaderWindow()->GetWidth();
2767 y += yUnit + 2; // one more scrollbar unit + 2 pixels
2768 int x_pos = GetScrollPos( wxHORIZONTAL );
2769
2770 if (item_y < start_y+3) {
2771 // going down, item should appear at top
2772 SetScrollbars (xUnit, yUnit, xUnit ? x/xUnit : 0, yUnit ? y/yUnit : 0, x_pos, yUnit ? item_y/yUnit : 0);
2773 }else if (item_y+GetLineHeight(gitem) > start_y+client_h) {
2774 // going up, item should appear at bottom
2775 item_y += yUnit + 2;
2776 SetScrollbars (xUnit, yUnit, xUnit ? x/xUnit : 0, yUnit ? y/yUnit : 0, x_pos, yUnit ? (item_y+GetLineHeight(gitem)-client_h)/yUnit : 0 );
2777 }
2778 }
2779
2780 // FIXME: tree sorting functions are not reentrant and not MT-safe!
2781 static wxTreeListMainWindow *s_treeBeingSorted = NULL;
2782
2783 static int LINKAGEMODE tree_ctrl_compare_func(wxTreeListItem **item1,
2784 wxTreeListItem **item2)
2785 {
2786 wxCHECK_MSG (s_treeBeingSorted, 0, _T("bug in wxTreeListMainWindow::SortChildren()") );
2787
2788 return s_treeBeingSorted->OnCompareItems(*item1, *item2);
2789 }
2790
2791 int wxTreeListMainWindow::OnCompareItems(const wxTreeItemId& item1,
2792 const wxTreeItemId& item2)
2793 {
2794 return m_owner->OnCompareItems (item1, item2);
2795 }
2796
2797 void wxTreeListMainWindow::SortChildren (const wxTreeItemId& itemId) {
2798 wxCHECK_RET (itemId.IsOk(), _T("invalid tree item"));
2799
2800 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
2801
2802 wxCHECK_RET (!s_treeBeingSorted,
2803 _T("wxTreeListMainWindow::SortChildren is not reentrant") );
2804
2805 wxArrayTreeListItems& children = item->GetChildren();
2806 if ( children.Count() > 1 ) {
2807 m_dirty = true;
2808 s_treeBeingSorted = this;
2809 children.Sort(tree_ctrl_compare_func);
2810 s_treeBeingSorted = NULL;
2811 }
2812 }
2813
2814 wxTreeItemId wxTreeListMainWindow::FindItem (const wxTreeItemId& item, const wxString& str, int mode) {
2815 wxString itemText;
2816 // determine start item
2817 wxTreeItemId next = item;
2818 if (next.IsOk()) {
2819 if (mode & wxTL_MODE_NAV_LEVEL) {
2820 next = GetNextSibling (next);
2821 }else if (mode & wxTL_MODE_NAV_VISIBLE) { //
2822 next = GetNextVisible (next, false);
2823 }else if (mode & wxTL_MODE_NAV_EXPANDED) {
2824 next = GetNextExpanded (next);
2825 }else{ // (mode & wxTL_MODE_NAV_FULLTREE) default
2826 next = GetNext (next, true);
2827 }
2828 }
2829
2830 #if !wxCHECK_VERSION(2, 5, 0)
2831 long cookie = 0;
2832 #else
2833 wxTreeItemIdValue cookie = 0;
2834 #endif
2835 if (!next.IsOk()) {
2836 next = (wxTreeListItem*)GetRootItem().m_pItem;
2837 if (HasFlag(wxTR_HIDE_ROOT)) {
2838 next = (wxTreeListItem*)GetFirstChild (GetRootItem().m_pItem, cookie).m_pItem;
2839 }
2840 }
2841 if (!next.IsOk()) return (wxTreeItemId*)NULL;
2842
2843 // start checking the next items
2844 while (next.IsOk() && (next != item)) {
2845 if (mode & wxTL_MODE_FIND_PARTIAL) {
2846 itemText = GetItemText (next).Mid (0, str.Length());
2847 }else{
2848 itemText = GetItemText (next);
2849 }
2850 if (mode & wxTL_MODE_FIND_NOCASE) {
2851 if (itemText.CmpNoCase (str) == 0) return next;
2852 }else{
2853 if (itemText.Cmp (str) == 0) return next;
2854 }
2855 if (mode & wxTL_MODE_NAV_LEVEL) {
2856 next = GetNextSibling (next);
2857 }else if (mode & wxTL_MODE_NAV_VISIBLE) { //
2858 next = GetNextVisible (next, false);
2859 }else if (mode & wxTL_MODE_NAV_EXPANDED) {
2860 next = GetNextExpanded (next);
2861 }else{ // (mode & wxTL_MODE_NAV_FULLTREE) default
2862 next = GetNext (next, true);
2863 }
2864 if (!next.IsOk() && item.IsOk()) {
2865 next = (wxTreeListItem*)GetRootItem().m_pItem;
2866 if (HasFlag(wxTR_HIDE_ROOT)) {
2867 next = (wxTreeListItem*)GetNextChild (GetRootItem().m_pItem, cookie).m_pItem;
2868 }
2869 }
2870 }
2871 return (wxTreeItemId*)NULL;
2872 }
2873
2874 void wxTreeListMainWindow::SetDragItem (const wxTreeItemId& item) {
2875 wxTreeListItem *prevItem = m_dragItem;
2876 m_dragItem = (wxTreeListItem*) item.m_pItem;
2877 if (prevItem) RefreshLine (prevItem);
2878 if (m_dragItem) RefreshLine (m_dragItem);
2879 }
2880
2881 void wxTreeListMainWindow::CalculateLineHeight() {
2882 wxClientDC dc (this);
2883 dc.SetFont (m_normalFont);
2884 m_lineHeight = (int)(dc.GetCharHeight() + m_linespacing);
2885
2886 if (m_imageListNormal) {
2887 // Calculate a m_lineHeight value from the normal Image sizes.
2888 // May be toggle off. Then wxTreeListMainWindow will spread when
2889 // necessary (which might look ugly).
2890 int n = m_imageListNormal->GetImageCount();
2891 for (int i = 0; i < n ; i++) {
2892 int width = 0, height = 0;
2893 m_imageListNormal->GetSize(i, width, height);
2894 if (height > m_lineHeight) m_lineHeight = height + m_linespacing;
2895 }
2896 }
2897
2898 if (m_imageListButtons) {
2899 // Calculate a m_lineHeight value from the Button image sizes.
2900 // May be toggle off. Then wxTreeListMainWindow will spread when
2901 // necessary (which might look ugly).
2902 int n = m_imageListButtons->GetImageCount();
2903 for (int i = 0; i < n ; i++) {
2904 int width = 0, height = 0;
2905 m_imageListButtons->GetSize(i, width, height);
2906 if (height > m_lineHeight) m_lineHeight = height + m_linespacing;
2907 }
2908 }
2909
2910 if (m_lineHeight < 30) { // add 10% space if greater than 30 pixels
2911 m_lineHeight += 2; // minimal 2 pixel space
2912 }else{
2913 m_lineHeight += m_lineHeight / 10; // otherwise 10% space
2914 }
2915 }
2916
2917 void wxTreeListMainWindow::SetImageList (wxImageList *imageList) {
2918 if (m_ownsImageListNormal) delete m_imageListNormal;
2919 m_imageListNormal = imageList;
2920 m_ownsImageListNormal = false;
2921 m_dirty = true;
2922 CalculateLineHeight();
2923 }
2924
2925 void wxTreeListMainWindow::SetStateImageList (wxImageList *imageList) {
2926 if (m_ownsImageListState) delete m_imageListState;
2927 m_imageListState = imageList;
2928 m_ownsImageListState = false;
2929 }
2930
2931 void wxTreeListMainWindow::SetButtonsImageList (wxImageList *imageList) {
2932 if (m_ownsImageListButtons) delete m_imageListButtons;
2933 m_imageListButtons = imageList;
2934 m_ownsImageListButtons = false;
2935 m_dirty = true;
2936 CalculateLineHeight();
2937 }
2938
2939 void wxTreeListMainWindow::AssignImageList (wxImageList *imageList) {
2940 SetImageList(imageList);
2941 m_ownsImageListNormal = true;
2942 }
2943
2944 void wxTreeListMainWindow::AssignStateImageList (wxImageList *imageList) {
2945 SetStateImageList(imageList);
2946 m_ownsImageListState = true;
2947 }
2948
2949 void wxTreeListMainWindow::AssignButtonsImageList (wxImageList *imageList) {
2950 SetButtonsImageList(imageList);
2951 m_ownsImageListButtons = true;
2952 }
2953
2954 // ----------------------------------------------------------------------------
2955 // helpers
2956 // ----------------------------------------------------------------------------
2957
2958 void wxTreeListMainWindow::AdjustMyScrollbars() {
2959 if (m_rootItem) {
2960 int xUnit, yUnit;
2961 GetScrollPixelsPerUnit (&xUnit, &yUnit);
2962 if (xUnit == 0) xUnit = GetCharWidth();
2963 if (yUnit == 0) yUnit = m_lineHeight;
2964 int x = 0, y = 0;
2965 m_rootItem->GetSize (x, y, this);
2966 y += yUnit + 2; // one more scrollbar unit + 2 pixels
2967 int x_pos = GetScrollPos (wxHORIZONTAL);
2968 int y_pos = GetScrollPos (wxVERTICAL);
2969 x = m_owner->GetHeaderWindow()->GetWidth() + 2;
2970 if (x < GetClientSize().GetWidth()) x_pos = 0;
2971 SetScrollbars (xUnit, yUnit, x/xUnit, y/yUnit, x_pos, y_pos);
2972 }else{
2973 SetScrollbars (0, 0, 0, 0);
2974 }
2975 }
2976
2977 int wxTreeListMainWindow::GetLineHeight (wxTreeListItem *item) const {
2978 if (GetWindowStyleFlag() & wxTR_HAS_VARIABLE_ROW_HEIGHT) {
2979 return item->GetHeight();
2980 }else{
2981 return m_lineHeight;
2982 }
2983 }
2984
2985 void wxTreeListMainWindow::PaintItem (wxTreeListItem *item, wxDC& dc) {
2986
2987 wxTreeItemAttr *attr = item->GetAttributes();
2988
2989 dc.SetFont (GetItemFont (item));
2990
2991 wxColour colText;
2992 if (attr && attr->HasTextColour()) {
2993 colText = attr->GetTextColour();
2994 }else{
2995 colText = GetForegroundColour();
2996 }
2997 #if !wxCHECK_VERSION(2, 5, 0)
2998 wxColour colTextHilight = wxSystemSettings::GetSystemColour (wxSYS_COLOUR_HIGHLIGHTTEXT);
2999 #else
3000 wxColour colTextHilight = wxSystemSettings::GetColour (wxSYS_COLOUR_HIGHLIGHTTEXT);
3001 #endif
3002
3003 int total_w = m_owner->GetHeaderWindow()->GetWidth();
3004 int total_h = GetLineHeight(item);
3005 int off_h = HasFlag(wxTR_ROW_LINES) ? 1 : 0;
3006 int off_w = HasFlag(wxTR_COLUMN_LINES) ? 1 : 0;
3007 wxDCClipper clipper (dc, 0, item->GetY(), total_w, total_h); // only within line
3008
3009 int text_w = 0, text_h = 0;
3010 dc.GetTextExtent( item->GetText(GetMainColumn()), &text_w, &text_h );
3011
3012 // determine background and show it
3013 wxColour colBg;
3014 if (attr && attr->HasBackgroundColour()) {
3015 colBg = attr->GetBackgroundColour();
3016 }else{
3017 colBg = m_backgroundColour;
3018 }
3019 dc.SetBrush (wxBrush (colBg, wxSOLID));
3020 dc.SetPen (*wxTRANSPARENT_PEN);
3021 if (HasFlag (wxTR_FULL_ROW_HIGHLIGHT)) {
3022 if (item == m_dragItem) {
3023 dc.SetBrush (*m_hilightBrush);
3024 #ifndef __WXMAC__ // don't draw rect outline if we already have the background color
3025 dc.SetPen ((item == m_dragItem)? *wxBLACK_PEN: *wxTRANSPARENT_PEN);
3026 #endif // !__WXMAC__
3027 dc.SetTextForeground (colTextHilight);
3028 }else if (item->IsSelected()) {
3029 if (!m_isDragging && m_hasFocus) {
3030 dc.SetBrush (*m_hilightBrush);
3031 #ifndef __WXMAC__ // don't draw rect outline if we already have the background color
3032 dc.SetPen (*wxBLACK_PEN);
3033 #endif // !__WXMAC__
3034 }else{
3035 dc.SetBrush (*m_hilightUnfocusedBrush);
3036 #ifndef __WXMAC__ // don't draw rect outline if we already have the background color
3037 dc.SetPen (*wxTRANSPARENT_PEN);
3038 #endif // !__WXMAC__
3039 }
3040 dc.SetTextForeground (colTextHilight);
3041 }else if (item == m_curItem) {
3042 dc.SetPen (m_hasFocus? *wxBLACK_PEN: *wxTRANSPARENT_PEN);
3043 }else{
3044 dc.SetTextForeground (colText);
3045 }
3046 dc.DrawRectangle (0, item->GetY() + off_h, total_w, total_h - off_h);
3047 }else{
3048 dc.SetTextForeground (colText);
3049 }
3050
3051 int text_extraH = (total_h > text_h) ? (total_h - text_h)/2 : 0;
3052 int img_extraH = (total_h > m_imgHeight)? (total_h-m_imgHeight)/2: 0;
3053 int x_colstart = 0;
3054 for (int i = 0; i < GetColumnCount(); ++i ) {
3055 if (!m_owner->GetHeaderWindow()->IsColumnShown(i)) continue;
3056
3057 int col_w = m_owner->GetHeaderWindow()->GetColumnWidth(i);
3058 wxDCClipper clipper (dc, x_colstart, item->GetY(), col_w, total_h); // only within column
3059
3060 int x = 0;
3061 int image = NO_IMAGE;
3062 int image_w = 0;
3063 if(i == GetMainColumn()) {
3064 x = item->GetX() + MARGIN;
3065 if (HasButtons()) {
3066 x += (m_btnWidth-m_btnWidth2) + LINEATROOT;
3067 }else{
3068 x -= m_indent/2;
3069 }
3070 if (m_imageListNormal) image = item->GetCurrentImage();
3071 }else{
3072 x = x_colstart + MARGIN;
3073 image = item->GetImage(i);
3074 }
3075 if (image != NO_IMAGE) image_w = m_imgWidth + MARGIN;
3076
3077 // honor text alignment
3078 wxString text = item->GetText(i);
3079 int w = 0;
3080 switch ( m_owner->GetHeaderWindow()->GetColumn(i).GetAlignment() ) {
3081 case wxALIGN_LEFT:
3082 // nothing to do, already left aligned
3083 break;
3084 case wxALIGN_RIGHT:
3085 dc.GetTextExtent (text, &text_w, NULL);
3086 w = col_w - (image_w + text_w + off_w + MARGIN);
3087 x += (w > 0)? w: 0;
3088 break;
3089 case wxALIGN_CENTER:
3090 dc.GetTextExtent(text, &text_w, NULL);
3091 w = (col_w - (image_w + text_w + off_w + MARGIN))/2;
3092 x += (w > 0)? w: 0;
3093 break;
3094 }
3095 int text_x = x + image_w;
3096 if (i == GetMainColumn()) item->SetTextX (text_x);
3097
3098 if (!HasFlag (wxTR_FULL_ROW_HIGHLIGHT)) {
3099 if (i == GetMainColumn()) {
3100 if (item == m_dragItem) {
3101 dc.SetBrush (*m_hilightBrush);
3102 #ifndef __WXMAC__ // don't draw rect outline if we already have the background color
3103 dc.SetPen ((item == m_dragItem)? *wxBLACK_PEN: *wxTRANSPARENT_PEN);
3104 #endif // !__WXMAC__
3105 dc.SetTextForeground (colTextHilight);
3106 }else if (item->IsSelected()) {
3107 if (!m_isDragging && m_hasFocus) {
3108 dc.SetBrush (*m_hilightBrush);
3109 #ifndef __WXMAC__ // don't draw rect outline if we already have the background color
3110 dc.SetPen (*wxBLACK_PEN);
3111 #endif // !__WXMAC__
3112 }else{
3113 dc.SetBrush (*m_hilightUnfocusedBrush);
3114 #ifndef __WXMAC__ // don't draw rect outline if we already have the background color
3115 dc.SetPen (*wxTRANSPARENT_PEN);
3116 #endif // !__WXMAC__
3117 }
3118 dc.SetTextForeground (colTextHilight);
3119 }else if (item == m_curItem) {
3120 dc.SetPen (m_hasFocus? *wxBLACK_PEN: *wxTRANSPARENT_PEN);
3121 }else{
3122 dc.SetTextForeground (colText);
3123 }
3124 dc.DrawRectangle (text_x, item->GetY() + off_h, text_w, total_h - off_h);
3125 }else{
3126 dc.SetTextForeground (colText);
3127 }
3128 }
3129
3130 if (HasFlag(wxTR_COLUMN_LINES)) { // vertical lines between columns
3131 #if !wxCHECK_VERSION(2, 5, 0)
3132 wxPen pen (wxSystemSettings::GetSystemColour (wxSYS_COLOUR_3DLIGHT ), 1, wxSOLID);
3133 #else
3134 wxPen pen (wxSystemSettings::GetColour (wxSYS_COLOUR_3DLIGHT ), 1, wxSOLID);
3135 #endif
3136 dc.SetPen ((GetBackgroundColour() == *wxWHITE)? pen: *wxWHITE_PEN);
3137 dc.DrawLine (x_colstart+col_w-1, item->GetY(), x_colstart+col_w-1, item->GetY()+total_h);
3138 }
3139
3140 dc.SetBackgroundMode (wxTRANSPARENT);
3141
3142 if (image != NO_IMAGE) {
3143 int y = item->GetY() + img_extraH;
3144 m_imageListNormal->Draw (image, dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
3145 }
3146 int text_y = item->GetY() + text_extraH;
3147 dc.DrawText (text, (wxCoord)text_x, (wxCoord)text_y);
3148
3149 x_colstart += col_w;
3150 }
3151
3152 // restore normal font
3153 dc.SetFont( m_normalFont );
3154 }
3155
3156 // Now y stands for the top of the item, whereas it used to stand for middle !
3157 void wxTreeListMainWindow::PaintLevel (wxTreeListItem *item, wxDC &dc,
3158 int level, int &y, int x_maincol) {
3159
3160 // Handle hide root (only level 0)
3161 if (HasFlag(wxTR_HIDE_ROOT) && (level == 0)) {
3162 wxArrayTreeListItems& children = item->GetChildren();
3163 for (size_t n = 0; n < children.Count(); n++) {
3164 PaintLevel (children[n], dc, 1, y, x_maincol);
3165 }
3166 // end after expanding root
3167 return;
3168 }
3169
3170 // calculate position of vertical lines
3171 int x = x_maincol + MARGIN; // start of column
3172 if (HasFlag(wxTR_LINES_AT_ROOT)) x += LINEATROOT; // space for lines at root
3173 if (HasButtons()) {
3174 x += (m_btnWidth-m_btnWidth2); // half button space
3175 }else{
3176 x += (m_indent-m_indent/2);
3177 }
3178 if (HasFlag(wxTR_HIDE_ROOT)) {
3179 x += m_indent * (level-1); // indent but not level 1
3180 }else{
3181 x += m_indent * level; // indent according to level
3182 }
3183
3184 // set position of vertical line
3185 item->SetX (x);
3186 item->SetY (y);
3187
3188 int h = GetLineHeight (item);
3189 int y_top = y;
3190 int y_mid = y_top + (h/2);
3191 y += h;
3192
3193 int exposed_x = dc.LogicalToDeviceX(0);
3194 int exposed_y = dc.LogicalToDeviceY(y_top);
3195
3196 if (IsExposed(exposed_x, exposed_y, 10000, h)) { // 10000 = very much
3197
3198 if (HasFlag(wxTR_ROW_LINES)) { // horizontal lines between rows
3199 //dc.DestroyClippingRegion();
3200 int total_width = m_owner->GetHeaderWindow()->GetWidth();
3201 // if the background colour is white, choose a
3202 // contrasting color for the lines
3203 #if !wxCHECK_VERSION(2, 5, 0)
3204 wxPen pen (wxSystemSettings::GetSystemColour (wxSYS_COLOUR_3DLIGHT ), 1, wxSOLID);
3205 #else
3206 wxPen pen (wxSystemSettings::GetColour (wxSYS_COLOUR_3DLIGHT ), 1, wxSOLID);
3207 #endif
3208 dc.SetPen ((GetBackgroundColour() == *wxWHITE)? pen: *wxWHITE_PEN);
3209 dc.DrawLine (0, y_top, total_width, y_top);
3210 dc.DrawLine (0, y_top+h, total_width, y_top+h);
3211 }
3212
3213 // draw item
3214 PaintItem (item, dc);
3215
3216 // restore DC objects
3217 dc.SetBrush(*wxWHITE_BRUSH);
3218 dc.SetPen(m_dottedPen);
3219
3220 // clip to the column width
3221 int clip_width = m_owner->GetHeaderWindow()->
3222 GetColumn(m_main_column).GetWidth();
3223 wxDCClipper clipper(dc, x_maincol, y_top, clip_width, 10000);
3224
3225 if (!HasFlag(wxTR_NO_LINES)) { // connection lines
3226
3227 // draw the horizontal line here
3228 dc.SetPen(m_dottedPen);
3229 int x2 = x - m_indent;
3230 if (x2 < (x_maincol + MARGIN)) x2 = x_maincol + MARGIN;
3231 int x3 = x + (m_btnWidth-m_btnWidth2);
3232 if (HasButtons()) {
3233 if (item->HasPlus()) {
3234 dc.DrawLine (x2, y_mid, x - m_btnWidth2, y_mid);
3235 dc.DrawLine (x3, y_mid, x3 + LINEATROOT, y_mid);
3236 }else{
3237 dc.DrawLine (x2, y_mid, x3 + LINEATROOT, y_mid);
3238 }
3239 }else{
3240 dc.DrawLine (x2, y_mid, x - m_indent/2, y_mid);
3241 }
3242 }
3243
3244 if (item->HasPlus() && HasButtons()) { // should the item show a button?
3245
3246 if (m_imageListButtons) {
3247
3248 // draw the image button here
3249 int image = wxTreeItemIcon_Normal;
3250 if (item->IsExpanded()) image = wxTreeItemIcon_Expanded;
3251 if (item->IsSelected()) image += wxTreeItemIcon_Selected - wxTreeItemIcon_Normal;
3252 int xx = x - m_btnWidth2 + MARGIN;
3253 int yy = y_mid - m_btnHeight2;
3254 dc.SetClippingRegion(xx, yy, m_btnWidth, m_btnHeight);
3255 m_imageListButtons->Draw (image, dc, xx, yy, wxIMAGELIST_DRAW_TRANSPARENT);
3256 dc.DestroyClippingRegion();
3257
3258 }else if (HasFlag (wxTR_TWIST_BUTTONS)) {
3259
3260 // draw the twisty button here
3261 dc.SetPen(*wxBLACK_PEN);
3262 dc.SetBrush(*m_hilightBrush);
3263 wxPoint button[3];
3264 if (item->IsExpanded()) {
3265 button[0].x = x - (m_btnWidth2+1);
3266 button[0].y = y_mid - (m_btnHeight/3);
3267 button[1].x = x + (m_btnWidth2+1);
3268 button[1].y = button[0].y;
3269 button[2].x = x;
3270 button[2].y = button[0].y + (m_btnHeight2+1);
3271 }else{
3272 button[0].x = x - (m_btnWidth/3);
3273 button[0].y = y_mid - (m_btnHeight2+1);
3274 button[1].x = button[0].x;
3275 button[1].y = y_mid + (m_btnHeight2+1);
3276 button[2].x = button[0].x + (m_btnWidth2+1);
3277 button[2].y = y_mid;
3278 }
3279 dc.DrawPolygon(3, button);
3280
3281 }else{ // if (HasFlag(wxTR_HAS_BUTTONS))
3282
3283 // draw the plus sign here
3284 #if !wxCHECK_VERSION(2, 7, 0)
3285 dc.SetPen(*wxGREY_PEN);
3286 dc.SetBrush(*wxWHITE_BRUSH);
3287 dc.DrawRectangle (x-m_btnWidth2, y_mid-m_btnHeight2, m_btnWidth, m_btnHeight);
3288 dc.SetPen(*wxBLACK_PEN);
3289 dc.DrawLine (x-(m_btnWidth2-2), y_mid, x+(m_btnWidth2-1), y_mid);
3290 if (!item->IsExpanded()) { // change "-" to "+"
3291 dc.DrawLine (x, y_mid-(m_btnHeight2-2), x, y_mid+(m_btnHeight2-1));
3292 }
3293 #else
3294 wxRect rect (x-m_btnWidth2, y_mid-m_btnHeight2, m_btnWidth, m_btnHeight);
3295 int flag = item->IsExpanded()? wxCONTROL_EXPANDED: 0;
3296 wxRendererNative::GetDefault().DrawTreeItemButton (this, dc, rect, flag);
3297 #endif
3298
3299 }
3300
3301 }
3302
3303 }
3304
3305 // restore DC objects
3306 dc.SetBrush(*wxWHITE_BRUSH);
3307 dc.SetPen(m_dottedPen);
3308 dc.SetTextForeground(*wxBLACK);
3309
3310 if (item->IsExpanded())
3311 {
3312 wxArrayTreeListItems& children = item->GetChildren();
3313
3314 // clip to the column width
3315 int clip_width = m_owner->GetHeaderWindow()->
3316 GetColumn(m_main_column).GetWidth();
3317
3318 // process lower levels
3319 int oldY;
3320 if (m_imgWidth > 0) {
3321 oldY = y_mid + m_imgHeight2;
3322 }else{
3323 oldY = y_mid + h/2;
3324 }
3325 int y2;
3326 for (size_t n = 0; n < children.Count(); ++n) {
3327
3328 y2 = y + h/2;
3329 PaintLevel (children[n], dc, level+1, y, x_maincol);
3330
3331 // draw vertical line
3332 wxDCClipper clipper(dc, x_maincol, y_top, clip_width, 10000);
3333 if (!HasFlag (wxTR_NO_LINES)) {
3334 x = item->GetX();
3335 dc.DrawLine (x, oldY, x, y2);
3336 oldY = y2;
3337 }
3338 }
3339 }
3340 }
3341
3342
3343 // ----------------------------------------------------------------------------
3344 // wxWindows callbacks
3345 // ----------------------------------------------------------------------------
3346
3347 void wxTreeListMainWindow::OnPaint (wxPaintEvent &WXUNUSED(event)) {
3348
3349 wxPaintDC dc (this);
3350 PrepareDC (dc);
3351
3352 if (!m_rootItem || (GetColumnCount() <= 0)) return;
3353
3354 // calculate button size
3355 if (m_imageListButtons) {
3356 m_imageListButtons->GetSize (0, m_btnWidth, m_btnHeight);
3357 }else if (HasButtons()) {
3358 m_btnWidth = BTNWIDTH;
3359 m_btnHeight = BTNHEIGHT;
3360 }
3361 m_btnWidth2 = m_btnWidth/2;
3362 m_btnHeight2 = m_btnHeight/2;
3363
3364 // calculate image size
3365 if (m_imageListNormal) {
3366 m_imageListNormal->GetSize (0, m_imgWidth, m_imgHeight);
3367 }
3368 m_imgWidth2 = m_imgWidth/2;
3369 m_imgHeight2 = m_imgHeight/2;
3370
3371 // calculate indent size
3372 if (m_imageListButtons) {
3373 m_indent = wxMax (MININDENT, m_btnWidth + MARGIN);
3374 }else if (HasButtons()) {
3375 m_indent = wxMax (MININDENT, m_btnWidth + LINEATROOT);
3376 }
3377
3378 // set default values
3379 dc.SetFont( m_normalFont );
3380 dc.SetPen( m_dottedPen );
3381
3382 // calculate column start and paint
3383 int x_maincol = 0;
3384 int i = 0;
3385 for (i = 0; i < (int)GetMainColumn(); ++i) {
3386 if (!m_owner->GetHeaderWindow()->IsColumnShown(i)) continue;
3387 x_maincol += m_owner->GetHeaderWindow()->GetColumnWidth (i);
3388 }
3389 int y = 0;
3390 PaintLevel (m_rootItem, dc, 0, y, x_maincol);
3391 }
3392
3393 void wxTreeListMainWindow::OnSetFocus (wxFocusEvent &event) {
3394
3395 m_hasFocus = true;
3396 RefreshSelected();
3397 if (m_curItem) RefreshLine (m_curItem);
3398 event.Skip();
3399 }
3400
3401 void wxTreeListMainWindow::OnKillFocus( wxFocusEvent &event )
3402 {
3403 m_hasFocus = false;
3404 RefreshSelected();
3405 if (m_curItem) RefreshLine (m_curItem);
3406 event.Skip();
3407 }
3408
3409 void wxTreeListMainWindow::OnChar (wxKeyEvent &event) {
3410 // send event to user code
3411 wxTreeEvent nevent (wxEVT_COMMAND_TREE_KEY_DOWN, m_owner->GetId());
3412 nevent.SetKeyEvent (event);
3413 nevent.SetEventObject (m_owner);
3414 if (m_owner->GetEventHandler()->ProcessEvent (nevent)) return; // handled in user code
3415
3416 // determine first current if none
3417 bool curItemSet = false;
3418 if (!m_curItem) {
3419 m_curItem = (wxTreeListItem*)GetRootItem().m_pItem;
3420 if (HasFlag(wxTR_HIDE_ROOT)) {
3421 #if !wxCHECK_VERSION(2, 5, 0)
3422 long cookie = 0;
3423 #else
3424 wxTreeItemIdValue cookie = 0;
3425 #endif
3426 m_curItem = (wxTreeListItem*)GetFirstChild (m_curItem, cookie).m_pItem;
3427 }
3428 curItemSet = true;
3429 }
3430 if (!m_curItem) return; // do nothing if empty tree
3431
3432 // remember item at shift down
3433 if (HasFlag(wxTR_MULTIPLE) && event.ShiftDown()) {
3434 if (!m_shiftItem) m_shiftItem = m_curItem;
3435 }else{
3436 m_shiftItem = (wxTreeListItem*)NULL;
3437 }
3438
3439 // process all cases
3440 wxTreeItemId newItem = (wxTreeItemId*)NULL;
3441 switch (event.GetKeyCode()) {
3442
3443 // '+': Expand subtree
3444 case '+':
3445 case WXK_ADD: {
3446 if (m_curItem->HasPlus() && !IsExpanded (m_curItem)) Expand (m_curItem);
3447 }break;
3448
3449 // '-': collapse subtree
3450 case '-':
3451 case WXK_SUBTRACT: {
3452 if (m_curItem->HasPlus() && IsExpanded (m_curItem)) Collapse (m_curItem);
3453 }break;
3454
3455 // '*': expand/collapse all subtrees // TODO: Mak it more useful
3456 case '*':
3457 case WXK_MULTIPLY: {
3458 if (m_curItem->HasPlus() && !IsExpanded (m_curItem)) {
3459 ExpandAll (m_curItem);
3460 }else if (m_curItem->HasPlus()) {
3461 Collapse (m_curItem); // TODO: CollapseAll
3462 }
3463 }break;
3464
3465 // ' ': toggle current item
3466 case ' ': {
3467 SelectItem (m_curItem, (wxTreeListItem*)NULL, false);
3468 }break;
3469
3470 // <RETURN>: activate current item
3471 case WXK_RETURN: {
3472 wxTreeEvent aevent (wxEVT_COMMAND_TREE_ITEM_ACTIVATED, m_owner->GetId());
3473 #if !wxCHECK_VERSION(2, 5, 0)
3474 aevent.SetItem ((long)m_curItem);
3475 #else
3476 aevent.SetItem (m_curItem);
3477 #endif
3478 aevent.SetEventObject (m_owner);
3479 m_owner->GetEventHandler()->ProcessEvent (aevent);
3480 }break;
3481
3482 // <BKSP>: go to the parent without collapsing
3483 case WXK_BACK: {
3484 newItem = GetItemParent (m_curItem);
3485 if ((newItem == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT)) {
3486 newItem = GetPrevSibling (m_curItem); // get sibling instead of root
3487 }
3488 }break;
3489
3490 // <UP>: go to the previous sibling or to the last of its children, to the parent
3491 case WXK_UP: {
3492 newItem = GetPrevSibling (m_curItem);
3493 if (newItem) {
3494 #if !wxCHECK_VERSION(2, 5, 0)
3495 long cookie = 0;
3496 #else
3497 wxTreeItemIdValue cookie = 0;
3498 #endif
3499 while (IsExpanded (newItem) && HasChildren (newItem)) {
3500 newItem = GetLastChild (newItem, cookie);
3501 }
3502 }else {
3503 newItem = GetItemParent (m_curItem);
3504 if ((newItem == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT)) {
3505 newItem = (wxTreeItemId*)NULL; // don't go to root if it is hidden
3506 }
3507 }
3508 }break;
3509
3510 // <LEFT>: if expanded collapse subtree, else go to the parent
3511 case WXK_LEFT: {
3512 if (IsExpanded (m_curItem)) {
3513 Collapse (m_curItem);
3514 }else{
3515 newItem = GetItemParent (m_curItem);
3516 if ((newItem == GetRootItem()) && HasFlag(wxTR_HIDE_ROOT)) {
3517 newItem = GetPrevSibling (m_curItem); // go to sibling if it is hidden
3518 }
3519 }
3520 }break;
3521
3522 // <RIGHT>: if possible expand subtree, else go go to the first child
3523 case WXK_RIGHT: {
3524 if (m_curItem->HasPlus() && !IsExpanded (m_curItem)) {
3525 Expand (m_curItem);
3526 }else{
3527 if (IsExpanded (m_curItem) && HasChildren (m_curItem)) {
3528 #if !wxCHECK_VERSION(2, 5, 0)
3529 long cookie = 0;
3530 #else
3531 wxTreeItemIdValue cookie = 0;
3532 #endif
3533 newItem = GetFirstChild (m_curItem, cookie);
3534 }
3535 }
3536 }break;
3537
3538 // <DOWN>: if expanded go to the first child, else to the next sibling, ect
3539 case WXK_DOWN: {
3540 if (curItemSet) {
3541 newItem = m_curItem;
3542 }else{
3543 if (IsExpanded (m_curItem) && HasChildren (m_curItem)) {
3544 #if !wxCHECK_VERSION(2, 5, 0)
3545 long cookie = 0;
3546 #else
3547 wxTreeItemIdValue cookie = 0;
3548 #endif
3549 newItem = GetFirstChild( m_curItem, cookie );
3550 }
3551 if (!newItem) {
3552 wxTreeItemId parent = m_curItem;
3553 do {
3554 newItem = GetNextSibling (parent);
3555 parent = GetItemParent (parent);
3556 } while (!newItem && parent);
3557 }
3558 }
3559 }break;
3560
3561 // <END>: go to last item of the root
3562 case WXK_END: {
3563 #if !wxCHECK_VERSION(2, 5, 0)
3564 long cookie = 0;
3565 #else
3566 wxTreeItemIdValue cookie = 0;
3567 #endif
3568 newItem = GetLastChild (GetRootItem(), cookie);
3569 }break;
3570
3571 // <HOME>: go to root
3572 case WXK_HOME: {
3573 newItem = GetRootItem();
3574 if (HasFlag(wxTR_HIDE_ROOT)) {
3575 #if !wxCHECK_VERSION(2, 5, 0)
3576 long cookie = 0;
3577 #else
3578 wxTreeItemIdValue cookie = 0;
3579 #endif
3580 newItem = GetFirstChild (newItem, cookie);
3581 }
3582 }break;
3583
3584 // any char: go to the next matching string
3585 default:
3586 if (event.GetKeyCode() >= (int)' ') {
3587 if (!m_findTimer->IsRunning()) m_findStr.Clear();
3588 m_findStr.Append (event.GetKeyCode());
3589 m_findTimer->Start (FIND_TIMER_TICKS, wxTIMER_ONE_SHOT);
3590 wxTreeItemId prev = m_curItem? (wxTreeItemId*)m_curItem: (wxTreeItemId*)NULL;
3591 while (true) {
3592 newItem = FindItem (prev, m_findStr, wxTL_MODE_NAV_EXPANDED |
3593 wxTL_MODE_FIND_PARTIAL |
3594 wxTL_MODE_FIND_NOCASE);
3595 if (newItem || (m_findStr.Length() <= 1)) break;
3596 m_findStr.RemoveLast();
3597 };
3598 }
3599 event.Skip();
3600
3601 }
3602
3603 // select and show the new item
3604 if (newItem) {
3605 if (!event.ControlDown()) {
3606 bool unselect_others = !((event.ShiftDown() || event.ControlDown()) &&
3607 HasFlag(wxTR_MULTIPLE));
3608 SelectItem (newItem, m_shiftItem, unselect_others);
3609 }
3610 EnsureVisible (newItem);
3611 wxTreeListItem *oldItem = m_curItem;
3612 m_curItem = (wxTreeListItem*)newItem.m_pItem; // make the new item the current item
3613 RefreshLine (oldItem);
3614 }
3615
3616 }
3617
3618 wxTreeItemId wxTreeListMainWindow::HitTest (const wxPoint& point, int& flags, int& column) {
3619
3620 int w, h;
3621 GetSize(&w, &h);
3622 flags=0;
3623 column = -1;
3624 if (point.x<0) flags |= wxTREE_HITTEST_TOLEFT;
3625 if (point.x>w) flags |= wxTREE_HITTEST_TORIGHT;
3626 if (point.y<0) flags |= wxTREE_HITTEST_ABOVE;
3627 if (point.y>h) flags |= wxTREE_HITTEST_BELOW;
3628 if (flags) return wxTreeItemId();
3629
3630 if (!m_rootItem) {
3631 flags = wxTREE_HITTEST_NOWHERE;
3632 column = -1;
3633 return wxTreeItemId();
3634 }
3635
3636 wxTreeListItem *hit = m_rootItem->HitTest (CalcUnscrolledPosition(point),
3637 this, flags, column, 0);
3638 if (!hit) {
3639 flags = wxTREE_HITTEST_NOWHERE;
3640 column = -1;
3641 return wxTreeItemId();
3642 }
3643 return hit;
3644 }
3645
3646 // get the bounding rectangle of the item (or of its label only)
3647 bool wxTreeListMainWindow::GetBoundingRect (const wxTreeItemId& itemId, wxRect& rect,
3648 bool WXUNUSED(textOnly)) const {
3649 wxCHECK_MSG (itemId.IsOk(), false, _T("invalid item in wxTreeListMainWindow::GetBoundingRect") );
3650
3651 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
3652
3653 int xUnit, yUnit;
3654 GetScrollPixelsPerUnit (&xUnit, &yUnit);
3655 int startX, startY;
3656 GetViewStart(& startX, & startY);
3657
3658 rect.x = item->GetX() - startX * xUnit;
3659 rect.y = item->GetY() - startY * yUnit;
3660 rect.width = item->GetWidth();
3661 rect.height = GetLineHeight (item);
3662
3663 return true;
3664 }
3665
3666 /* **** */
3667
3668 void wxTreeListMainWindow::EditLabel (const wxTreeItemId& item, int column) {
3669 if (!item.IsOk()) return;
3670 if (!((column >= 0) && (column < GetColumnCount()))) return;
3671
3672 m_editItem = (wxTreeListItem*) item.m_pItem;
3673
3674 wxTreeEvent te( wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, m_owner->GetId() );
3675 #if !wxCHECK_VERSION(2, 5, 0)
3676 te.SetItem ((long)m_editItem);
3677 #else
3678 te.SetItem (m_editItem);
3679 #endif
3680 te.SetInt (column);
3681 te.SetEventObject (m_owner );
3682 m_owner->GetEventHandler()->ProcessEvent (te);
3683
3684 if (!te.IsAllowed()) return;
3685
3686 // ensure that the position of the item it calculated in any case
3687 if (m_dirty) CalculatePositions();
3688
3689 wxTreeListHeaderWindow* header_win = m_owner->GetHeaderWindow();
3690 int x = 0;
3691 int y = m_editItem->GetY() + 1; // wxTextCtrl needs 1 pixels above the text
3692 int w = 0;
3693 int h = m_editItem->GetHeight();
3694 long style = 0;
3695 if (column == GetMainColumn()) {
3696 x += m_editItem->GetTextX() - 2; // wxTextCtrl needs 2 pixels before the text
3697 w = wxMin (m_editItem->GetWidth(), m_owner->GetHeaderWindow()->GetWidth() - x);
3698 }else{
3699 for (int i = 0; i < column; ++i) x += header_win->GetColumnWidth (i); // start of column
3700 switch (header_win->GetColumnAlignment (column)) {
3701 case wxALIGN_LEFT: {style = wxTE_LEFT; break;}
3702 case wxALIGN_RIGHT: {style = wxTE_RIGHT; break;}
3703 case wxALIGN_CENTER: {style = wxTE_CENTER; break;}
3704 }
3705 w = header_win->GetColumnWidth (column); // width of column
3706 }
3707
3708 wxClientDC dc (this);
3709 PrepareDC (dc);
3710 x = dc.LogicalToDeviceX (x);
3711 y = dc.LogicalToDeviceY (y);
3712
3713 wxEditTextCtrl *text = new wxEditTextCtrl (this, -1, &m_renameAccept, &m_renameRes,
3714 this, m_editItem->GetText (column),
3715 wxPoint (x, y), wxSize (w, h), style);
3716 text->SetFocus();
3717 }
3718
3719 void wxTreeListMainWindow::OnRenameTimer() {
3720 EditLabel (m_curItem, m_curColumn);
3721 }
3722
3723 void wxTreeListMainWindow::OnRenameAccept() {
3724
3725 // TODO if the validator fails this causes a crash
3726 wxTreeEvent le( wxEVT_COMMAND_TREE_END_LABEL_EDIT, m_owner->GetId() );
3727 #if !wxCHECK_VERSION(2, 5, 0)
3728 le.SetItem((long)m_editItem);
3729 #else
3730 le.SetItem(m_editItem);
3731 #endif
3732 le.SetEventObject( /*this*/m_owner );
3733 le.SetLabel( m_renameRes );
3734 m_owner->GetEventHandler()->ProcessEvent( le );
3735
3736 if (!le.IsAllowed()) return;
3737
3738 SetItemText (m_editItem, m_curColumn, m_renameRes);
3739 }
3740
3741 void wxTreeListMainWindow::OnMouse (wxMouseEvent &event) {
3742 if (!m_rootItem) return;
3743
3744 // we process left mouse up event (enables in-place edit), right down
3745 // (pass to the user code), left dbl click (activate item) and
3746 // dragging/moving events for items drag-and-drop
3747 if (!(event.LeftDown() ||
3748 event.LeftUp() ||
3749 event.RightDown() ||
3750 event.RightUp() ||
3751 event.LeftDClick() ||
3752 event.Dragging() ||
3753 (event.GetWheelRotation() != 0 )/*? TODO ||
3754 event.Moving()?*/)) {
3755 m_owner->GetEventHandler()->ProcessEvent (event);
3756 return;
3757 }
3758
3759 // set focus if window clicked
3760 if (event.LeftDown() || event.RightDown()) SetFocus();
3761
3762 // determine event
3763 wxPoint p = wxPoint (event.GetX(), event.GetY());
3764 int flags = 0;
3765 wxTreeListItem *item = m_rootItem->HitTest (CalcUnscrolledPosition (p),
3766 this, flags, m_curColumn, 0);
3767
3768 // we only process dragging here
3769 if (event.Dragging()){
3770 if (m_isDragging) return; // nothing to do, already done
3771 if (item == NULL) return; // we need an item to dragging
3772
3773 // determine drag start
3774 if (m_dragCount == 0) {
3775 m_dragTimer->Start (DRAG_TIMER_TICKS, wxTIMER_ONE_SHOT);
3776 }
3777 m_dragCount++;
3778 if (m_dragCount < 3) return; // minimum drag 3 pixel
3779 if (m_dragTimer->IsRunning()) return;
3780
3781 // we're going to drag
3782 m_dragCount = 0;
3783 m_isDragging = true;
3784 CaptureMouse();
3785 RefreshSelected();
3786
3787 // send drag start event
3788 wxEventType command = event.LeftIsDown()
3789 ? wxEVT_COMMAND_TREE_BEGIN_DRAG
3790 : wxEVT_COMMAND_TREE_BEGIN_RDRAG;
3791 wxTreeEvent nevent (command, m_owner->GetId());
3792 nevent.SetEventObject (m_owner);
3793 #if !wxCHECK_VERSION(2, 5, 0)
3794 nevent.SetItem ((long)item); // the item the drag is ended
3795 #else
3796 nevent.SetItem (item); // the item the drag is ended
3797 #endif
3798 nevent.Veto(); // dragging must be explicit allowed!
3799 m_owner->GetEventHandler()->ProcessEvent (nevent);
3800
3801 }else if (m_isDragging) { // any other event but not event.Dragging()
3802
3803 // end dragging
3804 m_dragCount = 0;
3805 m_isDragging = false;
3806 if (HasCapture()) ReleaseMouse();
3807 RefreshSelected();
3808
3809 // send drag end event event
3810 wxTreeEvent nevent (wxEVT_COMMAND_TREE_END_DRAG, m_owner->GetId());
3811 nevent.SetEventObject (m_owner);
3812 #if !wxCHECK_VERSION(2, 5, 0)
3813 nevent.SetItem ((long)item); // the item the drag is started
3814 #else
3815 nevent.SetItem (item); // the item the drag is started
3816 #endif
3817 nevent.SetPoint (p);
3818 m_owner->GetEventHandler()->ProcessEvent (nevent);
3819
3820 }else if (m_dragCount > 0) { // just in case dragging is initiated
3821
3822 // end dragging
3823 m_dragCount = 0;
3824
3825 }
3826
3827 // we process only the messages which happen on tree items
3828 if (item == NULL) {
3829 m_owner->GetEventHandler()->ProcessEvent (event);
3830 return;
3831 }
3832
3833 // remember item at shift down
3834 if (event.ShiftDown()) {
3835 if (!m_shiftItem) m_shiftItem = m_curItem;
3836 }else{
3837 m_shiftItem = (wxTreeListItem*)NULL;
3838 }
3839
3840 if (event.RightUp()) {
3841
3842 SetFocus();
3843 wxTreeEvent nevent (wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, m_owner->GetId());
3844 nevent.SetEventObject (m_owner);
3845 #if !wxCHECK_VERSION(2, 5, 0)
3846 nevent.SetItem ((long)item); // the item clicked
3847 #else
3848 nevent.SetItem (item); // the item clicked
3849 #endif
3850 nevent.SetInt (m_curColumn); // the colum clicked
3851 nevent.SetPoint (p);
3852 m_owner->GetEventHandler()->ProcessEvent (nevent);
3853
3854 }else if (event.LeftUp()) {
3855
3856 if (m_lastOnSame) {
3857 if ((item == m_curItem) && (m_curColumn != -1) &&
3858 (m_owner->GetHeaderWindow()->IsColumnEditable (m_curColumn)) &&
3859 (flags & (wxTREE_HITTEST_ONITEMLABEL | wxTREE_HITTEST_ONITEMCOLUMN))){
3860 m_renameTimer->Start (RENAME_TIMER_TICKS, wxTIMER_ONE_SHOT);
3861 }
3862 m_lastOnSame = false;
3863 }
3864
3865 if (((flags & wxTREE_HITTEST_ONITEMBUTTON) ||
3866 (flags & wxTREE_HITTEST_ONITEMICON)) &&
3867 HasButtons() && item->HasPlus()) {
3868
3869 // only toggle the item for a single click, double click on
3870 // the button doesn't do anything (it toggles the item twice)
3871 if (event.LeftDown()) Toggle (item);
3872
3873 // don't select the item if the button was clicked
3874 return;
3875 }
3876
3877 // determine the selection if not done by left down
3878 if (!m_left_down_selection) {
3879 bool unselect_others = !((event.ShiftDown() || event.ControlDown()) &&
3880 HasFlag(wxTR_MULTIPLE));
3881 SelectItem (item, m_shiftItem, unselect_others);
3882 EnsureVisible (item);
3883 m_curItem = item; // make the new item the current item
3884 }else{
3885 m_left_down_selection = false;
3886 }
3887
3888 }else if (event.LeftDown() || event.RightDown() || event.LeftDClick()) {
3889
3890 if (event.LeftDown() || event.RightDown()) {
3891 SetFocus();
3892 m_lastOnSame = item == m_curItem;
3893 }
3894
3895 if (((flags & wxTREE_HITTEST_ONITEMBUTTON) ||
3896 (flags & wxTREE_HITTEST_ONITEMICON)) &&
3897 item->HasPlus()) {
3898
3899 // only toggle the item for a single click, double click on
3900 // the button doesn't do anything (it toggles the item twice)
3901 if (event.LeftDown()) Toggle (item);
3902
3903 // don't select the item if the button was clicked
3904 return;
3905 }
3906
3907 // determine the selection if the current item is not selected
3908 if (!item->IsSelected()) {
3909 bool unselect_others = !((event.ShiftDown() || event.ControlDown()) &&
3910 HasFlag(wxTR_MULTIPLE));
3911 SelectItem (item, m_shiftItem, unselect_others);
3912 EnsureVisible (item);
3913 m_curItem = item; // make the new item the current item
3914 m_left_down_selection = true;
3915 }
3916
3917 // For some reason, Windows isn't recognizing a left double-click,
3918 // so we need to simulate it here. Allow 200 milliseconds for now.
3919 if (event.LeftDClick()) {
3920
3921 // double clicking should not start editing the item label
3922 m_renameTimer->Stop();
3923 m_lastOnSame = false;
3924
3925 // send activate event first
3926 wxTreeEvent nevent (wxEVT_COMMAND_TREE_ITEM_ACTIVATED, m_owner->GetId());
3927 nevent.SetEventObject (m_owner);
3928 #if !wxCHECK_VERSION(2, 5, 0)
3929 nevent.SetItem ((long)item); // the item clicked
3930 #else
3931 nevent.SetItem (item); // the item clicked
3932 #endif
3933 nevent.SetInt (m_curColumn); // the colum clicked
3934 nevent.SetPoint (p);
3935 if (!m_owner->GetEventHandler()->ProcessEvent (nevent)) {
3936
3937 // if the user code didn't process the activate event,
3938 // handle it ourselves by toggling the item when it is
3939 // double clicked
3940 if (item->HasPlus()) Toggle(item);
3941 }
3942 }
3943
3944 }else{ // any other event skip just in case
3945
3946 event.Skip();
3947
3948 }
3949 }
3950
3951 void wxTreeListMainWindow::OnIdle (wxIdleEvent &WXUNUSED(event)) {
3952 /* after all changes have been done to the tree control,
3953 * we actually redraw the tree when everything is over */
3954
3955 if (!m_dirty) return;
3956
3957 m_dirty = false;
3958
3959 CalculatePositions();
3960 Refresh();
3961 AdjustMyScrollbars();
3962 }
3963
3964 void wxTreeListMainWindow::OnScroll (wxScrollWinEvent& event) {
3965 // FIXME
3966 #if defined(__WXGTK__) && !defined(__WXUNIVERSAL__)
3967 wxScrolledWindow::OnScroll(event);
3968 #else
3969 HandleOnScroll( event );
3970 #endif
3971
3972 if(event.GetOrientation() == wxHORIZONTAL) {
3973 m_owner->GetHeaderWindow()->Refresh();
3974 m_owner->GetHeaderWindow()->Update();
3975 }
3976 }
3977
3978 void wxTreeListMainWindow::CalculateSize (wxTreeListItem *item, wxDC &dc) {
3979 wxCoord text_w = 0;
3980 wxCoord text_h = 0;
3981
3982 dc.SetFont (GetItemFont (item));
3983
3984 dc.GetTextExtent (item->GetText (m_main_column), &text_w, &text_h);
3985
3986 // restore normal font
3987 dc.SetFont (m_normalFont);
3988
3989 int total_h = (m_imgHeight > text_h) ? m_imgHeight : text_h;
3990 if (total_h < 30) { // add 10% space if greater than 30 pixels
3991 total_h += 2; // minimal 2 pixel space
3992 }else{
3993 total_h += total_h / 10; // otherwise 10% space
3994 }
3995
3996 item->SetHeight (total_h);
3997 if (total_h > m_lineHeight) m_lineHeight = total_h;
3998 item->SetWidth(m_imgWidth + text_w+2);
3999 }
4000
4001 // -----------------------------------------------------------------------------
4002 void wxTreeListMainWindow::CalculateLevel (wxTreeListItem *item, wxDC &dc,
4003 int level, int &y, int x_colstart) {
4004
4005 // calculate position of vertical lines
4006 int x = x_colstart + MARGIN; // start of column
4007 if (HasFlag(wxTR_LINES_AT_ROOT)) x += LINEATROOT; // space for lines at root
4008 if (HasButtons()) {
4009 x += (m_btnWidth-m_btnWidth2); // half button space
4010 }else{
4011 x += (m_indent-m_indent/2);
4012 }
4013 if (HasFlag(wxTR_HIDE_ROOT)) {
4014 x += m_indent * (level-1); // indent but not level 1
4015 }else{
4016 x += m_indent * level; // indent according to level
4017 }
4018
4019 // a hidden root is not evaluated, but its children are always
4020 if (HasFlag(wxTR_HIDE_ROOT) && (level == 0)) goto Recurse;
4021
4022 CalculateSize( item, dc );
4023
4024 // set its position
4025 item->SetX (x);
4026 item->SetY (y);
4027 y += GetLineHeight(item);
4028
4029 // we don't need to calculate collapsed branches
4030 if ( !item->IsExpanded() ) return;
4031
4032 Recurse:
4033 wxArrayTreeListItems& children = item->GetChildren();
4034 long n, count = (long)children.Count();
4035 ++level;
4036 for (n = 0; n < count; ++n) {
4037 CalculateLevel( children[n], dc, level, y, x_colstart ); // recurse
4038 }
4039 }
4040
4041 void wxTreeListMainWindow::CalculatePositions() {
4042 if ( !m_rootItem ) return;
4043
4044 wxClientDC dc(this);
4045 PrepareDC( dc );
4046
4047 dc.SetFont( m_normalFont );
4048
4049 dc.SetPen( m_dottedPen );
4050 //if(GetImageList() == NULL)
4051 // m_lineHeight = (int)(dc.GetCharHeight() + 4);
4052
4053 int y = 2;
4054 int x_colstart = 0;
4055 for (int i = 0; i < (int)GetMainColumn(); ++i) {
4056 if (!m_owner->GetHeaderWindow()->IsColumnShown(i)) continue;
4057 x_colstart += m_owner->GetHeaderWindow()->GetColumnWidth(i);
4058 }
4059 CalculateLevel( m_rootItem, dc, 0, y, x_colstart ); // start recursion
4060 }
4061
4062 void wxTreeListMainWindow::RefreshSubtree (wxTreeListItem *item) {
4063 if (m_dirty) return;
4064
4065 wxClientDC dc(this);
4066 PrepareDC(dc);
4067
4068 int cw = 0;
4069 int ch = 0;
4070 GetVirtualSize( &cw, &ch );
4071
4072 wxRect rect;
4073 rect.x = dc.LogicalToDeviceX( 0 );
4074 rect.width = cw;
4075 rect.y = dc.LogicalToDeviceY( item->GetY() - 2 );
4076 rect.height = ch;
4077
4078 Refresh (true, &rect );
4079 AdjustMyScrollbars();
4080 }
4081
4082 void wxTreeListMainWindow::RefreshLine (wxTreeListItem *item) {
4083 if (m_dirty) return;
4084
4085 wxClientDC dc(this);
4086 PrepareDC( dc );
4087
4088 int cw = 0;
4089 int ch = 0;
4090 GetVirtualSize( &cw, &ch );
4091
4092 wxRect rect;
4093 rect.x = dc.LogicalToDeviceX( 0 );
4094 rect.y = dc.LogicalToDeviceY( item->GetY() );
4095 rect.width = cw;
4096 rect.height = GetLineHeight(item); //dc.GetCharHeight() + 6;
4097
4098 Refresh (true, &rect);
4099 }
4100
4101 void wxTreeListMainWindow::RefreshSelected() {
4102 // TODO: this is awfully inefficient, we should keep the list of all
4103 // selected items internally, should be much faster
4104 if (m_rootItem) {
4105 RefreshSelectedUnder (m_rootItem);
4106 }
4107 }
4108
4109 void wxTreeListMainWindow::RefreshSelectedUnder (wxTreeListItem *item) {
4110 if (item->IsSelected()) {
4111 RefreshLine (item);
4112 }
4113
4114 const wxArrayTreeListItems& children = item->GetChildren();
4115 long count = children.GetCount();
4116 for (long n = 0; n < count; n++ ) {
4117 RefreshSelectedUnder (children[n]);
4118 }
4119 }
4120
4121 // ----------------------------------------------------------------------------
4122 // changing colours: we need to refresh the tree control
4123 // ----------------------------------------------------------------------------
4124
4125 bool wxTreeListMainWindow::SetBackgroundColour (const wxColour& colour) {
4126 if (!wxWindow::SetBackgroundColour(colour)) return false;
4127
4128 Refresh();
4129 return true;
4130 }
4131
4132 bool wxTreeListMainWindow::SetForegroundColour (const wxColour& colour) {
4133 if (!wxWindow::SetForegroundColour(colour)) return false;
4134
4135 Refresh();
4136 return true;
4137 }
4138
4139 void wxTreeListMainWindow::SetItemText (const wxTreeItemId& itemId, int column,
4140 const wxString& text) {
4141 wxCHECK_RET (itemId.IsOk(), _T("invalid tree item"));
4142
4143 wxClientDC dc (this);
4144 wxTreeListItem *item = (wxTreeListItem*) itemId.m_pItem;
4145 item->SetText (column, text);
4146 CalculateSize (item, dc);
4147 RefreshLine (item);
4148 }
4149
4150 wxString wxTreeListMainWindow::GetItemText (const wxTreeItemId& itemId,
4151 int column) const {
4152 wxCHECK_MSG (itemId.IsOk(), _T(""), _T("invalid tree item") );
4153
4154 if( IsVirtual() ) return m_owner->OnGetItemText(((wxTreeListItem*) itemId.m_pItem)->GetData(),column);
4155 else return ((wxTreeListItem*) itemId.m_pItem)->GetText (column);
4156 }
4157
4158 wxString wxTreeListMainWindow::GetItemText (wxTreeItemData* item,
4159 int column) const {
4160 wxASSERT_MSG( IsVirtual(), _T("can be used only with virtual control") );
4161 return m_owner->OnGetItemText(item,column);
4162 }
4163
4164 void wxTreeListMainWindow::SetFocus() {
4165 wxWindow::SetFocus();
4166 }
4167
4168 wxFont wxTreeListMainWindow::GetItemFont (wxTreeListItem *item) {
4169 wxTreeItemAttr *attr = item->GetAttributes();
4170
4171 if (attr && attr->HasFont()) {
4172 return attr->GetFont();
4173 }else if (item->IsBold()) {
4174 return m_boldFont;
4175 }else{
4176 return m_normalFont;
4177 }
4178 }
4179
4180 int wxTreeListMainWindow::GetItemWidth (int column, wxTreeListItem *item) {
4181 if (!item) return 0;
4182
4183 // determine item width
4184 int w = 0, h = 0;
4185 wxFont font = GetItemFont (item);
4186 GetTextExtent (item->GetText (column), &w, &h, NULL, NULL, font.Ok()? &font: NULL);
4187 w += 2*MARGIN;
4188
4189 // calculate width
4190 int width = w + 2*MARGIN;
4191 if (column == GetMainColumn()) {
4192 width += MARGIN;
4193 if (HasFlag(wxTR_LINES_AT_ROOT)) width += LINEATROOT;
4194 if (HasButtons()) width += m_btnWidth + LINEATROOT;
4195 if (item->GetCurrentImage() != NO_IMAGE) width += m_imgWidth;
4196
4197 // count indent level
4198 int level = 0;
4199 wxTreeListItem *parent = item->GetItemParent();
4200 wxTreeListItem *root = (wxTreeListItem*)GetRootItem().m_pItem;
4201 while (parent && (!HasFlag(wxTR_HIDE_ROOT) || (parent != root))) {
4202 level++;
4203 parent = parent->GetItemParent();
4204 }
4205 if (level) width += level * GetIndent();
4206 }
4207
4208 return width;
4209 }
4210
4211 int wxTreeListMainWindow::GetBestColumnWidth (int column, wxTreeItemId parent) {
4212 int maxWidth, h;
4213 GetClientSize (&maxWidth, &h);
4214 int width = 0;
4215
4216 // get root if on item
4217 if (!parent.IsOk()) parent = GetRootItem();
4218
4219 // add root width
4220 if (!HasFlag(wxTR_HIDE_ROOT)) {
4221 int w = GetItemWidth (column, (wxTreeListItem*)parent.m_pItem);
4222 if (width < w) width = w;
4223 if (width > maxWidth) return maxWidth;
4224 }
4225
4226 wxTreeItemIdValue cookie = 0;
4227 wxTreeItemId item = GetFirstChild (parent, cookie);
4228 while (item.IsOk()) {
4229 int w = GetItemWidth (column, (wxTreeListItem*)item.m_pItem);
4230 if (width < w) width = w;
4231 if (width > maxWidth) return maxWidth;
4232
4233 // check the children of this item
4234 if (((wxTreeListItem*)item.m_pItem)->IsExpanded()) {
4235 int w = GetBestColumnWidth (column, item);
4236 if (width < w) width = w;
4237 if (width > maxWidth) return maxWidth;
4238 }
4239
4240 // next sibling
4241 item = GetNextChild (parent, cookie);
4242 }
4243
4244 return width;
4245 }
4246
4247
4248 //-----------------------------------------------------------------------------
4249 // wxTreeListCtrl
4250 //-----------------------------------------------------------------------------
4251
4252 IMPLEMENT_DYNAMIC_CLASS(wxTreeListCtrl, wxControl);
4253
4254 BEGIN_EVENT_TABLE(wxTreeListCtrl, wxControl)
4255 EVT_SIZE(wxTreeListCtrl::OnSize)
4256 END_EVENT_TABLE();
4257
4258 bool wxTreeListCtrl::Create(wxWindow *parent, wxWindowID id,
4259 const wxPoint& pos,
4260 const wxSize& size,
4261 long style, const wxValidator &validator,
4262 const wxString& name)
4263 {
4264 long main_style = style & ~(wxSIMPLE_BORDER|wxSUNKEN_BORDER|wxDOUBLE_BORDER|
4265 wxRAISED_BORDER|wxSTATIC_BORDER);
4266 long ctrl_style = style & ~(wxVSCROLL|wxHSCROLL);
4267
4268 if (!wxControl::Create(parent, id, pos, size, ctrl_style, validator, name)) {
4269 return false;
4270 }
4271 m_main_win = new wxTreeListMainWindow (this, -1, wxPoint(0, 0), size,
4272 main_style, validator);
4273 m_header_win = new wxTreeListHeaderWindow (this, -1, m_main_win,
4274 wxPoint(0, 0), wxDefaultSize,
4275 wxTAB_TRAVERSAL);
4276 CalculateAndSetHeaderHeight();
4277 return true;
4278 }
4279
4280 void wxTreeListCtrl::CalculateAndSetHeaderHeight()
4281 {
4282 if (m_header_win) {
4283 int h;
4284 #if wxCHECK_VERSION_FULL(2, 7, 0, 1)
4285 h = wxRendererNative::Get().GetHeaderButtonHeight(m_header_win);
4286 #else
4287 // we use 'g' to get the descent, too
4288 int w, d;
4289 m_header_win->GetTextExtent(_T("Hg"), &w, &h, &d);
4290 h += d + 2 * HEADER_OFFSET_Y + EXTRA_HEIGHT;
4291 #endif
4292 // only update if changed
4293 if (h != m_headerHeight) {
4294 m_headerHeight = h;
4295 DoHeaderLayout();
4296 }
4297 }
4298 }
4299
4300 void wxTreeListCtrl::DoHeaderLayout()
4301 {
4302 int w, h;
4303 GetClientSize(&w, &h);
4304 if (m_header_win) {
4305 m_header_win->SetSize (0, 0, w, m_headerHeight);
4306 m_header_win->Refresh();
4307 }
4308 if (m_main_win) {
4309 m_main_win->SetSize (0, m_headerHeight + 1, w, h - m_headerHeight - 1);
4310 }
4311 }
4312
4313 void wxTreeListCtrl::OnSize(wxSizeEvent& WXUNUSED(event))
4314 {
4315 DoHeaderLayout();
4316 }
4317
4318 size_t wxTreeListCtrl::GetCount() const { return m_main_win->GetCount(); }
4319
4320 unsigned int wxTreeListCtrl::GetIndent() const
4321 { return m_main_win->GetIndent(); }
4322
4323 void wxTreeListCtrl::SetIndent(unsigned int indent)
4324 { m_main_win->SetIndent(indent); }
4325
4326 unsigned int wxTreeListCtrl::GetLineSpacing() const
4327 { return m_main_win->GetLineSpacing(); }
4328
4329 void wxTreeListCtrl::SetLineSpacing(unsigned int spacing)
4330 { m_main_win->SetLineSpacing(spacing); }
4331
4332 wxImageList* wxTreeListCtrl::GetImageList() const
4333 { return m_main_win->GetImageList(); }
4334
4335 wxImageList* wxTreeListCtrl::GetStateImageList() const
4336 { return m_main_win->GetStateImageList(); }
4337
4338 wxImageList* wxTreeListCtrl::GetButtonsImageList() const
4339 { return m_main_win->GetButtonsImageList(); }
4340
4341 void wxTreeListCtrl::SetImageList(wxImageList* imageList)
4342 { m_main_win->SetImageList(imageList); }
4343
4344 void wxTreeListCtrl::SetStateImageList(wxImageList* imageList)
4345 { m_main_win->SetStateImageList(imageList); }
4346
4347 void wxTreeListCtrl::SetButtonsImageList(wxImageList* imageList)
4348 { m_main_win->SetButtonsImageList(imageList); }
4349
4350 void wxTreeListCtrl::AssignImageList(wxImageList* imageList)
4351 { m_main_win->AssignImageList(imageList); }
4352
4353 void wxTreeListCtrl::AssignStateImageList(wxImageList* imageList)
4354 { m_main_win->AssignStateImageList(imageList); }
4355
4356 void wxTreeListCtrl::AssignButtonsImageList(wxImageList* imageList)
4357 { m_main_win->AssignButtonsImageList(imageList); }
4358
4359 wxString wxTreeListCtrl::GetItemText(const wxTreeItemId& item, int column) const
4360 { return m_main_win->GetItemText (item, column); }
4361
4362 int wxTreeListCtrl::GetItemImage(const wxTreeItemId& item, int column,
4363 wxTreeItemIcon which) const
4364 { return m_main_win->GetItemImage(item, column, which); }
4365
4366 wxTreeItemData* wxTreeListCtrl::GetItemData(const wxTreeItemId& item) const
4367 { return m_main_win->GetItemData(item); }
4368
4369 bool wxTreeListCtrl::GetItemBold(const wxTreeItemId& item) const
4370 { return m_main_win->GetItemBold(item); }
4371
4372 wxColour wxTreeListCtrl::GetItemTextColour(const wxTreeItemId& item) const
4373 { return m_main_win->GetItemTextColour(item); }
4374
4375 wxColour wxTreeListCtrl::GetItemBackgroundColour(const wxTreeItemId& item)
4376 const
4377 { return m_main_win->GetItemBackgroundColour(item); }
4378
4379 wxFont wxTreeListCtrl::GetItemFont(const wxTreeItemId& item) const
4380 { return m_main_win->GetItemFont(item); }
4381
4382
4383 void wxTreeListCtrl::SetItemText(const wxTreeItemId& item, int column,
4384 const wxString& text)
4385 { m_main_win->SetItemText (item, column, text); }
4386
4387 void wxTreeListCtrl::SetItemImage(const wxTreeItemId& item,
4388 int column,
4389 int image,
4390 wxTreeItemIcon which)
4391 { m_main_win->SetItemImage(item, column, image, which); }
4392
4393 void wxTreeListCtrl::SetItemData(const wxTreeItemId& item,
4394 wxTreeItemData* data)
4395 { m_main_win->SetItemData(item, data); }
4396
4397 void wxTreeListCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
4398 { m_main_win->SetItemHasChildren(item, has); }
4399
4400 void wxTreeListCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
4401 { m_main_win->SetItemBold(item, bold); }
4402
4403 void wxTreeListCtrl::SetItemTextColour(const wxTreeItemId& item,
4404 const wxColour& colour)
4405 { m_main_win->SetItemTextColour(item, colour); }
4406
4407 void wxTreeListCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
4408 const wxColour& colour)
4409 { m_main_win->SetItemBackgroundColour(item, colour); }
4410
4411 void wxTreeListCtrl::SetItemFont(const wxTreeItemId& item,
4412 const wxFont& font)
4413 { m_main_win->SetItemFont(item, font); }
4414
4415 bool wxTreeListCtrl::SetFont(const wxFont& font)
4416 {
4417 if (m_header_win) {
4418 m_header_win->SetFont(font);
4419 CalculateAndSetHeaderHeight();
4420 m_header_win->Refresh();
4421 }
4422 if (m_main_win) {
4423 return m_main_win->SetFont(font);
4424 }else{
4425 return false;
4426 }
4427 }
4428
4429 void wxTreeListCtrl::SetWindowStyle(const long style)
4430 {
4431 if(m_main_win)
4432 m_main_win->SetWindowStyle(style);
4433 m_windowStyle = style;
4434 // TODO: provide something like wxTL_NO_HEADERS to hide m_header_win
4435 }
4436
4437 long wxTreeListCtrl::GetWindowStyle() const
4438 {
4439 long style = m_windowStyle;
4440 if(m_main_win)
4441 style |= m_main_win->GetWindowStyle();
4442 return style;
4443 }
4444
4445 bool wxTreeListCtrl::IsVisible(const wxTreeItemId& item, bool fullRow) const
4446 { return m_main_win->IsVisible(item, fullRow); }
4447
4448 bool wxTreeListCtrl::HasChildren(const wxTreeItemId& item) const
4449 { return m_main_win->HasChildren(item); }
4450
4451 bool wxTreeListCtrl::IsExpanded(const wxTreeItemId& item) const
4452 { return m_main_win->IsExpanded(item); }
4453
4454 bool wxTreeListCtrl::IsSelected(const wxTreeItemId& item) const
4455 { return m_main_win->IsSelected(item); }
4456
4457 bool wxTreeListCtrl::IsBold(const wxTreeItemId& item) const
4458 { return m_main_win->IsBold(item); }
4459
4460 size_t wxTreeListCtrl::GetChildrenCount(const wxTreeItemId& item, bool rec)
4461 { return m_main_win->GetChildrenCount(item, rec); }
4462
4463 wxTreeItemId wxTreeListCtrl::GetRootItem() const
4464 { return m_main_win->GetRootItem(); }
4465
4466 wxTreeItemId wxTreeListCtrl::GetSelection() const
4467 { return m_main_win->GetSelection(); }
4468
4469 size_t wxTreeListCtrl::GetSelections(wxArrayTreeItemIds& arr) const
4470 { return m_main_win->GetSelections(arr); }
4471
4472 wxTreeItemId wxTreeListCtrl::GetItemParent(const wxTreeItemId& item) const
4473 { return m_main_win->GetItemParent(item); }
4474
4475 #if !wxCHECK_VERSION(2, 5, 0)
4476 wxTreeItemId wxTreeListCtrl::GetFirstChild (const wxTreeItemId& item,
4477 long& cookie) const
4478 #else
4479 wxTreeItemId wxTreeListCtrl::GetFirstChild (const wxTreeItemId& item,
4480 wxTreeItemIdValue& cookie) const
4481 #endif
4482 { return m_main_win->GetFirstChild(item, cookie); }
4483
4484 #if !wxCHECK_VERSION(2, 5, 0)
4485 wxTreeItemId wxTreeListCtrl::GetNextChild (const wxTreeItemId& item,
4486 long& cookie) const
4487 #else
4488 wxTreeItemId wxTreeListCtrl::GetNextChild (const wxTreeItemId& item,
4489 wxTreeItemIdValue& cookie) const
4490 #endif
4491 { return m_main_win->GetNextChild(item, cookie); }
4492
4493 #if !wxCHECK_VERSION(2, 5, 0)
4494 wxTreeItemId wxTreeListCtrl::GetPrevChild (const wxTreeItemId& item,
4495 long& cookie) const
4496 #else
4497 wxTreeItemId wxTreeListCtrl::GetPrevChild (const wxTreeItemId& item,
4498 wxTreeItemIdValue& cookie) const
4499 #endif
4500 { return m_main_win->GetPrevChild(item, cookie); }
4501
4502 #if !wxCHECK_VERSION(2, 5, 0)
4503 wxTreeItemId wxTreeListCtrl::GetLastChild (const wxTreeItemId& item,
4504 long& cookie) const
4505 #else
4506 wxTreeItemId wxTreeListCtrl::GetLastChild (const wxTreeItemId& item,
4507 wxTreeItemIdValue& cookie) const
4508 #endif
4509 { return m_main_win->GetLastChild(item, cookie); }
4510
4511
4512 wxTreeItemId wxTreeListCtrl::GetNextSibling(const wxTreeItemId& item) const
4513 { return m_main_win->GetNextSibling(item); }
4514
4515 wxTreeItemId wxTreeListCtrl::GetPrevSibling(const wxTreeItemId& item) const
4516 { return m_main_win->GetPrevSibling(item); }
4517
4518 wxTreeItemId wxTreeListCtrl::GetNext(const wxTreeItemId& item) const
4519 { return m_main_win->GetNext(item, true); }
4520
4521 wxTreeItemId wxTreeListCtrl::GetPrev(const wxTreeItemId& item) const
4522 { return m_main_win->GetPrev(item, true); }
4523
4524 wxTreeItemId wxTreeListCtrl::GetFirstExpandedItem() const
4525 { return m_main_win->GetFirstExpandedItem(); }
4526
4527 wxTreeItemId wxTreeListCtrl::GetNextExpanded(const wxTreeItemId& item) const
4528 { return m_main_win->GetNextExpanded(item); }
4529
4530 wxTreeItemId wxTreeListCtrl::GetPrevExpanded(const wxTreeItemId& item) const
4531 { return m_main_win->GetPrevExpanded(item); }
4532
4533 wxTreeItemId wxTreeListCtrl::GetFirstVisibleItem(bool fullRow) const
4534 { return m_main_win->GetFirstVisibleItem(fullRow); }
4535
4536 wxTreeItemId wxTreeListCtrl::GetNextVisible(const wxTreeItemId& item, bool fullRow) const
4537 { return m_main_win->GetNextVisible(item, fullRow); }
4538
4539 wxTreeItemId wxTreeListCtrl::GetPrevVisible(const wxTreeItemId& item, bool fullRow) const
4540 { return m_main_win->GetPrevVisible(item, fullRow); }
4541
4542 wxTreeItemId wxTreeListCtrl::AddRoot (const wxString& text, int image,
4543 int selectedImage, wxTreeItemData* data)
4544 { return m_main_win->AddRoot (text, image, selectedImage, data); }
4545
4546 wxTreeItemId wxTreeListCtrl::PrependItem(const wxTreeItemId& parent,
4547 const wxString& text, int image,
4548 int selectedImage,
4549 wxTreeItemData* data)
4550 { return m_main_win->PrependItem(parent, text, image, selectedImage, data); }
4551
4552 wxTreeItemId wxTreeListCtrl::InsertItem(const wxTreeItemId& parent,
4553 const wxTreeItemId& previous,
4554 const wxString& text, int image,
4555 int selectedImage,
4556 wxTreeItemData* data)
4557 {
4558 return m_main_win->InsertItem(parent, previous, text, image,
4559 selectedImage, data);
4560 }
4561
4562 wxTreeItemId wxTreeListCtrl::InsertItem(const wxTreeItemId& parent,
4563 size_t index,
4564 const wxString& text, int image,
4565 int selectedImage,
4566 wxTreeItemData* data)
4567 {
4568 return m_main_win->InsertItem(parent, index, text, image,
4569 selectedImage, data);
4570 }
4571
4572 wxTreeItemId wxTreeListCtrl::AppendItem(const wxTreeItemId& parent,
4573 const wxString& text, int image,
4574 int selectedImage,
4575 wxTreeItemData* data)
4576 { return m_main_win->AppendItem(parent, text, image, selectedImage, data); }
4577
4578 void wxTreeListCtrl::Delete(const wxTreeItemId& item)
4579 { m_main_win->Delete(item); }
4580
4581 void wxTreeListCtrl::DeleteChildren(const wxTreeItemId& item)
4582 { m_main_win->DeleteChildren(item); }
4583
4584 void wxTreeListCtrl::DeleteRoot()
4585 { m_main_win->DeleteRoot(); }
4586
4587 void wxTreeListCtrl::Expand(const wxTreeItemId& item)
4588 { m_main_win->Expand(item); }
4589
4590 void wxTreeListCtrl::ExpandAll(const wxTreeItemId& item)
4591 { m_main_win->ExpandAll(item); }
4592
4593 void wxTreeListCtrl::Collapse(const wxTreeItemId& item)
4594 { m_main_win->Collapse(item); }
4595
4596 void wxTreeListCtrl::CollapseAndReset(const wxTreeItemId& item)
4597 { m_main_win->CollapseAndReset(item); }
4598
4599 void wxTreeListCtrl::Toggle(const wxTreeItemId& item)
4600 { m_main_win->Toggle(item); }
4601
4602 void wxTreeListCtrl::Unselect()
4603 { m_main_win->Unselect(); }
4604
4605 void wxTreeListCtrl::UnselectAll()
4606 { m_main_win->UnselectAll(); }
4607
4608 void wxTreeListCtrl::SelectItem(const wxTreeItemId& item, const wxTreeItemId& last,
4609 bool unselect_others)
4610 { m_main_win->SelectItem (item, last, unselect_others); }
4611
4612 void wxTreeListCtrl::SelectAll()
4613 { m_main_win->SelectAll(); }
4614
4615 void wxTreeListCtrl::EnsureVisible(const wxTreeItemId& item)
4616 { m_main_win->EnsureVisible(item); }
4617
4618 void wxTreeListCtrl::ScrollTo(const wxTreeItemId& item)
4619 { m_main_win->ScrollTo(item); }
4620
4621 wxTreeItemId wxTreeListCtrl::HitTest(const wxPoint& pos, int& flags, int& column)
4622 {
4623 wxPoint p = m_main_win->ScreenToClient (ClientToScreen (pos));
4624 return m_main_win->HitTest (p, flags, column);
4625 }
4626
4627 bool wxTreeListCtrl::GetBoundingRect(const wxTreeItemId& item, wxRect& rect,
4628 bool textOnly) const
4629 { return m_main_win->GetBoundingRect(item, rect, textOnly); }
4630
4631 void wxTreeListCtrl::EditLabel (const wxTreeItemId& item, int column)
4632 { m_main_win->EditLabel (item, column); }
4633
4634 int wxTreeListCtrl::OnCompareItems(const wxTreeItemId& item1,
4635 const wxTreeItemId& item2)
4636 {
4637 // do the comparison here, and not delegate to m_main_win, in order
4638 // to let the user override it
4639 //return m_main_win->OnCompareItems(item1, item2);
4640 return wxStrcmp(GetItemText(item1), GetItemText(item2));
4641 }
4642
4643 void wxTreeListCtrl::SortChildren(const wxTreeItemId& item)
4644 { m_main_win->SortChildren(item); }
4645
4646 wxTreeItemId wxTreeListCtrl::FindItem (const wxTreeItemId& item, const wxString& str, int mode)
4647 { return m_main_win->FindItem (item, str, mode); }
4648
4649 void wxTreeListCtrl::SetDragItem (const wxTreeItemId& item)
4650 { m_main_win->SetDragItem (item); }
4651
4652 bool wxTreeListCtrl::SetBackgroundColour(const wxColour& colour)
4653 {
4654 if (!m_main_win) return false;
4655 return m_main_win->SetBackgroundColour(colour);
4656 }
4657
4658 bool wxTreeListCtrl::SetForegroundColour(const wxColour& colour)
4659 {
4660 if (!m_main_win) return false;
4661 return m_main_win->SetForegroundColour(colour);
4662 }
4663
4664 int wxTreeListCtrl::GetColumnCount() const
4665 { return m_main_win->GetColumnCount(); }
4666
4667 void wxTreeListCtrl::SetColumnWidth(int column, int width)
4668 {
4669 m_header_win->SetColumnWidth (column, width);
4670 m_header_win->Refresh();
4671 }
4672
4673 int wxTreeListCtrl::GetColumnWidth(int column) const
4674 { return m_header_win->GetColumnWidth(column); }
4675
4676 void wxTreeListCtrl::SetMainColumn(int column)
4677 { m_main_win->SetMainColumn(column); }
4678
4679 int wxTreeListCtrl::GetMainColumn() const
4680 { return m_main_win->GetMainColumn(); }
4681
4682 void wxTreeListCtrl::SetColumnText(int column, const wxString& text)
4683 {
4684 m_header_win->SetColumnText (column, text);
4685 m_header_win->Refresh();
4686 }
4687
4688 wxString wxTreeListCtrl::GetColumnText(int column) const
4689 { return m_header_win->GetColumnText(column); }
4690
4691 void wxTreeListCtrl::AddColumn(const wxTreeListColumnInfo& colInfo)
4692 {
4693 m_header_win->AddColumn (colInfo);
4694 DoHeaderLayout();
4695 }
4696
4697 void wxTreeListCtrl::InsertColumn(int before, const wxTreeListColumnInfo& colInfo)
4698 {
4699 m_header_win->InsertColumn (before, colInfo);
4700 m_header_win->Refresh();
4701 }
4702
4703 void wxTreeListCtrl::RemoveColumn(int column)
4704 {
4705 m_header_win->RemoveColumn (column);
4706 m_header_win->Refresh();
4707 }
4708
4709 void wxTreeListCtrl::SetColumn(int column, const wxTreeListColumnInfo& colInfo)
4710 {
4711 m_header_win->SetColumn (column, colInfo);
4712 m_header_win->Refresh();
4713 }
4714
4715 const wxTreeListColumnInfo& wxTreeListCtrl::GetColumn(int column) const
4716 { return m_header_win->GetColumn(column); }
4717
4718 wxTreeListColumnInfo& wxTreeListCtrl::GetColumn(int column)
4719 { return m_header_win->GetColumn(column); }
4720
4721 void wxTreeListCtrl::SetColumnImage(int column, int image)
4722 {
4723 m_header_win->SetColumn (column, GetColumn(column).SetImage(image));
4724 m_header_win->Refresh();
4725 }
4726
4727 int wxTreeListCtrl::GetColumnImage(int column) const
4728 {
4729 return m_header_win->GetColumn(column).GetImage();
4730 }
4731
4732 void wxTreeListCtrl::SetColumnEditable(int column, bool shown)
4733 {
4734 m_header_win->SetColumn (column, GetColumn(column).SetEditable(shown));
4735 }
4736
4737 void wxTreeListCtrl::SetColumnShown(int column, bool shown)
4738 {
4739 wxASSERT_MSG (column != GetMainColumn(), _T("The main column may not be hidden") );
4740 m_header_win->SetColumn (column, GetColumn(column).SetShown(GetMainColumn()==column? true: shown));
4741 m_header_win->Refresh();
4742 }
4743
4744 bool wxTreeListCtrl::IsColumnEditable(int column) const
4745 {
4746 return m_header_win->GetColumn(column).IsEditable();
4747 }
4748
4749 bool wxTreeListCtrl::IsColumnShown(int column) const
4750 {
4751 return m_header_win->GetColumn(column).IsShown();
4752 }
4753
4754 void wxTreeListCtrl::SetColumnAlignment (int column, int flag)
4755 {
4756 m_header_win->SetColumn(column, GetColumn(column).SetAlignment(flag));
4757 m_header_win->Refresh();
4758 }
4759
4760 int wxTreeListCtrl::GetColumnAlignment(int column) const
4761 {
4762 return m_header_win->GetColumn(column).GetAlignment();
4763 }
4764
4765 void wxTreeListCtrl::Refresh(bool erase, const wxRect* rect)
4766 {
4767 m_main_win->Refresh (erase, rect);
4768 m_header_win->Refresh (erase, rect);
4769 }
4770
4771 void wxTreeListCtrl::SetFocus()
4772 { m_main_win->SetFocus(); }
4773
4774 wxSize wxTreeListCtrl::DoGetBestSize() const
4775 {
4776 // something is better than nothing...
4777 return wxSize (200,200); // but it should be specified values! FIXME
4778 }
4779
4780 wxString wxTreeListCtrl::OnGetItemText( wxTreeItemData* WXUNUSED(item), long WXUNUSED(column)) const
4781 {
4782 return wxEmptyString;
4783 }
wxWidgets (Impactor)