]> git.saurik.com Git - wxWidgets.git/blob - src/msw/treectrl.cpp
Applied another Marco patch (5)
[wxWidgets.git] / src / msw / treectrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/treectrl.cpp
3 // Purpose: wxTreeCtrl
4 // Author: Julian Smart
5 // Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98
6 // Created: 1997
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "treectrl.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #if wxUSE_TREECTRL
32
33 #include "wx/msw/private.h"
34
35 // Set this to 1 to be _absolutely_ sure that repainting will work for all
36 // comctl32.dll versions
37 #define wxUSE_COMCTL32_SAFELY 0
38
39 // Mingw32 is a bit mental even though this is done in winundef
40 #ifdef GetFirstChild
41 #undef GetFirstChild
42 #endif
43
44 #ifdef GetNextSibling
45 #undef GetNextSibling
46 #endif
47
48 #if defined(__WIN95__)
49
50 #include "wx/app.h"
51 #include "wx/log.h"
52 #include "wx/dynarray.h"
53 #include "wx/imaglist.h"
54 #include "wx/settings.h"
55 #include "wx/msw/treectrl.h"
56 #include "wx/msw/dragimag.h"
57
58 #ifdef __GNUWIN32_OLD__
59 #include "wx/msw/gnuwin32/extra.h"
60 #endif
61
62 #if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__)) && !defined(__CYGWIN10__))
63 #include <commctrl.h>
64 #endif
65
66 // Bug in headers, sometimes
67 #ifndef TVIS_FOCUSED
68 #define TVIS_FOCUSED 0x0001
69 #endif
70
71 #ifndef TV_FIRST
72 #define TV_FIRST 0x1100
73 #endif
74
75 #ifndef TVS_CHECKBOXES
76 #define TVS_CHECKBOXES 0x0100
77 #endif
78
79 #ifndef TVS_FULLROWSELECT
80 #define TVS_FULLROWSELECT 0x1000
81 #endif
82
83 // old headers might miss these messages (comctl32.dll 4.71+ only)
84 #ifndef TVM_SETBKCOLOR
85 #define TVM_SETBKCOLOR (TV_FIRST + 29)
86 #define TVM_SETTEXTCOLOR (TV_FIRST + 30)
87 #endif
88
89 // a macro to hide the ugliness of nested casts
90 #define HITEM(item) (HTREEITEM)(WXHTREEITEM)(item)
91
92 // the native control doesn't support multiple selections under MSW and we
93 // have 2 ways to emulate them: either using TVS_CHECKBOXES style and let
94 // checkboxes be the selection status (checked == selected) or by really
95 // emulating everything, i.e. intercepting mouse and key events &c. The first
96 // approach is much easier but doesn't work with comctl32.dll < 4.71 and also
97 // looks quite ugly.
98 #define wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE 0
99
100 // ----------------------------------------------------------------------------
101 // private functions
102 // ----------------------------------------------------------------------------
103
104 // wrapper for TreeView_HitTest
105 static HTREEITEM GetItemFromPoint(HWND hwndTV, int x, int y)
106 {
107 TV_HITTESTINFO tvht;
108 tvht.pt.x = x;
109 tvht.pt.y = y;
110
111 return (HTREEITEM)TreeView_HitTest(hwndTV, &tvht);
112 }
113
114 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
115
116 // wrappers for TreeView_GetItem/TreeView_SetItem
117 static bool IsItemSelected(HWND hwndTV, HTREEITEM hItem)
118 {
119
120 TV_ITEM tvi;
121 tvi.mask = TVIF_STATE | TVIF_HANDLE;
122 tvi.stateMask = TVIS_SELECTED;
123 tvi.hItem = hItem;
124
125 if ( !TreeView_GetItem(hwndTV, &tvi) )
126 {
127 wxLogLastError(wxT("TreeView_GetItem"));
128 }
129
130 return (tvi.state & TVIS_SELECTED) != 0;
131 }
132
133 static void SelectItem(HWND hwndTV, HTREEITEM hItem, bool select = TRUE)
134 {
135 TV_ITEM tvi;
136 tvi.mask = TVIF_STATE | TVIF_HANDLE;
137 tvi.stateMask = TVIS_SELECTED;
138 tvi.state = select ? TVIS_SELECTED : 0;
139 tvi.hItem = hItem;
140
141 if ( TreeView_SetItem(hwndTV, &tvi) == -1 )
142 {
143 wxLogLastError(wxT("TreeView_SetItem"));
144 }
145 }
146
147 static inline void UnselectItem(HWND hwndTV, HTREEITEM htItem)
148 {
149 SelectItem(hwndTV, htItem, FALSE);
150 }
151
152 static inline void ToggleItemSelection(HWND hwndTV, HTREEITEM htItem)
153 {
154 SelectItem(hwndTV, htItem, !IsItemSelected(hwndTV, htItem));
155 }
156
157 // helper function which selects all items in a range and, optionally,
158 // unselects all others
159 static void SelectRange(HWND hwndTV,
160 HTREEITEM htFirst,
161 HTREEITEM htLast,
162 bool unselectOthers = TRUE)
163 {
164 // find the first (or last) item and select it
165 bool cont = TRUE;
166 HTREEITEM htItem = (HTREEITEM)TreeView_GetRoot(hwndTV);
167 while ( htItem && cont )
168 {
169 if ( (htItem == htFirst) || (htItem == htLast) )
170 {
171 if ( !IsItemSelected(hwndTV, htItem) )
172 {
173 SelectItem(hwndTV, htItem);
174 }
175
176 cont = FALSE;
177 }
178 else
179 {
180 if ( unselectOthers && IsItemSelected(hwndTV, htItem) )
181 {
182 UnselectItem(hwndTV, htItem);
183 }
184 }
185
186 htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
187 }
188
189 // select the items in range
190 cont = htFirst != htLast;
191 while ( htItem && cont )
192 {
193 if ( !IsItemSelected(hwndTV, htItem) )
194 {
195 SelectItem(hwndTV, htItem);
196 }
197
198 cont = (htItem != htFirst) && (htItem != htLast);
199
200 htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
201 }
202
203 // unselect the rest
204 if ( unselectOthers )
205 {
206 while ( htItem )
207 {
208 if ( IsItemSelected(hwndTV, htItem) )
209 {
210 UnselectItem(hwndTV, htItem);
211 }
212
213 htItem = (HTREEITEM)TreeView_GetNextVisible(hwndTV, htItem);
214 }
215 }
216
217 // seems to be necessary - otherwise the just selected items don't always
218 // appear as selected
219 UpdateWindow(hwndTV);
220 }
221
222 // helper function which tricks the standard control into changing the focused
223 // item without changing anything else (if someone knows why Microsoft doesn't
224 // allow to do it by just setting TVIS_FOCUSED flag, please tell me!)
225 static void SetFocus(HWND hwndTV, HTREEITEM htItem)
226 {
227 // the current focus
228 HTREEITEM htFocus = (HTREEITEM)TreeView_GetSelection(hwndTV);
229
230 if ( htItem )
231 {
232 // set the focus
233 if ( htItem != htFocus )
234 {
235 // remember the selection state of the item
236 bool wasSelected = IsItemSelected(hwndTV, htItem);
237
238 if ( htFocus && IsItemSelected(hwndTV, htFocus) )
239 {
240 // prevent the tree from unselecting the old focus which it
241 // would do by default (TreeView_SelectItem unselects the
242 // focused item)
243 TreeView_SelectItem(hwndTV, 0);
244 SelectItem(hwndTV, htFocus);
245 }
246
247 TreeView_SelectItem(hwndTV, htItem);
248
249 if ( !wasSelected )
250 {
251 // need to clear the selection which TreeView_SelectItem() gave
252 // us
253 UnselectItem(hwndTV, htItem);
254 }
255 //else: was selected, still selected - ok
256 }
257 //else: nothing to do, focus already there
258 }
259 else
260 {
261 if ( htFocus )
262 {
263 bool wasFocusSelected = IsItemSelected(hwndTV, htFocus);
264
265 // just clear the focus
266 TreeView_SelectItem(hwndTV, 0);
267
268 if ( wasFocusSelected )
269 {
270 // restore the selection state
271 SelectItem(hwndTV, htFocus);
272 }
273 }
274 //else: nothing to do, no focus already
275 }
276 }
277
278 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
279
280 // ----------------------------------------------------------------------------
281 // private classes
282 // ----------------------------------------------------------------------------
283
284 // a convenient wrapper around TV_ITEM struct which adds a ctor
285 #ifdef __VISUALC__
286 #pragma warning( disable : 4097 ) // inheriting from typedef
287 #endif
288
289 struct wxTreeViewItem : public TV_ITEM
290 {
291 wxTreeViewItem(const wxTreeItemId& item, // the item handle
292 UINT mask_, // fields which are valid
293 UINT stateMask_ = 0) // for TVIF_STATE only
294 {
295 wxZeroMemory(*this);
296
297 // hItem member is always valid
298 mask = mask_ | TVIF_HANDLE;
299 stateMask = stateMask_;
300 hItem = HITEM(item);
301 }
302 };
303
304 // wxVirutalNode is used in place of a single root when 'hidden' root is
305 // specified.
306 class wxVirtualNode : public wxTreeViewItem
307 {
308 public:
309 wxVirtualNode(wxTreeItemData *data)
310 : wxTreeViewItem(TVI_ROOT, 0)
311 {
312 m_data = data;
313 }
314
315 ~wxVirtualNode()
316 {
317 delete m_data;
318 }
319
320 wxTreeItemData *GetData() const { return m_data; }
321 void SetData(wxTreeItemData *data) { delete m_data; m_data = data; }
322
323 private:
324 wxTreeItemData *m_data;
325 };
326
327 #ifdef __VISUALC__
328 #pragma warning( default : 4097 )
329 #endif
330
331 // a macro to get the virtual root, returns NULL if none
332 #define GET_VIRTUAL_ROOT() ((wxVirtualNode *)m_pVirtualRoot)
333
334 // returns TRUE if the item is the virtual root
335 #define IS_VIRTUAL_ROOT(item) (HITEM(item) == TVI_ROOT)
336
337 // a class which encapsulates the tree traversal logic: it vists all (unless
338 // OnVisit() returns FALSE) items under the given one
339 class wxTreeTraversal
340 {
341 public:
342 wxTreeTraversal(const wxTreeCtrl *tree)
343 {
344 m_tree = tree;
345 }
346
347 // do traverse the tree: visit all items (recursively by default) under the
348 // given one; return TRUE if all items were traversed or FALSE if the
349 // traversal was aborted because OnVisit returned FALSE
350 bool DoTraverse(const wxTreeItemId& root, bool recursively = TRUE);
351
352 // override this function to do whatever is needed for each item, return
353 // FALSE to stop traversing
354 virtual bool OnVisit(const wxTreeItemId& item) = 0;
355
356 protected:
357 const wxTreeCtrl *GetTree() const { return m_tree; }
358
359 private:
360 bool Traverse(const wxTreeItemId& root, bool recursively);
361
362 const wxTreeCtrl *m_tree;
363 };
364
365 // internal class for getting the selected items
366 class TraverseSelections : public wxTreeTraversal
367 {
368 public:
369 TraverseSelections(const wxTreeCtrl *tree,
370 wxArrayTreeItemIds& selections)
371 : wxTreeTraversal(tree), m_selections(selections)
372 {
373 m_selections.Empty();
374
375 DoTraverse(tree->GetRootItem());
376 }
377
378 virtual bool OnVisit(const wxTreeItemId& item)
379 {
380 // can't visit a virtual node.
381 if ( (GetTree()->GetRootItem() == item) && (GetTree()->GetWindowStyle() & wxTR_HIDE_ROOT))
382 {
383 return TRUE;
384 }
385
386 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
387 if ( GetTree()->IsItemChecked(item) )
388 #else
389 if ( ::IsItemSelected(GetHwndOf(GetTree()), HITEM(item)) )
390 #endif
391 {
392 m_selections.Add(item);
393 }
394
395 return TRUE;
396 }
397
398 size_t GetCount() const { return m_selections.GetCount(); }
399
400 private:
401 wxArrayTreeItemIds& m_selections;
402 };
403
404 // internal class for counting tree items
405 class TraverseCounter : public wxTreeTraversal
406 {
407 public:
408 TraverseCounter(const wxTreeCtrl *tree,
409 const wxTreeItemId& root,
410 bool recursively)
411 : wxTreeTraversal(tree)
412 {
413 m_count = 0;
414
415 DoTraverse(root, recursively);
416 }
417
418 virtual bool OnVisit(const wxTreeItemId& WXUNUSED(item))
419 {
420 m_count++;
421
422 return TRUE;
423 }
424
425 size_t GetCount() const { return m_count; }
426
427 private:
428 size_t m_count;
429 };
430
431 // ----------------------------------------------------------------------------
432 // This class is needed for support of different images: the Win32 common
433 // control natively supports only 2 images (the normal one and another for the
434 // selected state). We wish to provide support for 2 more of them for folder
435 // items (i.e. those which have children): for expanded state and for expanded
436 // selected state. For this we use this structure to store the additional items
437 // images.
438 //
439 // There is only one problem with this: when we retrieve the item's data, we
440 // don't know whether we get a pointer to wxTreeItemData or
441 // wxTreeItemIndirectData. So we always set the item id to an invalid value
442 // in this class and the code using the client data checks for it and retrieves
443 // the real client data in this case.
444 // ----------------------------------------------------------------------------
445
446 class wxTreeItemIndirectData : public wxTreeItemData
447 {
448 public:
449 // ctor associates this data with the item and the real item data becomes
450 // available through our GetData() method
451 wxTreeItemIndirectData(wxTreeCtrl *tree, const wxTreeItemId& item)
452 {
453 for ( size_t n = 0; n < WXSIZEOF(m_images); n++ )
454 {
455 m_images[n] = -1;
456 }
457
458 // save the old data
459 m_data = tree->GetItemData(item);
460
461 // and set ourselves as the new one
462 tree->SetIndirectItemData(item, this);
463
464 // we must have the invalid value for the item
465 m_pItem = 0l;
466 }
467
468 // dtor deletes the associated data as well
469 virtual ~wxTreeItemIndirectData() { delete m_data; }
470
471 // accessors
472 // get the real data associated with the item
473 wxTreeItemData *GetData() const { return m_data; }
474 // change it
475 void SetData(wxTreeItemData *data) { m_data = data; }
476
477 // do we have such image?
478 bool HasImage(wxTreeItemIcon which) const { return m_images[which] != -1; }
479 // get image
480 int GetImage(wxTreeItemIcon which) const { return m_images[which]; }
481 // change it
482 void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
483
484 private:
485 // all the images associated with the item
486 int m_images[wxTreeItemIcon_Max];
487
488 // the real client data
489 wxTreeItemData *m_data;
490 };
491
492 // ----------------------------------------------------------------------------
493 // wxWin macros
494 // ----------------------------------------------------------------------------
495
496 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
497
498 // ----------------------------------------------------------------------------
499 // constants
500 // ----------------------------------------------------------------------------
501
502 // indices in gs_expandEvents table below
503 enum
504 {
505 IDX_COLLAPSE,
506 IDX_EXPAND,
507 IDX_WHAT_MAX
508 };
509
510 enum
511 {
512 IDX_DONE,
513 IDX_DOING,
514 IDX_HOW_MAX
515 };
516
517 // handy table for sending events - it has to be initialized during run-time
518 // now so can't be const any more
519 static /* const */ wxEventType gs_expandEvents[IDX_WHAT_MAX][IDX_HOW_MAX];
520
521 /*
522 but logically it's a const table with the following entries:
523 =
524 {
525 { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
526 { wxEVT_COMMAND_TREE_ITEM_EXPANDED, wxEVT_COMMAND_TREE_ITEM_EXPANDING }
527 };
528 */
529
530 // ============================================================================
531 // implementation
532 // ============================================================================
533
534 // ----------------------------------------------------------------------------
535 // tree traversal
536 // ----------------------------------------------------------------------------
537
538 bool wxTreeTraversal::DoTraverse(const wxTreeItemId& root, bool recursively)
539 {
540 if ( !OnVisit(root) )
541 return FALSE;
542
543 return Traverse(root, recursively);
544 }
545
546 bool wxTreeTraversal::Traverse(const wxTreeItemId& root, bool recursively)
547 {
548 long cookie;
549 wxTreeItemId child = m_tree->GetFirstChild(root, cookie);
550 while ( child.IsOk() )
551 {
552 // depth first traversal
553 if ( recursively && !Traverse(child, TRUE) )
554 return FALSE;
555
556 if ( !OnVisit(child) )
557 return FALSE;
558
559 child = m_tree->GetNextChild(root, cookie);
560 }
561
562 return TRUE;
563 }
564
565 // ----------------------------------------------------------------------------
566 // construction and destruction
567 // ----------------------------------------------------------------------------
568
569 void wxTreeCtrl::Init()
570 {
571 m_imageListNormal = NULL;
572 m_imageListState = NULL;
573 m_ownsImageListNormal = m_ownsImageListState = FALSE;
574 m_textCtrl = NULL;
575 m_hasAnyAttr = FALSE;
576 m_dragImage = NULL;
577 m_htSelStart = 0;
578 m_pVirtualRoot = NULL;
579
580 // initialize the global array of events now as it can't be done statically
581 // with the wxEVT_XXX values being allocated during run-time only
582 gs_expandEvents[IDX_COLLAPSE][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
583 gs_expandEvents[IDX_COLLAPSE][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
584 gs_expandEvents[IDX_EXPAND][IDX_DONE] = wxEVT_COMMAND_TREE_ITEM_EXPANDED;
585 gs_expandEvents[IDX_EXPAND][IDX_DOING] = wxEVT_COMMAND_TREE_ITEM_EXPANDING;
586 }
587
588 bool wxTreeCtrl::Create(wxWindow *parent,
589 wxWindowID id,
590 const wxPoint& pos,
591 const wxSize& size,
592 long style,
593 const wxValidator& validator,
594 const wxString& name)
595 {
596 Init();
597
598 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
599 return FALSE;
600
601 DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
602 TVS_SHOWSELALWAYS;
603
604 if ( m_windowStyle & wxCLIP_SIBLINGS )
605 wstyle |= WS_CLIPSIBLINGS;
606
607 if ((m_windowStyle & wxTR_NO_LINES) == 0)
608 wstyle |= TVS_HASLINES;
609 if ( m_windowStyle & wxTR_HAS_BUTTONS )
610 wstyle |= TVS_HASBUTTONS;
611
612 if ( m_windowStyle & wxTR_EDIT_LABELS )
613 wstyle |= TVS_EDITLABELS;
614
615 if ( m_windowStyle & wxTR_LINES_AT_ROOT )
616 wstyle |= TVS_LINESATROOT;
617
618 if ( m_windowStyle & wxTR_FULL_ROW_HIGHLIGHT )
619 {
620 if ( wxTheApp->GetComCtl32Version() >= 471 )
621 wstyle |= TVS_FULLROWSELECT;
622 }
623
624 // using TVS_CHECKBOXES for emulation of a multiselection tree control
625 // doesn't work without the new enough headers
626 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE && \
627 !defined( __GNUWIN32_OLD__ ) && \
628 !defined( __BORLANDC__ ) && \
629 !defined( __WATCOMC__ ) && \
630 (!defined(__VISUALC__) || (__VISUALC__ > 1010))
631
632 // we emulate the multiple selection tree controls by using checkboxes: set
633 // up the image list we need for this if we do have multiple selections
634 if ( m_windowStyle & wxTR_MULTIPLE )
635 wstyle |= TVS_CHECKBOXES;
636 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
637
638 // Create the tree control.
639 if ( !MSWCreateControl(WC_TREEVIEW, wstyle) )
640 return FALSE;
641
642 #if wxUSE_COMCTL32_SAFELY
643 wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
644 wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
645 #elif 1
646 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
647 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
648 #else
649 // This works around a bug in the Windows tree control whereby for some versions
650 // of comctrl32, setting any colour actually draws the background in black.
651 // This will initialise the background to the system colour.
652 // THIS FIX NOW REVERTED since it caused problems on _other_ systems.
653 // Assume the user has an updated comctl32.dll.
654 ::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0,-1);
655 wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
656 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
657 #endif
658
659
660 // VZ: this is some experimental code which may be used to get the
661 // TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
662 // AFAIK, the standard DLL does about the same thing anyhow.
663 #if 0
664 if ( m_windowStyle & wxTR_MULTIPLE )
665 {
666 wxBitmap bmp;
667
668 // create the DC compatible with the current screen
669 HDC hdcMem = CreateCompatibleDC(NULL);
670
671 // create a mono bitmap of the standard size
672 int x = GetSystemMetrics(SM_CXMENUCHECK);
673 int y = GetSystemMetrics(SM_CYMENUCHECK);
674 wxImageList imagelistCheckboxes(x, y, FALSE, 2);
675 HBITMAP hbmpCheck = CreateBitmap(x, y, // bitmap size
676 1, // # of color planes
677 1, // # bits needed for one pixel
678 0); // array containing colour data
679 SelectObject(hdcMem, hbmpCheck);
680
681 // then draw a check mark into it
682 RECT rect = { 0, 0, x, y };
683 if ( !::DrawFrameControl(hdcMem, &rect,
684 DFC_BUTTON,
685 DFCS_BUTTONCHECK | DFCS_CHECKED) )
686 {
687 wxLogLastError(wxT("DrawFrameControl(check)"));
688 }
689
690 bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
691 imagelistCheckboxes.Add(bmp);
692
693 if ( !::DrawFrameControl(hdcMem, &rect,
694 DFC_BUTTON,
695 DFCS_BUTTONCHECK) )
696 {
697 wxLogLastError(wxT("DrawFrameControl(uncheck)"));
698 }
699
700 bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
701 imagelistCheckboxes.Add(bmp);
702
703 // clean up
704 ::DeleteDC(hdcMem);
705
706 // set the imagelist
707 SetStateImageList(&imagelistCheckboxes);
708 }
709 #endif // 0
710
711 SetSize(pos.x, pos.y, size.x, size.y);
712
713 return TRUE;
714 }
715
716 wxTreeCtrl::~wxTreeCtrl()
717 {
718 // delete any attributes
719 if ( m_hasAnyAttr )
720 {
721 for ( wxNode *node = m_attrs.Next(); node; node = m_attrs.Next() )
722 {
723 delete (wxTreeItemAttr *)node->Data();
724 }
725
726 // prevent TVN_DELETEITEM handler from deleting the attributes again!
727 m_hasAnyAttr = FALSE;
728 }
729
730 DeleteTextCtrl();
731
732 // delete user data to prevent memory leaks
733 // also deletes hidden root node storage.
734 DeleteAllItems();
735
736 if (m_ownsImageListNormal) delete m_imageListNormal;
737 if (m_ownsImageListState) delete m_imageListState;
738 }
739
740 // ----------------------------------------------------------------------------
741 // accessors
742 // ----------------------------------------------------------------------------
743
744 // simple wrappers which add error checking in debug mode
745
746 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
747 {
748 wxCHECK_MSG( tvItem->hItem != TVI_ROOT, FALSE,
749 _T("can't retrieve virtual root item") );
750
751 if ( !TreeView_GetItem(GetHwnd(), tvItem) )
752 {
753 wxLogLastError(wxT("TreeView_GetItem"));
754
755 return FALSE;
756 }
757
758 return TRUE;
759 }
760
761 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
762 {
763 if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
764 {
765 wxLogLastError(wxT("TreeView_SetItem"));
766 }
767 }
768
769 size_t wxTreeCtrl::GetCount() const
770 {
771 return (size_t)TreeView_GetCount(GetHwnd());
772 }
773
774 unsigned int wxTreeCtrl::GetIndent() const
775 {
776 return TreeView_GetIndent(GetHwnd());
777 }
778
779 void wxTreeCtrl::SetIndent(unsigned int indent)
780 {
781 TreeView_SetIndent(GetHwnd(), indent);
782 }
783
784 wxImageList *wxTreeCtrl::GetImageList() const
785 {
786 return m_imageListNormal;
787 }
788
789 wxImageList *wxTreeCtrl::GetStateImageList() const
790 {
791 return m_imageListNormal;
792 }
793
794 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
795 {
796 // no error return
797 TreeView_SetImageList(GetHwnd(),
798 imageList ? imageList->GetHIMAGELIST() : 0,
799 which);
800 }
801
802 void wxTreeCtrl::SetImageList(wxImageList *imageList)
803 {
804 if (m_ownsImageListNormal)
805 delete m_imageListNormal;
806
807 SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
808 m_ownsImageListNormal = FALSE;
809 }
810
811 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
812 {
813 if (m_ownsImageListState) delete m_imageListState;
814 SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
815 m_ownsImageListState = FALSE;
816 }
817
818 void wxTreeCtrl::AssignImageList(wxImageList *imageList)
819 {
820 SetImageList(imageList);
821 m_ownsImageListNormal = TRUE;
822 }
823
824 void wxTreeCtrl::AssignStateImageList(wxImageList *imageList)
825 {
826 SetStateImageList(imageList);
827 m_ownsImageListState = TRUE;
828 }
829
830 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
831 bool recursively) const
832 {
833 TraverseCounter counter(this, item, recursively);
834
835 return counter.GetCount() - 1;
836 }
837
838 // ----------------------------------------------------------------------------
839 // control colours
840 // ----------------------------------------------------------------------------
841
842 bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
843 {
844 #if !wxUSE_COMCTL32_SAFELY
845 if ( !wxWindowBase::SetBackgroundColour(colour) )
846 return FALSE;
847
848 SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0, colour.GetPixel());
849 #endif
850
851 return TRUE;
852 }
853
854 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
855 {
856 #if !wxUSE_COMCTL32_SAFELY
857 if ( !wxWindowBase::SetForegroundColour(colour) )
858 return FALSE;
859
860 SendMessage(GetHwnd(), TVM_SETTEXTCOLOR, 0, colour.GetPixel());
861 #endif
862
863 return TRUE;
864 }
865
866 // ----------------------------------------------------------------------------
867 // Item access
868 // ----------------------------------------------------------------------------
869
870 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
871 {
872 wxChar buf[512]; // the size is arbitrary...
873
874 wxTreeViewItem tvItem(item, TVIF_TEXT);
875 tvItem.pszText = buf;
876 tvItem.cchTextMax = WXSIZEOF(buf);
877 if ( !DoGetItem(&tvItem) )
878 {
879 // don't return some garbage which was on stack, but an empty string
880 buf[0] = wxT('\0');
881 }
882
883 return wxString(buf);
884 }
885
886 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
887 {
888 if ( IS_VIRTUAL_ROOT(item) )
889 return;
890
891 wxTreeViewItem tvItem(item, TVIF_TEXT);
892 tvItem.pszText = (wxChar *)text.c_str(); // conversion is ok
893 DoSetItem(&tvItem);
894
895 // when setting the text of the item being edited, the text control should
896 // be updated to reflect the new text as well, otherwise calling
897 // SetItemText() in the OnBeginLabelEdit() handler doesn't have any effect
898 //
899 // don't use GetEditControl() here because m_textCtrl is not set yet
900 HWND hwndEdit = TreeView_GetEditControl(GetHwnd());
901 if ( hwndEdit )
902 {
903 if ( item == GetSelection() )
904 {
905 ::SetWindowText(hwndEdit, text);
906 }
907 }
908 }
909
910 int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,
911 wxTreeItemIcon which) const
912 {
913 wxTreeViewItem tvItem(item, TVIF_PARAM);
914 if ( !DoGetItem(&tvItem) )
915 {
916 return -1;
917 }
918
919 return ((wxTreeItemIndirectData *)tvItem.lParam)->GetImage(which);
920 }
921
922 void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId& item,
923 int image,
924 wxTreeItemIcon which) const
925 {
926 wxTreeViewItem tvItem(item, TVIF_PARAM);
927 if ( !DoGetItem(&tvItem) )
928 {
929 return;
930 }
931
932 wxTreeItemIndirectData *data = ((wxTreeItemIndirectData *)tvItem.lParam);
933
934 data->SetImage(image, which);
935
936 // make sure that we have selected images as well
937 if ( which == wxTreeItemIcon_Normal &&
938 !data->HasImage(wxTreeItemIcon_Selected) )
939 {
940 data->SetImage(image, wxTreeItemIcon_Selected);
941 }
942
943 if ( which == wxTreeItemIcon_Expanded &&
944 !data->HasImage(wxTreeItemIcon_SelectedExpanded) )
945 {
946 data->SetImage(image, wxTreeItemIcon_SelectedExpanded);
947 }
948 }
949
950 void wxTreeCtrl::DoSetItemImages(const wxTreeItemId& item,
951 int image,
952 int imageSel)
953 {
954 wxTreeViewItem tvItem(item, TVIF_IMAGE | TVIF_SELECTEDIMAGE);
955 tvItem.iSelectedImage = imageSel;
956 tvItem.iImage = image;
957 DoSetItem(&tvItem);
958 }
959
960 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
961 wxTreeItemIcon which) const
962 {
963 if ( (HITEM(item) == TVI_ROOT) && (m_windowStyle & wxTR_HIDE_ROOT) )
964 {
965 // TODO: Maybe a hidden root can still provide images?
966 return -1;
967 }
968
969 if ( HasIndirectData(item) )
970 {
971 return DoGetItemImageFromData(item, which);
972 }
973
974 UINT mask;
975 switch ( which )
976 {
977 default:
978 wxFAIL_MSG( wxT("unknown tree item image type") );
979
980 case wxTreeItemIcon_Normal:
981 mask = TVIF_IMAGE;
982 break;
983
984 case wxTreeItemIcon_Selected:
985 mask = TVIF_SELECTEDIMAGE;
986 break;
987
988 case wxTreeItemIcon_Expanded:
989 case wxTreeItemIcon_SelectedExpanded:
990 return -1;
991 }
992
993 wxTreeViewItem tvItem(item, mask);
994 DoGetItem(&tvItem);
995
996 return mask == TVIF_IMAGE ? tvItem.iImage : tvItem.iSelectedImage;
997 }
998
999 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
1000 wxTreeItemIcon which)
1001 {
1002 if ( IS_VIRTUAL_ROOT(item) )
1003 {
1004 // TODO: Maybe a hidden root can still store images?
1005 return;
1006 }
1007
1008 int imageNormal, imageSel;
1009 switch ( which )
1010 {
1011 default:
1012 wxFAIL_MSG( wxT("unknown tree item image type") );
1013
1014 case wxTreeItemIcon_Normal:
1015 imageNormal = image;
1016 imageSel = GetItemSelectedImage(item);
1017 break;
1018
1019 case wxTreeItemIcon_Selected:
1020 imageNormal = GetItemImage(item);
1021 imageSel = image;
1022 break;
1023
1024 case wxTreeItemIcon_Expanded:
1025 case wxTreeItemIcon_SelectedExpanded:
1026 if ( !HasIndirectData(item) )
1027 {
1028 // we need to get the old images first, because after we create
1029 // the wxTreeItemIndirectData GetItemXXXImage() will use it to
1030 // get the images
1031 imageNormal = GetItemImage(item);
1032 imageSel = GetItemSelectedImage(item);
1033
1034 // if it doesn't have it yet, add it
1035 wxTreeItemIndirectData *data = new
1036 wxTreeItemIndirectData(this, item);
1037
1038 // copy the data to the new location
1039 data->SetImage(imageNormal, wxTreeItemIcon_Normal);
1040 data->SetImage(imageSel, wxTreeItemIcon_Selected);
1041 }
1042
1043 DoSetItemImageFromData(item, image, which);
1044
1045 // reset the normal/selected images because we won't use them any
1046 // more - now they're stored inside the indirect data
1047 imageNormal =
1048 imageSel = I_IMAGECALLBACK;
1049 break;
1050 }
1051
1052 // NB: at least in version 5.00.0518.9 of comctl32.dll we need to always
1053 // change both normal and selected image - otherwise the change simply
1054 // doesn't take place!
1055 DoSetItemImages(item, imageNormal, imageSel);
1056 }
1057
1058 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
1059 {
1060 wxTreeViewItem tvItem(item, TVIF_PARAM);
1061
1062 // Hidden root may have data.
1063 if ( IS_VIRTUAL_ROOT(item) )
1064 {
1065 return GET_VIRTUAL_ROOT()->GetData();
1066 }
1067
1068 // Visible node.
1069 if ( !DoGetItem(&tvItem) )
1070 {
1071 return NULL;
1072 }
1073
1074 wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
1075 if ( IsDataIndirect(data) )
1076 {
1077 data = ((wxTreeItemIndirectData *)data)->GetData();
1078 }
1079
1080 return data;
1081 }
1082
1083 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
1084 {
1085 if ( IS_VIRTUAL_ROOT(item) )
1086 {
1087 GET_VIRTUAL_ROOT()->SetData(data);
1088 }
1089
1090 // first, associate this piece of data with this item
1091 if ( data )
1092 {
1093 data->SetId(item);
1094 }
1095
1096 wxTreeViewItem tvItem(item, TVIF_PARAM);
1097
1098 if ( HasIndirectData(item) )
1099 {
1100 if ( DoGetItem(&tvItem) )
1101 {
1102 ((wxTreeItemIndirectData *)tvItem.lParam)->SetData(data);
1103 }
1104 else
1105 {
1106 wxFAIL_MSG( wxT("failed to change tree items data") );
1107 }
1108 }
1109 else
1110 {
1111 tvItem.lParam = (LPARAM)data;
1112 DoSetItem(&tvItem);
1113 }
1114 }
1115
1116 void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId& item,
1117 wxTreeItemIndirectData *data)
1118 {
1119 // this should never happen because it's unnecessary and will probably lead
1120 // to crash too because the code elsewhere supposes that the pointer the
1121 // wxTreeItemIndirectData has is a real wxItemData and not
1122 // wxTreeItemIndirectData as well
1123 wxASSERT_MSG( !HasIndirectData(item), wxT("setting indirect data twice?") );
1124
1125 SetItemData(item, data);
1126 }
1127
1128 bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
1129 {
1130 // query the item itself
1131 wxTreeViewItem tvItem(item, TVIF_PARAM);
1132 if ( !DoGetItem(&tvItem) )
1133 {
1134 return FALSE;
1135 }
1136
1137 wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
1138
1139 return data && IsDataIndirect(data);
1140 }
1141
1142 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
1143 {
1144 if ( IS_VIRTUAL_ROOT(item) )
1145 return;
1146
1147 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1148 tvItem.cChildren = (int)has;
1149 DoSetItem(&tvItem);
1150 }
1151
1152 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
1153 {
1154 if ( IS_VIRTUAL_ROOT(item) )
1155 return;
1156
1157 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1158 tvItem.state = bold ? TVIS_BOLD : 0;
1159 DoSetItem(&tvItem);
1160 }
1161
1162 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
1163 {
1164 if ( IS_VIRTUAL_ROOT(item) )
1165 return;
1166
1167 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
1168 tvItem.state = highlight ? TVIS_DROPHILITED : 0;
1169 DoSetItem(&tvItem);
1170 }
1171
1172 void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
1173 {
1174 if ( IS_VIRTUAL_ROOT(item) )
1175 return;
1176
1177 wxRect rect;
1178 if ( GetBoundingRect(item, rect) )
1179 {
1180 RefreshRect(rect);
1181 }
1182 }
1183
1184 wxColour wxTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
1185 {
1186 long id = (long)(WXHTREEITEM)item;
1187 wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1188 if ( !attr )
1189 {
1190 return wxNullColour;
1191 }
1192
1193 return attr->GetTextColour();
1194 }
1195
1196 wxColour wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
1197 {
1198 long id = (long)(WXHTREEITEM)item;
1199 wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1200 if ( !attr )
1201 {
1202 return wxNullColour;
1203 }
1204
1205 return attr->GetBackgroundColour();
1206 }
1207
1208 wxFont wxTreeCtrl::GetItemFont(const wxTreeItemId& item) const
1209 {
1210 long id = (long)(WXHTREEITEM)item;
1211 wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1212 if ( !attr )
1213 {
1214 return wxNullFont;
1215 }
1216
1217 return attr->GetFont();
1218 }
1219
1220 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
1221 const wxColour& col)
1222 {
1223 m_hasAnyAttr = TRUE;
1224
1225 long id = (long)(WXHTREEITEM)item;
1226 wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1227 if ( !attr )
1228 {
1229 attr = new wxTreeItemAttr;
1230 m_attrs.Put(id, (wxObject *)attr);
1231 }
1232
1233 attr->SetTextColour(col);
1234
1235 RefreshItem(item);
1236 }
1237
1238 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
1239 const wxColour& col)
1240 {
1241 m_hasAnyAttr = TRUE;
1242
1243 long id = (long)(WXHTREEITEM)item;
1244 wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1245 if ( !attr )
1246 {
1247 attr = new wxTreeItemAttr;
1248 m_attrs.Put(id, (wxObject *)attr);
1249 }
1250
1251 attr->SetBackgroundColour(col);
1252
1253 RefreshItem(item);
1254 }
1255
1256 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
1257 {
1258 m_hasAnyAttr = TRUE;
1259
1260 long id = (long)(WXHTREEITEM)item;
1261 wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1262 if ( !attr )
1263 {
1264 attr = new wxTreeItemAttr;
1265 m_attrs.Put(id, (wxObject *)attr);
1266 }
1267
1268 attr->SetFont(font);
1269
1270 RefreshItem(item);
1271 }
1272
1273 // ----------------------------------------------------------------------------
1274 // Item status
1275 // ----------------------------------------------------------------------------
1276
1277 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
1278 {
1279 if ( item == wxTreeItemId(TVI_ROOT) )
1280 {
1281 // virtual (hidden) root is never visible
1282 return FALSE;
1283 }
1284
1285 // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
1286 RECT rect;
1287
1288 // this ugliness comes directly from MSDN - it *is* the correct way to pass
1289 // the HTREEITEM with TVM_GETITEMRECT
1290 *(WXHTREEITEM *)&rect = (WXHTREEITEM)item;
1291
1292 // FALSE means get item rect for the whole item, not only text
1293 return SendMessage(GetHwnd(), TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
1294 }
1295
1296 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
1297 {
1298 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1299 DoGetItem(&tvItem);
1300
1301 return tvItem.cChildren != 0;
1302 }
1303
1304 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
1305 {
1306 // probably not a good idea to put it here
1307 //wxASSERT( ItemHasChildren(item) );
1308
1309 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
1310 DoGetItem(&tvItem);
1311
1312 return (tvItem.state & TVIS_EXPANDED) != 0;
1313 }
1314
1315 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
1316 {
1317 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
1318 DoGetItem(&tvItem);
1319
1320 return (tvItem.state & TVIS_SELECTED) != 0;
1321 }
1322
1323 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
1324 {
1325 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1326 DoGetItem(&tvItem);
1327
1328 return (tvItem.state & TVIS_BOLD) != 0;
1329 }
1330
1331 // ----------------------------------------------------------------------------
1332 // navigation
1333 // ----------------------------------------------------------------------------
1334
1335 wxTreeItemId wxTreeCtrl::GetRootItem() const
1336 {
1337 // Root may be real (visible) or virtual (hidden).
1338 if ( GET_VIRTUAL_ROOT() )
1339 return TVI_ROOT;
1340
1341 return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(GetHwnd()));
1342 }
1343
1344 wxTreeItemId wxTreeCtrl::GetSelection() const
1345 {
1346 wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), (long)(WXHTREEITEM)0,
1347 wxT("this only works with single selection controls") );
1348
1349 return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(GetHwnd()));
1350 }
1351
1352 wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
1353 {
1354 HTREEITEM hItem;
1355
1356 if ( IS_VIRTUAL_ROOT(item) )
1357 {
1358 // no parent for the virtual root
1359 hItem = 0;
1360 }
1361 else // normal item
1362 {
1363 hItem = TreeView_GetParent(GetHwnd(), HITEM(item));
1364 if ( !hItem && HasFlag(wxTR_HIDE_ROOT) )
1365 {
1366 // the top level items should have the virtual root as their parent
1367 hItem = TVI_ROOT;
1368 }
1369 }
1370
1371 return wxTreeItemId((WXHTREEITEM)hItem);
1372 }
1373
1374 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1375 long& _cookie) const
1376 {
1377 // remember the last child returned in 'cookie'
1378 _cookie = (long)TreeView_GetChild(GetHwnd(), HITEM(item));
1379
1380 return wxTreeItemId((WXHTREEITEM)_cookie);
1381 }
1382
1383 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
1384 long& _cookie) const
1385 {
1386 wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(GetHwnd(),
1387 HITEM(_cookie)));
1388 _cookie = (long)l;
1389
1390 return l;
1391 }
1392
1393 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
1394 {
1395 // can this be done more efficiently?
1396 long cookie;
1397
1398 wxTreeItemId childLast,
1399 child = GetFirstChild(item, cookie);
1400 while ( child.IsOk() )
1401 {
1402 childLast = child;
1403 child = GetNextChild(item, cookie);
1404 }
1405
1406 return childLast;
1407 }
1408
1409 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
1410 {
1411 return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(GetHwnd(), HITEM(item)));
1412 }
1413
1414 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
1415 {
1416 return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(GetHwnd(), HITEM(item)));
1417 }
1418
1419 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
1420 {
1421 return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(GetHwnd()));
1422 }
1423
1424 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1425 {
1426 wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() for must be visible itself!"));
1427
1428 return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(GetHwnd(), HITEM(item)));
1429 }
1430
1431 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1432 {
1433 wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() for must be visible itself!"));
1434
1435 return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(GetHwnd(), HITEM(item)));
1436 }
1437
1438 // ----------------------------------------------------------------------------
1439 // multiple selections emulation
1440 // ----------------------------------------------------------------------------
1441
1442 bool wxTreeCtrl::IsItemChecked(const wxTreeItemId& item) const
1443 {
1444 // receive the desired information.
1445 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
1446 DoGetItem(&tvItem);
1447
1448 // state image indices are 1 based
1449 return ((tvItem.state >> 12) - 1) == 1;
1450 }
1451
1452 void wxTreeCtrl::SetItemCheck(const wxTreeItemId& item, bool check)
1453 {
1454 // receive the desired information.
1455 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
1456
1457 DoGetItem(&tvItem);
1458
1459 // state images are one-based
1460 tvItem.state = (check ? 2 : 1) << 12;
1461
1462 DoSetItem(&tvItem);
1463 }
1464
1465 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
1466 {
1467 TraverseSelections selector(this, selections);
1468
1469 return selector.GetCount();
1470 }
1471
1472 // ----------------------------------------------------------------------------
1473 // Usual operations
1474 // ----------------------------------------------------------------------------
1475
1476 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
1477 wxTreeItemId hInsertAfter,
1478 const wxString& text,
1479 int image, int selectedImage,
1480 wxTreeItemData *data)
1481 {
1482 wxCHECK_MSG( parent.IsOk() || !TreeView_GetRoot(GetHwnd()),
1483 wxTreeItemId(),
1484 _T("can't have more than one root in the tree") );
1485
1486 TV_INSERTSTRUCT tvIns;
1487 tvIns.hParent = HITEM(parent);
1488 tvIns.hInsertAfter = HITEM(hInsertAfter);
1489
1490 // this is how we insert the item as the first child: supply a NULL
1491 // hInsertAfter
1492 if ( !tvIns.hInsertAfter )
1493 {
1494 tvIns.hInsertAfter = TVI_FIRST;
1495 }
1496
1497 UINT mask = 0;
1498 if ( !text.IsEmpty() )
1499 {
1500 mask |= TVIF_TEXT;
1501 tvIns.item.pszText = (wxChar *)text.c_str(); // cast is ok
1502 }
1503 else
1504 {
1505 tvIns.item.pszText = NULL;
1506 tvIns.item.cchTextMax = 0;
1507 }
1508
1509 if ( image != -1 )
1510 {
1511 mask |= TVIF_IMAGE;
1512 tvIns.item.iImage = image;
1513
1514 if ( selectedImage == -1 )
1515 {
1516 // take the same image for selected icon if not specified
1517 selectedImage = image;
1518 }
1519 }
1520
1521 if ( selectedImage != -1 )
1522 {
1523 mask |= TVIF_SELECTEDIMAGE;
1524 tvIns.item.iSelectedImage = selectedImage;
1525 }
1526
1527 if ( data != NULL )
1528 {
1529 mask |= TVIF_PARAM;
1530 tvIns.item.lParam = (LPARAM)data;
1531 }
1532
1533 tvIns.item.mask = mask;
1534
1535 HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
1536 if ( id == 0 )
1537 {
1538 wxLogLastError(wxT("TreeView_InsertItem"));
1539 }
1540
1541 if ( data != NULL )
1542 {
1543 // associate the application tree item with Win32 tree item handle
1544 data->SetId((WXHTREEITEM)id);
1545 }
1546
1547 return wxTreeItemId((WXHTREEITEM)id);
1548 }
1549
1550 // for compatibility only
1551 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1552 const wxString& text,
1553 int image, int selImage,
1554 long insertAfter)
1555 {
1556 return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
1557 image, selImage, NULL);
1558 }
1559
1560 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
1561 int image, int selectedImage,
1562 wxTreeItemData *data)
1563 {
1564
1565 if ( m_windowStyle & wxTR_HIDE_ROOT )
1566 {
1567 // create a virtual root item, the parent for all the others
1568 m_pVirtualRoot = new wxVirtualNode(data);
1569
1570 return TVI_ROOT;
1571 }
1572
1573 return DoInsertItem(wxTreeItemId((long)(WXHTREEITEM) 0), (long)(WXHTREEITEM) 0,
1574 text, image, selectedImage, data);
1575 }
1576
1577 wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
1578 const wxString& text,
1579 int image, int selectedImage,
1580 wxTreeItemData *data)
1581 {
1582 return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,
1583 text, image, selectedImage, data);
1584 }
1585
1586 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1587 const wxTreeItemId& idPrevious,
1588 const wxString& text,
1589 int image, int selectedImage,
1590 wxTreeItemData *data)
1591 {
1592 return DoInsertItem(parent, idPrevious, text, image, selectedImage, data);
1593 }
1594
1595 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1596 size_t index,
1597 const wxString& text,
1598 int image, int selectedImage,
1599 wxTreeItemData *data)
1600 {
1601 // find the item from index
1602 long cookie;
1603 wxTreeItemId idPrev, idCur = GetFirstChild(parent, cookie);
1604 while ( index != 0 && idCur.IsOk() )
1605 {
1606 index--;
1607
1608 idPrev = idCur;
1609 idCur = GetNextChild(parent, cookie);
1610 }
1611
1612 // assert, not check: if the index is invalid, we will append the item
1613 // to the end
1614 wxASSERT_MSG( index == 0, _T("bad index in wxTreeCtrl::InsertItem") );
1615
1616 return DoInsertItem(parent, idPrev, text, image, selectedImage, data);
1617 }
1618
1619 wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
1620 const wxString& text,
1621 int image, int selectedImage,
1622 wxTreeItemData *data)
1623 {
1624 return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,
1625 text, image, selectedImage, data);
1626 }
1627
1628 void wxTreeCtrl::Delete(const wxTreeItemId& item)
1629 {
1630 if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item)) )
1631 {
1632 wxLogLastError(wxT("TreeView_DeleteItem"));
1633 }
1634 }
1635
1636 // delete all children (but don't delete the item itself)
1637 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
1638 {
1639 long cookie;
1640
1641 wxArrayLong children;
1642 wxTreeItemId child = GetFirstChild(item, cookie);
1643 while ( child.IsOk() )
1644 {
1645 children.Add((long)(WXHTREEITEM)child);
1646
1647 child = GetNextChild(item, cookie);
1648 }
1649
1650 size_t nCount = children.Count();
1651 for ( size_t n = 0; n < nCount; n++ )
1652 {
1653 if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)children[n]) )
1654 {
1655 wxLogLastError(wxT("TreeView_DeleteItem"));
1656 }
1657 }
1658 }
1659
1660 void wxTreeCtrl::DeleteAllItems()
1661 {
1662 // delete stored root item.
1663 delete GET_VIRTUAL_ROOT();
1664
1665 if ( !TreeView_DeleteAllItems(GetHwnd()) )
1666 {
1667 wxLogLastError(wxT("TreeView_DeleteAllItems"));
1668 }
1669 }
1670
1671 void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
1672 {
1673 wxASSERT_MSG( flag == TVE_COLLAPSE ||
1674 flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
1675 flag == TVE_EXPAND ||
1676 flag == TVE_TOGGLE,
1677 wxT("Unknown flag in wxTreeCtrl::DoExpand") );
1678
1679 // A hidden root can be neither expanded nor collapsed.
1680 wxCHECK_RET( !(m_windowStyle & wxTR_HIDE_ROOT) || (HITEM(item) != TVI_ROOT),
1681 wxT("Can't expand/collapse hidden root node!") )
1682
1683 // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
1684 // emulate them. This behaviour has changed slightly with comctl32.dll
1685 // v 4.70 - now it does send them but only the first time. To maintain
1686 // compatible behaviour and also in order to not have surprises with the
1687 // future versions, don't rely on this and still do everything ourselves.
1688 // To avoid that the messages be sent twice when the item is expanded for
1689 // the first time we must clear TVIS_EXPANDEDONCE style manually.
1690
1691 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDEDONCE);
1692 tvItem.state = 0;
1693 DoSetItem(&tvItem);
1694
1695 if ( TreeView_Expand(GetHwnd(), HITEM(item), flag) != 0 )
1696 {
1697 wxTreeEvent event(wxEVT_NULL, m_windowId);
1698 event.m_item = item;
1699 event.SetEventObject(this);
1700
1701 // note that the {EXPAND|COLLAPS}ING event is sent by TreeView_Expand()
1702 // itself
1703 event.SetEventType(gs_expandEvents[IsExpanded(item) ? IDX_EXPAND
1704 : IDX_COLLAPSE]
1705 [IDX_DONE]);
1706
1707 (void)GetEventHandler()->ProcessEvent(event);
1708 }
1709 //else: change didn't took place, so do nothing at all
1710 }
1711
1712 void wxTreeCtrl::Expand(const wxTreeItemId& item)
1713 {
1714 DoExpand(item, TVE_EXPAND);
1715 }
1716
1717 void wxTreeCtrl::Collapse(const wxTreeItemId& item)
1718 {
1719 DoExpand(item, TVE_COLLAPSE);
1720 }
1721
1722 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1723 {
1724 DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);
1725 }
1726
1727 void wxTreeCtrl::Toggle(const wxTreeItemId& item)
1728 {
1729 DoExpand(item, TVE_TOGGLE);
1730 }
1731
1732 void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
1733 {
1734 DoExpand(item, action);
1735 }
1736
1737 void wxTreeCtrl::Unselect()
1738 {
1739 wxASSERT_MSG( !(m_windowStyle & wxTR_MULTIPLE),
1740 wxT("doesn't make sense, may be you want UnselectAll()?") );
1741
1742 // just remove the selection
1743 SelectItem(wxTreeItemId((long) (WXHTREEITEM) 0));
1744 }
1745
1746 void wxTreeCtrl::UnselectAll()
1747 {
1748 if ( m_windowStyle & wxTR_MULTIPLE )
1749 {
1750 wxArrayTreeItemIds selections;
1751 size_t count = GetSelections(selections);
1752 for ( size_t n = 0; n < count; n++ )
1753 {
1754 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1755 SetItemCheck(selections[n], FALSE);
1756 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1757 ::UnselectItem(GetHwnd(), HITEM(selections[n]));
1758 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1759 }
1760 }
1761 else
1762 {
1763 // just remove the selection
1764 Unselect();
1765 }
1766 }
1767
1768 void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
1769 {
1770 if ( m_windowStyle & wxTR_MULTIPLE )
1771 {
1772 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1773 // selecting the item means checking it
1774 SetItemCheck(item);
1775 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1776 ::SelectItem(GetHwnd(), HITEM(item));
1777 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1778 }
1779 else
1780 {
1781 // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
1782 // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
1783 // send them ourselves
1784
1785 wxTreeEvent event(wxEVT_NULL, m_windowId);
1786 event.m_item = item;
1787 event.SetEventObject(this);
1788
1789 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING);
1790 if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
1791 {
1792 if ( !TreeView_SelectItem(GetHwnd(), HITEM(item)) )
1793 {
1794 wxLogLastError(wxT("TreeView_SelectItem"));
1795 }
1796 else
1797 {
1798 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1799 (void)GetEventHandler()->ProcessEvent(event);
1800 }
1801 }
1802 //else: program vetoed the change
1803 }
1804 }
1805
1806 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1807 {
1808 // no error return
1809 TreeView_EnsureVisible(GetHwnd(), HITEM(item));
1810 }
1811
1812 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
1813 {
1814 if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item)) )
1815 {
1816 wxLogLastError(wxT("TreeView_SelectSetFirstVisible"));
1817 }
1818 }
1819
1820 wxTextCtrl *wxTreeCtrl::GetEditControl() const
1821 {
1822 return m_textCtrl;
1823 }
1824
1825 void wxTreeCtrl::DeleteTextCtrl()
1826 {
1827 if ( m_textCtrl )
1828 {
1829 // the HWND corresponding to this control is deleted by the tree
1830 // control itself and we don't know when exactly this happens, so check
1831 // if the window still exists before calling UnsubclassWin()
1832 if ( !::IsWindow(GetHwndOf(m_textCtrl)) )
1833 {
1834 m_textCtrl->SetHWND(0);
1835 }
1836
1837 m_textCtrl->UnsubclassWin();
1838 m_textCtrl->SetHWND(0);
1839 delete m_textCtrl;
1840 m_textCtrl = NULL;
1841 }
1842 }
1843
1844 wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
1845 wxClassInfo* textControlClass)
1846 {
1847 wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
1848
1849 DeleteTextCtrl();
1850
1851 m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
1852 HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), HITEM(item));
1853
1854 // this is not an error - the TVN_BEGINLABELEDIT handler might have
1855 // returned FALSE
1856 if ( !hWnd )
1857 {
1858 delete m_textCtrl;
1859 m_textCtrl = NULL;
1860 return NULL;
1861 }
1862
1863 // textctrl is subclassed in MSWOnNotify
1864 return m_textCtrl;
1865 }
1866
1867 // End label editing, optionally cancelling the edit
1868 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item), bool discardChanges)
1869 {
1870 TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
1871
1872 DeleteTextCtrl();
1873 }
1874
1875 wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
1876 {
1877 TV_HITTESTINFO hitTestInfo;
1878 hitTestInfo.pt.x = (int)point.x;
1879 hitTestInfo.pt.y = (int)point.y;
1880
1881 TreeView_HitTest(GetHwnd(), &hitTestInfo);
1882
1883 flags = 0;
1884
1885 // avoid repetition
1886 #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
1887 flags |= wxTREE_HITTEST_##flag
1888
1889 TRANSLATE_FLAG(ABOVE);
1890 TRANSLATE_FLAG(BELOW);
1891 TRANSLATE_FLAG(NOWHERE);
1892 TRANSLATE_FLAG(ONITEMBUTTON);
1893 TRANSLATE_FLAG(ONITEMICON);
1894 TRANSLATE_FLAG(ONITEMINDENT);
1895 TRANSLATE_FLAG(ONITEMLABEL);
1896 TRANSLATE_FLAG(ONITEMRIGHT);
1897 TRANSLATE_FLAG(ONITEMSTATEICON);
1898 TRANSLATE_FLAG(TOLEFT);
1899 TRANSLATE_FLAG(TORIGHT);
1900
1901 #undef TRANSLATE_FLAG
1902
1903 return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
1904 }
1905
1906 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
1907 wxRect& rect,
1908 bool textOnly) const
1909 {
1910 RECT rc;
1911 if ( TreeView_GetItemRect(GetHwnd(), HITEM(item),
1912 &rc, textOnly) )
1913 {
1914 rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
1915
1916 return TRUE;
1917 }
1918 else
1919 {
1920 // couldn't retrieve rect: for example, item isn't visible
1921 return FALSE;
1922 }
1923 }
1924
1925 // ----------------------------------------------------------------------------
1926 // sorting stuff
1927 // ----------------------------------------------------------------------------
1928
1929 // this is just a tiny namespace which is friend to wxTreeCtrl and so can use
1930 // functions such as IsDataIndirect()
1931 class wxTreeSortHelper
1932 {
1933 public:
1934 static int CALLBACK Compare(LPARAM data1, LPARAM data2, LPARAM tree);
1935
1936 private:
1937 static wxTreeItemId GetIdFromData(wxTreeCtrl *tree, LPARAM item)
1938 {
1939 wxTreeItemData *data = (wxTreeItemData *)item;
1940 if ( tree->IsDataIndirect(data) )
1941 {
1942 data = ((wxTreeItemIndirectData *)data)->GetData();
1943 }
1944
1945 return data->GetId();
1946 }
1947 };
1948
1949 int CALLBACK wxTreeSortHelper::Compare(LPARAM pItem1,
1950 LPARAM pItem2,
1951 LPARAM htree)
1952 {
1953 wxCHECK_MSG( pItem1 && pItem2, 0,
1954 wxT("sorting tree without data doesn't make sense") );
1955
1956 wxTreeCtrl *tree = (wxTreeCtrl *)htree;
1957
1958 return tree->OnCompareItems(GetIdFromData(tree, pItem1),
1959 GetIdFromData(tree, pItem2));
1960 }
1961
1962 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1963 const wxTreeItemId& item2)
1964 {
1965 return wxStrcmp(GetItemText(item1), GetItemText(item2));
1966 }
1967
1968 void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
1969 {
1970 // rely on the fact that TreeView_SortChildren does the same thing as our
1971 // default behaviour, i.e. sorts items alphabetically and so call it
1972 // directly if we're not in derived class (much more efficient!)
1973 if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
1974 {
1975 TreeView_SortChildren(GetHwnd(), HITEM(item), 0);
1976 }
1977 else
1978 {
1979 TV_SORTCB tvSort;
1980 tvSort.hParent = HITEM(item);
1981 tvSort.lpfnCompare = wxTreeSortHelper::Compare;
1982 tvSort.lParam = (LPARAM)this;
1983 TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
1984 }
1985 }
1986
1987 // ----------------------------------------------------------------------------
1988 // implementation
1989 // ----------------------------------------------------------------------------
1990
1991 bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
1992 {
1993 if ( cmd == EN_UPDATE )
1994 {
1995 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1996 event.SetEventObject( this );
1997 ProcessCommand(event);
1998 }
1999 else if ( cmd == EN_KILLFOCUS )
2000 {
2001 wxCommandEvent event(wxEVT_KILL_FOCUS, id);
2002 event.SetEventObject( this );
2003 ProcessCommand(event);
2004 }
2005 else
2006 {
2007 // nothing done
2008 return FALSE;
2009 }
2010
2011 // command processed
2012 return TRUE;
2013 }
2014
2015 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
2016 // only do it during dragging, minimize wxWin overhead (this is important for
2017 // WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
2018 // instead of passing by wxWin events
2019 long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2020 {
2021 bool processed = FALSE;
2022 long rc = 0;
2023 bool isMultiple = (GetWindowStyle() & wxTR_MULTIPLE) != 0;
2024
2025 if ( (nMsg >= WM_MOUSEFIRST) && (nMsg <= WM_MOUSELAST) )
2026 {
2027 // we only process mouse messages here and these parameters have the
2028 // same meaning for all of them
2029 int x = GET_X_LPARAM(lParam),
2030 y = GET_Y_LPARAM(lParam);
2031 HTREEITEM htItem = GetItemFromPoint(GetHwnd(), x, y);
2032
2033 switch ( nMsg )
2034 {
2035 case WM_RBUTTONDOWN:
2036 // if the item we are about to right click on
2037 // is not already select, remove the entire
2038 // previous selection
2039 if (!::IsItemSelected(GetHwnd(), htItem))
2040 {
2041 UnselectAll();
2042 }
2043
2044 // select item and set the focus to the
2045 // newly selected item
2046 ::SelectItem(GetHwnd(), htItem);
2047 ::SetFocus(GetHwnd(), htItem);
2048 break;
2049
2050 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2051 case WM_LBUTTONDOWN:
2052 if ( htItem && isMultiple )
2053 {
2054 if ( wParam & MK_CONTROL )
2055 {
2056 SetFocus();
2057
2058 // toggle selected state
2059 ToggleItemSelection(GetHwnd(), htItem);
2060
2061 ::SetFocus(GetHwnd(), htItem);
2062
2063 // reset on any click without Shift
2064 m_htSelStart = 0;
2065
2066 processed = TRUE;
2067 }
2068 else if ( wParam & MK_SHIFT )
2069 {
2070 // this selects all items between the starting one and
2071 // the current
2072
2073 if ( !m_htSelStart )
2074 {
2075 // take the focused item
2076 m_htSelStart = (WXHTREEITEM)
2077 TreeView_GetSelection(GetHwnd());
2078 }
2079
2080 SelectRange(GetHwnd(), HITEM(m_htSelStart), htItem,
2081 !(wParam & MK_CONTROL));
2082
2083 ::SetFocus(GetHwnd(), htItem);
2084
2085 processed = TRUE;
2086 }
2087 else // normal click
2088 {
2089 // clear the selection and then let the default handler
2090 // do the job
2091 UnselectAll();
2092
2093 // prevent the click from starting in-place editing
2094 // when there was no selection in the control
2095 TreeView_SelectItem(GetHwnd(), 0);
2096
2097 // reset on any click without Shift
2098 m_htSelStart = 0;
2099 }
2100 }
2101 break;
2102 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2103
2104 case WM_MOUSEMOVE:
2105 if ( m_dragImage )
2106 {
2107 m_dragImage->Move(wxPoint(x, y));
2108 if ( htItem )
2109 {
2110 // highlight the item as target (hiding drag image is
2111 // necessary - otherwise the display will be corrupted)
2112 m_dragImage->Hide();
2113 TreeView_SelectDropTarget(GetHwnd(), htItem);
2114 m_dragImage->Show();
2115 }
2116 }
2117 break;
2118
2119 case WM_LBUTTONUP:
2120 case WM_RBUTTONUP:
2121 if ( m_dragImage )
2122 {
2123 m_dragImage->EndDrag();
2124 delete m_dragImage;
2125 m_dragImage = NULL;
2126
2127 // generate the drag end event
2128 wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, m_windowId);
2129
2130 event.m_item = (WXHTREEITEM)htItem;
2131 event.m_pointDrag = wxPoint(x, y);
2132 event.SetEventObject(this);
2133
2134 (void)GetEventHandler()->ProcessEvent(event);
2135
2136 // if we don't do it, the tree seems to think that 2 items
2137 // are selected simultaneously which is quite weird
2138 TreeView_SelectDropTarget(GetHwnd(), 0);
2139 }
2140 break;
2141 }
2142 }
2143 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2144 else if ( (nMsg == WM_SETFOCUS || nMsg == WM_KILLFOCUS) && isMultiple )
2145 {
2146 // the tree control greys out the selected item when it loses focus and
2147 // paints it as selected again when it regains it, but it won't do it
2148 // for the other items itself - help it
2149 wxArrayTreeItemIds selections;
2150 size_t count = GetSelections(selections);
2151 RECT rect;
2152 for ( size_t n = 0; n < count; n++ )
2153 {
2154 // TreeView_GetItemRect() will return FALSE if item is not visible,
2155 // which may happen perfectly well
2156 if ( TreeView_GetItemRect(GetHwnd(), HITEM(selections[n]),
2157 &rect, TRUE) )
2158 {
2159 ::InvalidateRect(GetHwnd(), &rect, FALSE);
2160 }
2161 }
2162 }
2163 else if ( nMsg == WM_KEYDOWN && isMultiple )
2164 {
2165 bool bCtrl = wxIsCtrlDown(),
2166 bShift = wxIsShiftDown();
2167
2168 // we handle.arrows and space, but not page up/down and home/end: the
2169 // latter should be easy, but not the former
2170
2171 HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());
2172 if ( !m_htSelStart )
2173 {
2174 m_htSelStart = (WXHTREEITEM)htSel;
2175 }
2176
2177 if ( wParam == VK_SPACE )
2178 {
2179 if ( bCtrl )
2180 {
2181 ToggleItemSelection(GetHwnd(), htSel);
2182 }
2183 else
2184 {
2185 UnselectAll();
2186
2187 ::SelectItem(GetHwnd(), htSel);
2188 }
2189
2190 processed = TRUE;
2191 }
2192 else if ( wParam == VK_UP || wParam == VK_DOWN )
2193 {
2194 if ( !bCtrl && !bShift )
2195 {
2196 // no modifiers, just clear selection and then let the default
2197 // processing to take place
2198 UnselectAll();
2199 }
2200 else if ( htSel )
2201 {
2202 (void)wxControl::MSWWindowProc(nMsg, wParam, lParam);
2203
2204 HTREEITEM htNext = (HTREEITEM)(wParam == VK_UP
2205 ? TreeView_GetPrevVisible(GetHwnd(), htSel)
2206 : TreeView_GetNextVisible(GetHwnd(), htSel));
2207
2208 if ( !htNext )
2209 {
2210 // at the top/bottom
2211 htNext = htSel;
2212 }
2213
2214 if ( bShift )
2215 {
2216 SelectRange(GetHwnd(), HITEM(m_htSelStart), htNext);
2217 }
2218 else // bCtrl
2219 {
2220 // without changing selection
2221 ::SetFocus(GetHwnd(), htNext);
2222 }
2223
2224 processed = TRUE;
2225 }
2226 }
2227 }
2228 #endif // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2229 else if ( nMsg == WM_CHAR )
2230 {
2231 // don't let the control process Space and Return keys because it
2232 // doesn't do anything useful with them anyhow but always beeps
2233 // annoyingly when it receives them and there is no way to turn it off
2234 // simply if you just process TREEITEM_ACTIVATED event to which Space
2235 // and Enter presses are mapped in your code
2236 if ( wParam == VK_SPACE || wParam == VK_RETURN )
2237 {
2238 processed = true;
2239 }
2240 }
2241
2242 if ( !processed )
2243 rc = wxControl::MSWWindowProc(nMsg, wParam, lParam);
2244
2245 return rc;
2246 }
2247
2248 // process WM_NOTIFY Windows message
2249 bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
2250 {
2251 wxTreeEvent event(wxEVT_NULL, m_windowId);
2252 wxEventType eventType = wxEVT_NULL;
2253 NMHDR *hdr = (NMHDR *)lParam;
2254
2255 switch ( hdr->code )
2256 {
2257 case TVN_BEGINDRAG:
2258 eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
2259 // fall through
2260
2261 case TVN_BEGINRDRAG:
2262 {
2263 if ( eventType == wxEVT_NULL )
2264 eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
2265 //else: left drag, already set above
2266
2267 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
2268
2269 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2270 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
2271
2272 // don't allow dragging by default: the user code must
2273 // explicitly say that it wants to allow it to avoid breaking
2274 // the old apps
2275 event.Veto();
2276 }
2277 break;
2278
2279 case TVN_BEGINLABELEDIT:
2280 {
2281 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
2282 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2283
2284 event.m_item = (WXHTREEITEM) info->item.hItem;
2285 event.m_label = info->item.pszText;
2286 event.m_editCancelled = FALSE;
2287 }
2288 break;
2289
2290 case TVN_DELETEITEM:
2291 {
2292 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
2293 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
2294
2295 event.m_item = (WXHTREEITEM)tv->itemOld.hItem;
2296
2297 if ( m_hasAnyAttr )
2298 {
2299 delete (wxTreeItemAttr *)m_attrs.
2300 Delete((long)tv->itemOld.hItem);
2301 }
2302 }
2303 break;
2304
2305 case TVN_ENDLABELEDIT:
2306 {
2307 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
2308 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2309
2310 event.m_item = (WXHTREEITEM)info->item.hItem;
2311 event.m_label = info->item.pszText;
2312 if (info->item.pszText == NULL)
2313 {
2314 event.m_editCancelled = TRUE;
2315 }
2316 else
2317 {
2318 event.m_editCancelled = FALSE;
2319 }
2320 break;
2321 }
2322
2323 case TVN_GETDISPINFO:
2324 eventType = wxEVT_COMMAND_TREE_GET_INFO;
2325 // fall through
2326
2327 case TVN_SETDISPINFO:
2328 {
2329 if ( eventType == wxEVT_NULL )
2330 eventType = wxEVT_COMMAND_TREE_SET_INFO;
2331 //else: get, already set above
2332
2333 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2334
2335 event.m_item = (WXHTREEITEM) info->item.hItem;
2336 break;
2337 }
2338
2339 case TVN_ITEMEXPANDING:
2340 case TVN_ITEMEXPANDED:
2341 {
2342 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
2343
2344 int what;
2345 switch ( tv->action )
2346 {
2347 default:
2348 wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv->action);
2349 // fall through
2350
2351 case TVE_EXPAND:
2352 what = IDX_EXPAND;
2353 break;
2354
2355 case TVE_COLLAPSE:
2356 what = IDX_COLLAPSE;
2357 break;
2358 }
2359
2360 int how = hdr->code == TVN_ITEMEXPANDING ? IDX_DOING
2361 : IDX_DONE;
2362
2363 eventType = gs_expandEvents[what][how];
2364
2365 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2366 }
2367 break;
2368
2369 case TVN_KEYDOWN:
2370 {
2371 eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
2372 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
2373
2374 // fabricate the lParam and wParam parameters sufficiently
2375 // similar to the ones from a "real" WM_KEYDOWN so that
2376 // CreateKeyEvent() works correctly
2377 WXLPARAM lParam =
2378 (::GetKeyState(VK_MENU) & 0x100 ? KF_ALTDOWN : 0) << 16;
2379
2380 WXWPARAM wParam = info->wVKey;
2381
2382 int keyCode = wxCharCodeMSWToWX(info->wVKey);
2383 if ( !keyCode )
2384 {
2385 // wxCharCodeMSWToWX() returns 0 to indicate that this is a
2386 // simple ASCII key
2387 keyCode = wParam;
2388 }
2389
2390 event.m_evtKey = CreateKeyEvent(wxEVT_KEY_DOWN,
2391 keyCode,
2392 lParam,
2393 wParam);
2394
2395 // a separate event for Space/Return
2396 if ( !wxIsCtrlDown() && !wxIsShiftDown() &&
2397 ((info->wVKey == VK_SPACE) || (info->wVKey == VK_RETURN)) )
2398 {
2399 wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
2400 m_windowId);
2401 event2.SetEventObject(this);
2402 if ( !(GetWindowStyle() & wxTR_MULTIPLE) )
2403 {
2404 event2.m_item = GetSelection();
2405 }
2406 //else: don't know how to get it
2407
2408 (void)GetEventHandler()->ProcessEvent(event2);
2409 }
2410 }
2411 break;
2412
2413 // NB: MSLU is broken and sends TVN_SELCHANGEDA instead of
2414 // TVN_SELCHANGEDW in Unicode mode under Win98. Therefore
2415 // we have to handle both messages:
2416 case TVN_SELCHANGEDA:
2417 case TVN_SELCHANGEDW:
2418 eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
2419 // fall through
2420
2421 case TVN_SELCHANGINGA:
2422 case TVN_SELCHANGINGW:
2423 {
2424 if ( eventType == wxEVT_NULL )
2425 eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
2426 //else: already set above
2427
2428 if (hdr->code == TVN_SELCHANGINGW ||
2429 hdr->code == TVN_SELCHANGEDW)
2430 {
2431 NM_TREEVIEWW* tv = (NM_TREEVIEWW *)lParam;
2432 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2433 event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
2434 }
2435 else
2436 {
2437 NM_TREEVIEWA* tv = (NM_TREEVIEWA *)lParam;
2438 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2439 event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
2440 }
2441 }
2442 break;
2443
2444 #if defined(_WIN32_IE) && _WIN32_IE >= 0x300 && !wxUSE_COMCTL32_SAFELY && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
2445 case NM_CUSTOMDRAW:
2446 {
2447 LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;
2448 NMCUSTOMDRAW& nmcd = lptvcd->nmcd;
2449 switch ( nmcd.dwDrawStage )
2450 {
2451 case CDDS_PREPAINT:
2452 // if we've got any items with non standard attributes,
2453 // notify us before painting each item
2454 *result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
2455 : CDRF_DODEFAULT;
2456 break;
2457
2458 case CDDS_ITEMPREPAINT:
2459 {
2460 wxTreeItemAttr *attr =
2461 (wxTreeItemAttr *)m_attrs.Get(nmcd.dwItemSpec);
2462
2463 if ( !attr )
2464 {
2465 // nothing to do for this item
2466 *result = CDRF_DODEFAULT;
2467 break;
2468 }
2469
2470 HFONT hFont;
2471 if ( attr->HasFont() )
2472 {
2473 hFont = GetHfontOf(attr->GetFont());
2474 }
2475 else
2476 {
2477 hFont = 0;
2478 }
2479
2480 wxColour colText;
2481 if ( attr->HasTextColour() )
2482 {
2483 colText = attr->GetTextColour();
2484 }
2485 else
2486 {
2487 colText = GetForegroundColour();
2488 }
2489
2490 // selection colours should override ours
2491 if ( nmcd.uItemState & CDIS_SELECTED )
2492 {
2493 lptvcd->clrTextBk =
2494 ::GetSysColor(COLOR_HIGHLIGHT);
2495 lptvcd->clrText =
2496 ::GetSysColor(COLOR_HIGHLIGHTTEXT);
2497 }
2498 else // !selected
2499 {
2500 wxColour colBack;
2501 if ( attr->HasBackgroundColour() )
2502 {
2503 colBack = attr->GetBackgroundColour();
2504 }
2505 else
2506 {
2507 colBack = GetBackgroundColour();
2508 }
2509
2510 lptvcd->clrText = wxColourToRGB(colText);
2511 lptvcd->clrTextBk = wxColourToRGB(colBack);
2512 }
2513
2514 // note that if we wanted to set colours for
2515 // individual columns (subitems), we would have
2516 // returned CDRF_NOTIFYSUBITEMREDRAW from here
2517 if ( hFont )
2518 {
2519 ::SelectObject(nmcd.hdc, hFont);
2520
2521 *result = CDRF_NEWFONT;
2522 }
2523 else
2524 {
2525 *result = CDRF_DODEFAULT;
2526 }
2527 }
2528 break;
2529
2530 default:
2531 *result = CDRF_DODEFAULT;
2532 }
2533 }
2534
2535 // we always process it
2536 return TRUE;
2537 #endif // _WIN32_IE >= 0x300
2538
2539 case NM_DBLCLK:
2540 case NM_RCLICK:
2541 {
2542 TV_HITTESTINFO tvhti;
2543 ::GetCursorPos(&tvhti.pt);
2544 ::ScreenToClient(GetHwnd(), &tvhti.pt);
2545 if ( TreeView_HitTest(GetHwnd(), &tvhti) )
2546 {
2547 if ( tvhti.flags & TVHT_ONITEM )
2548 {
2549 event.m_item = (WXHTREEITEM) tvhti.hItem;
2550 eventType = (int)hdr->code == NM_DBLCLK
2551 ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
2552 : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
2553
2554 event.m_pointDrag.x = tvhti.pt.x;
2555 event.m_pointDrag.y = tvhti.pt.y;
2556 }
2557
2558 break;
2559 }
2560 }
2561 // fall through
2562
2563 default:
2564 return wxControl::MSWOnNotify(idCtrl, lParam, result);
2565 }
2566
2567 event.SetEventObject(this);
2568 event.SetEventType(eventType);
2569
2570 bool processed = GetEventHandler()->ProcessEvent(event);
2571
2572 // post processing
2573 switch ( hdr->code )
2574 {
2575 case NM_DBLCLK:
2576 // we translate NM_DBLCLK into ACTIVATED event, so don't interpret
2577 // the return code of this event handler as the return value for
2578 // NM_DBLCLK - otherwise, double clicking the item to toggle its
2579 // expanded status would never work
2580 *result = FALSE;
2581 break;
2582
2583 case TVN_BEGINDRAG:
2584 case TVN_BEGINRDRAG:
2585 if ( event.IsAllowed() )
2586 {
2587 // normally this is impossible because the m_dragImage is
2588 // deleted once the drag operation is over
2589 wxASSERT_MSG( !m_dragImage, _T("starting to drag once again?") );
2590
2591 m_dragImage = new wxDragImage(*this, event.m_item);
2592 m_dragImage->BeginDrag(wxPoint(0, 0), this);
2593 m_dragImage->Show();
2594 }
2595 break;
2596
2597 case TVN_DELETEITEM:
2598 {
2599 // NB: we might process this message using wxWindows event
2600 // tables, but due to overhead of wxWin event system we
2601 // prefer to do it here ourself (otherwise deleting a tree
2602 // with many items is just too slow)
2603 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
2604
2605 wxTreeItemId item = event.m_item;
2606 if ( HasIndirectData(item) )
2607 {
2608 wxTreeItemIndirectData *data = (wxTreeItemIndirectData *)
2609 tv->itemOld.lParam;
2610 delete data; // can't be NULL here
2611 }
2612 else
2613 {
2614 wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
2615 delete data; // may be NULL, ok
2616 }
2617
2618 processed = TRUE; // Make sure we don't get called twice
2619 }
2620 break;
2621
2622 case TVN_BEGINLABELEDIT:
2623 // return TRUE to cancel label editing
2624 *result = !event.IsAllowed();
2625 // set ES_WANTRETURN ( like we do in BeginLabelEdit )
2626 if(event.IsAllowed())
2627 {
2628 HWND hText = TreeView_GetEditControl(GetHwnd());
2629 if(hText != NULL)
2630 {
2631 // MBN: if m_textCtrl already has an HWND, it is a stale
2632 // pointer from a previous edit (because the user
2633 // didn't modify the label before dismissing the control,
2634 // and TVN_ENDLABELEDIT was not sent), so delete it
2635 if(m_textCtrl && m_textCtrl->GetHWND() != 0)
2636 DeleteTextCtrl();
2637 if(!m_textCtrl)
2638 m_textCtrl = new wxTextCtrl();
2639 m_textCtrl->SetParent(this);
2640 m_textCtrl->SetHWND((WXHWND)hText);
2641 m_textCtrl->SubclassWin((WXHWND)hText);
2642
2643 // set wxTE_PROCESS_ENTER style for the text control to
2644 // force it to process the Enter presses itself, otherwise
2645 // they could be stolen from it by the dialog
2646 // navigation code
2647 m_textCtrl->SetWindowStyle(m_textCtrl->GetWindowStyle()
2648 | wxTE_PROCESS_ENTER);
2649 }
2650 }
2651 break;
2652
2653 case TVN_ENDLABELEDIT:
2654 // return TRUE to set the label to the new string: note that we
2655 // also must pretend that we did process the message or it is going
2656 // to be passed to DefWindowProc() which will happily return FALSE
2657 // cancelling the label change
2658 *result = event.IsAllowed();
2659 processed = TRUE;
2660
2661 // ensure that we don't have the text ctrl which is going to be
2662 // deleted any more
2663 DeleteTextCtrl();
2664 break;
2665
2666 case TVN_SELCHANGING:
2667 case TVN_ITEMEXPANDING:
2668 // return TRUE to prevent the action from happening
2669 *result = !event.IsAllowed();
2670 break;
2671
2672 case TVN_ITEMEXPANDED:
2673 // the item is not refreshed properly after expansion when it has
2674 // an image depending on the expanded/collapsed state - bug in
2675 // comctl32.dll or our code?
2676 {
2677 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
2678 wxTreeItemId id = (WXHTREEITEM)tv->itemNew.hItem;
2679
2680 int image = GetItemImage(id, wxTreeItemIcon_Expanded);
2681 if ( image != -1 )
2682 {
2683 RefreshItem(id);
2684 }
2685 }
2686 break;
2687
2688 case TVN_GETDISPINFO:
2689 // NB: so far the user can't set the image himself anyhow, so do it
2690 // anyway - but this may change later
2691 //if ( /* !processed && */ 1 )
2692 {
2693 wxTreeItemId item = event.m_item;
2694 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2695 if ( info->item.mask & TVIF_IMAGE )
2696 {
2697 info->item.iImage =
2698 DoGetItemImageFromData
2699 (
2700 item,
2701 IsExpanded(item) ? wxTreeItemIcon_Expanded
2702 : wxTreeItemIcon_Normal
2703 );
2704 }
2705 if ( info->item.mask & TVIF_SELECTEDIMAGE )
2706 {
2707 info->item.iSelectedImage =
2708 DoGetItemImageFromData
2709 (
2710 item,
2711 IsExpanded(item) ? wxTreeItemIcon_SelectedExpanded
2712 : wxTreeItemIcon_Selected
2713 );
2714 }
2715 }
2716 break;
2717
2718 //default:
2719 // for the other messages the return value is ignored and there is
2720 // nothing special to do
2721 }
2722 return processed;
2723 }
2724
2725 #endif // __WIN95__
2726
2727 #endif // wxUSE_TREECTRL