]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/treectrl.cpp
Committing in .
[wxWidgets.git] / src / msw / treectrl.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: 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#ifdef __GNUG__
20 #pragma implementation "treectrl.h"
21#endif
22
23// For compilers that support precompilation, includes "wx.h".
24#include "wx/wxprec.h"
25
26#ifdef __BORLANDC__
27 #pragma hdrstop
28#endif
29
30#include "wx/window.h"
31#include "wx/msw/private.h"
32
33// Mingw32 is a bit mental even though this is done in winundef
34#ifdef GetFirstChild
35 #undef GetFirstChild
36#endif
37
38#ifdef GetNextSibling
39 #undef GetNextSibling
40#endif
41
42#if defined(__WIN95__)
43
44#include "wx/log.h"
45#include "wx/dynarray.h"
46#include "wx/imaglist.h"
47#include "wx/treectrl.h"
48#include "wx/settings.h"
49
50#ifdef __GNUWIN32__
51#ifndef wxUSE_NORLANDER_HEADERS
52#include "wx/msw/gnuwin32/extra.h"
53#endif
54#endif
55
56#if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__) || defined(wxUSE_NORLANDER_HEADERS)
57 #include <commctrl.h>
58#endif
59
60// Bug in headers, sometimes
61#ifndef TVIS_FOCUSED
62 #define TVIS_FOCUSED 0x0001
63#endif
64
65// ----------------------------------------------------------------------------
66// private classes
67// ----------------------------------------------------------------------------
68
69// a convenient wrapper around TV_ITEM struct which adds a ctor
70#ifdef __VISUALC__
71#pragma warning( disable : 4097 )
72#endif
73
74struct wxTreeViewItem : public TV_ITEM
75{
76 wxTreeViewItem(const wxTreeItemId& item, // the item handle
77 UINT mask_, // fields which are valid
78 UINT stateMask_ = 0) // for TVIF_STATE only
79 {
80 // hItem member is always valid
81 mask = mask_ | TVIF_HANDLE;
82 stateMask = stateMask_;
83 hItem = (HTREEITEM) (WXHTREEITEM) item;
84 }
85};
86
87#ifdef __VISUALC__
88#pragma warning( default : 4097 )
89#endif
90
91// a class which encapsulates the tree traversal logic: it vists all (unless
92// OnVisit() returns FALSE) items under the given one
93class wxTreeTraversal
94{
95public:
96 wxTreeTraversal(const wxTreeCtrl *tree)
97 {
98 m_tree = tree;
99 }
100
101 // do traverse the tree: visit all items (recursively by default) under the
102 // given one; return TRUE if all items were traversed or FALSE if the
103 // traversal was aborted because OnVisit returned FALSE
104 bool DoTraverse(const wxTreeItemId& root, bool recursively = TRUE);
105
106 // override this function to do whatever is needed for each item, return
107 // FALSE to stop traversing
108 virtual bool OnVisit(const wxTreeItemId& item) = 0;
109
110protected:
111 const wxTreeCtrl *GetTree() const { return m_tree; }
112
113private:
114 bool Traverse(const wxTreeItemId& root, bool recursively);
115
116 const wxTreeCtrl *m_tree;
117};
118
119// internal class for getting the selected items
120class TraverseSelections : public wxTreeTraversal
121{
122public:
123 TraverseSelections(const wxTreeCtrl *tree,
124 wxArrayTreeItemIds& selections)
125 : wxTreeTraversal(tree), m_selections(selections)
126 {
127 m_selections.Empty();
128
129 DoTraverse(tree->GetRootItem());
130 }
131
132 virtual bool OnVisit(const wxTreeItemId& item)
133 {
134 if ( GetTree()->IsItemChecked(item) )
135 {
136 m_selections.Add(item);
137 }
138
139 return TRUE;
140 }
141
142private:
143 wxArrayTreeItemIds& m_selections;
144};
145
146// internal class for counting tree items
147class TraverseCounter : public wxTreeTraversal
148{
149public:
150 TraverseCounter(const wxTreeCtrl *tree,
151 const wxTreeItemId& root,
152 bool recursively)
153 : wxTreeTraversal(tree)
154 {
155 m_count = 0;
156
157 DoTraverse(root, recursively);
158 }
159
160 virtual bool OnVisit(const wxTreeItemId& item)
161 {
162 m_count++;
163
164 return TRUE;
165 }
166
167 size_t GetCount() const { return m_count; }
168
169private:
170 size_t m_count;
171};
172
173// ----------------------------------------------------------------------------
174// This class is needed for support of different images: the Win32 common
175// control natively supports only 2 images (the normal one and another for the
176// selected state). We wish to provide support for 2 more of them for folder
177// items (i.e. those which have children): for expanded state and for expanded
178// selected state. For this we use this structure to store the additional items
179// images.
180//
181// There is only one problem with this: when we retrieve the item's data, we
182// don't know whether we get a pointer to wxTreeItemData or
183// wxTreeItemIndirectData. So we have to maintain a list of all items which
184// have indirect data inside the listctrl itself.
185// ----------------------------------------------------------------------------
186class wxTreeItemIndirectData
187{
188public:
189 // ctor associates this data with the item and the real item data becomes
190 // available through our GetData() method
191 wxTreeItemIndirectData(wxTreeCtrl *tree, const wxTreeItemId& item)
192 {
193 for ( size_t n = 0; n < WXSIZEOF(m_images); n++ )
194 {
195 m_images[n] = -1;
196 }
197
198 // save the old data
199 m_data = tree->GetItemData(item);
200
201 // and set ourselves as the new one
202 tree->SetIndirectItemData(item, this);
203 }
204
205 // dtor deletes the associated data as well
206 ~wxTreeItemIndirectData() { delete m_data; }
207
208 // accessors
209 // get the real data associated with the item
210 wxTreeItemData *GetData() const { return m_data; }
211 // change it
212 void SetData(wxTreeItemData *data) { m_data = data; }
213
214 // do we have such image?
215 bool HasImage(wxTreeItemIcon which) const { return m_images[which] != -1; }
216 // get image
217 int GetImage(wxTreeItemIcon which) const { return m_images[which]; }
218 // change it
219 void SetImage(int image, wxTreeItemIcon which) { m_images[which] = image; }
220
221private:
222 // all the images associated with the item
223 int m_images[wxTreeItemIcon_Max];
224
225 wxTreeItemData *m_data;
226};
227
228// ----------------------------------------------------------------------------
229// macros
230// ----------------------------------------------------------------------------
231
232#if !USE_SHARED_LIBRARY
233 IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
234#endif
235
236// ----------------------------------------------------------------------------
237// variables
238// ----------------------------------------------------------------------------
239
240// handy table for sending events
241static const wxEventType g_events[2][2] =
242{
243 { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
244 { wxEVT_COMMAND_TREE_ITEM_EXPANDED, wxEVT_COMMAND_TREE_ITEM_EXPANDING }
245};
246
247// ============================================================================
248// implementation
249// ============================================================================
250
251// ----------------------------------------------------------------------------
252// tree traversal
253// ----------------------------------------------------------------------------
254
255bool wxTreeTraversal::DoTraverse(const wxTreeItemId& root, bool recursively)
256{
257 if ( !OnVisit(root) )
258 return FALSE;
259
260 return Traverse(root, recursively);
261}
262
263bool wxTreeTraversal::Traverse(const wxTreeItemId& root, bool recursively)
264{
265 long cookie;
266 wxTreeItemId child = m_tree->GetFirstChild(root, cookie);
267 while ( child.IsOk() )
268 {
269 // depth first traversal
270 if ( recursively && !Traverse(child, TRUE) )
271 return FALSE;
272
273 if ( !OnVisit(child) )
274 return FALSE;
275
276 child = m_tree->GetNextChild(root, cookie);
277 }
278
279 return TRUE;
280}
281
282// ----------------------------------------------------------------------------
283// construction and destruction
284// ----------------------------------------------------------------------------
285
286void wxTreeCtrl::Init()
287{
288 m_imageListNormal = NULL;
289 m_imageListState = NULL;
290 m_textCtrl = NULL;
291}
292
293bool wxTreeCtrl::Create(wxWindow *parent,
294 wxWindowID id,
295 const wxPoint& pos,
296 const wxSize& size,
297 long style,
298 const wxValidator& validator,
299 const wxString& name)
300{
301 Init();
302
303 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
304 return FALSE;
305
306 DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
307 TVS_HASLINES | TVS_SHOWSELALWAYS;
308
309 if ( m_windowStyle & wxTR_HAS_BUTTONS )
310 wstyle |= TVS_HASBUTTONS;
311
312 if ( m_windowStyle & wxTR_EDIT_LABELS )
313 wstyle |= TVS_EDITLABELS;
314
315 if ( m_windowStyle & wxTR_LINES_AT_ROOT )
316 wstyle |= TVS_LINESATROOT;
317
318#if !defined( __GNUWIN32__ ) && !defined( __BORLANDC__ ) && !defined( __WATCOMC__ ) && !defined(wxUSE_NORLANDER_HEADERS)
319 // we emulate the multiple selection tree controls by using checkboxes: set
320 // up the image list we need for this if we do have multiple selections
321#if !defined(__VISUALC__) || (__VISUALC__ > 1010)
322 if ( m_windowStyle & wxTR_MULTIPLE )
323 wstyle |= TVS_CHECKBOXES;
324#endif
325#endif
326
327 // Create the tree control.
328 if ( !MSWCreateControl(WC_TREEVIEW, wstyle) )
329 return FALSE;
330
331 SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
332 SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
333
334 // VZ: this is some experimental code which may be used to get the
335 // TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
336 // AFAIK, the standard DLL does about the same thing anyhow.
337#if 0
338 if ( m_windowStyle & wxTR_MULTIPLE )
339 {
340 wxBitmap bmp;
341
342 // create the DC compatible with the current screen
343 HDC hdcMem = CreateCompatibleDC(NULL);
344
345 // create a mono bitmap of the standard size
346 int x = GetSystemMetrics(SM_CXMENUCHECK);
347 int y = GetSystemMetrics(SM_CYMENUCHECK);
348 wxImageList imagelistCheckboxes(x, y, FALSE, 2);
349 HBITMAP hbmpCheck = CreateBitmap(x, y, // bitmap size
350 1, // # of color planes
351 1, // # bits needed for one pixel
352 0); // array containing colour data
353 SelectObject(hdcMem, hbmpCheck);
354
355 // then draw a check mark into it
356 RECT rect = { 0, 0, x, y };
357 if ( !::DrawFrameControl(hdcMem, &rect,
358 DFC_BUTTON,
359 DFCS_BUTTONCHECK | DFCS_CHECKED) )
360 {
361 wxLogLastError(wxT("DrawFrameControl(check)"));
362 }
363
364 bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
365 imagelistCheckboxes.Add(bmp);
366
367 if ( !::DrawFrameControl(hdcMem, &rect,
368 DFC_BUTTON,
369 DFCS_BUTTONCHECK) )
370 {
371 wxLogLastError(wxT("DrawFrameControl(uncheck)"));
372 }
373
374 bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
375 imagelistCheckboxes.Add(bmp);
376
377 // clean up
378 ::DeleteDC(hdcMem);
379
380 // set the imagelist
381 SetStateImageList(&imagelistCheckboxes);
382 }
383#endif // 0
384
385 SetSize(pos.x, pos.y, size.x, size.y);
386
387 return TRUE;
388}
389
390wxTreeCtrl::~wxTreeCtrl()
391{
392 DeleteTextCtrl();
393
394 // delete user data to prevent memory leaks
395 DeleteAllItems();
396}
397
398// ----------------------------------------------------------------------------
399// accessors
400// ----------------------------------------------------------------------------
401
402// simple wrappers which add error checking in debug mode
403
404bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
405{
406 if ( !TreeView_GetItem(GetHwnd(), tvItem) )
407 {
408 wxLogLastError("TreeView_GetItem");
409
410 return FALSE;
411 }
412
413 return TRUE;
414}
415
416void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
417{
418 if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
419 {
420 wxLogLastError("TreeView_SetItem");
421 }
422}
423
424size_t wxTreeCtrl::GetCount() const
425{
426 return (size_t)TreeView_GetCount(GetHwnd());
427}
428
429unsigned int wxTreeCtrl::GetIndent() const
430{
431 return TreeView_GetIndent(GetHwnd());
432}
433
434void wxTreeCtrl::SetIndent(unsigned int indent)
435{
436 TreeView_SetIndent(GetHwnd(), indent);
437}
438
439wxImageList *wxTreeCtrl::GetImageList() const
440{
441 return m_imageListNormal;
442}
443
444wxImageList *wxTreeCtrl::GetStateImageList() const
445{
446 return m_imageListNormal;
447}
448
449void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
450{
451 // no error return
452 TreeView_SetImageList(GetHwnd(),
453 imageList ? imageList->GetHIMAGELIST() : 0,
454 which);
455}
456
457void wxTreeCtrl::SetImageList(wxImageList *imageList)
458{
459 SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
460}
461
462void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
463{
464 SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
465}
466
467size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
468 bool recursively) const
469{
470 TraverseCounter counter(this, item, recursively);
471
472 return counter.GetCount() - 1;
473}
474
475// ----------------------------------------------------------------------------
476// Item access
477// ----------------------------------------------------------------------------
478
479wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
480{
481 wxChar buf[512]; // the size is arbitrary...
482
483 wxTreeViewItem tvItem(item, TVIF_TEXT);
484 tvItem.pszText = buf;
485 tvItem.cchTextMax = WXSIZEOF(buf);
486 if ( !DoGetItem(&tvItem) )
487 {
488 // don't return some garbage which was on stack, but an empty string
489 buf[0] = wxT('\0');
490 }
491
492 return wxString(buf);
493}
494
495void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
496{
497 wxTreeViewItem tvItem(item, TVIF_TEXT);
498 tvItem.pszText = (wxChar *)text.c_str(); // conversion is ok
499 DoSetItem(&tvItem);
500}
501
502int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,
503 wxTreeItemIcon which) const
504{
505 wxTreeViewItem tvItem(item, TVIF_PARAM);
506 if ( !DoGetItem(&tvItem) )
507 {
508 return -1;
509 }
510
511 return ((wxTreeItemIndirectData *)tvItem.lParam)->GetImage(which);
512}
513
514void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId& item,
515 int image,
516 wxTreeItemIcon which) const
517{
518 wxTreeViewItem tvItem(item, TVIF_PARAM);
519 if ( !DoGetItem(&tvItem) )
520 {
521 return;
522 }
523
524 wxTreeItemIndirectData *data = ((wxTreeItemIndirectData *)tvItem.lParam);
525
526 data->SetImage(image, which);
527
528 // make sure that we have selected images as well
529 if ( which == wxTreeItemIcon_Normal &&
530 !data->HasImage(wxTreeItemIcon_Selected) )
531 {
532 data->SetImage(image, wxTreeItemIcon_Selected);
533 }
534
535 if ( which == wxTreeItemIcon_Expanded &&
536 !data->HasImage(wxTreeItemIcon_SelectedExpanded) )
537 {
538 data->SetImage(image, wxTreeItemIcon_SelectedExpanded);
539 }
540}
541
542void wxTreeCtrl::DoSetItemImages(const wxTreeItemId& item,
543 int image,
544 int imageSel)
545{
546 wxTreeViewItem tvItem(item, TVIF_IMAGE | TVIF_SELECTEDIMAGE);
547 tvItem.iSelectedImage = imageSel;
548 tvItem.iImage = image;
549 DoSetItem(&tvItem);
550}
551
552int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
553 wxTreeItemIcon which) const
554{
555 if ( HasIndirectData(item) )
556 {
557 return DoGetItemImageFromData(item, which);
558 }
559
560 UINT mask;
561 switch ( which )
562 {
563 default:
564 wxFAIL_MSG( wxT("unknown tree item image type") );
565
566 case wxTreeItemIcon_Normal:
567 mask = TVIF_IMAGE;
568 break;
569
570 case wxTreeItemIcon_Selected:
571 mask = TVIF_SELECTEDIMAGE;
572 break;
573
574 case wxTreeItemIcon_Expanded:
575 case wxTreeItemIcon_SelectedExpanded:
576 return -1;
577 }
578
579 wxTreeViewItem tvItem(item, mask);
580 DoGetItem(&tvItem);
581
582 return mask == TVIF_IMAGE ? tvItem.iImage : tvItem.iSelectedImage;
583}
584
585void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
586 wxTreeItemIcon which)
587{
588 int imageNormal, imageSel;
589 switch ( which )
590 {
591 default:
592 wxFAIL_MSG( wxT("unknown tree item image type") );
593
594 case wxTreeItemIcon_Normal:
595 imageNormal = image;
596 imageSel = GetItemSelectedImage(item);
597 break;
598
599 case wxTreeItemIcon_Selected:
600 imageNormal = GetItemImage(item);
601 imageSel = image;
602 break;
603
604 case wxTreeItemIcon_Expanded:
605 case wxTreeItemIcon_SelectedExpanded:
606 if ( !HasIndirectData(item) )
607 {
608 // we need to get the old images first, because after we create
609 // the wxTreeItemIndirectData GetItemXXXImage() will use it to
610 // get the images
611 imageNormal = GetItemImage(item);
612 imageSel = GetItemSelectedImage(item);
613
614 // if it doesn't have it yet, add it
615 wxTreeItemIndirectData *data = new
616 wxTreeItemIndirectData(this, item);
617
618 // copy the data to the new location
619 data->SetImage(imageNormal, wxTreeItemIcon_Normal);
620 data->SetImage(imageSel, wxTreeItemIcon_Selected);
621 }
622
623 DoSetItemImageFromData(item, image, which);
624
625 // reset the normal/selected images because we won't use them any
626 // more - now they're stored inside the indirect data
627 imageNormal =
628 imageSel = I_IMAGECALLBACK;
629 break;
630 }
631
632 // NB: at least in version 5.00.0518.9 of comctl32.dll we need to always
633 // change both normal and selected image - otherwise the change simply
634 // doesn't take place!
635 DoSetItemImages(item, imageNormal, imageSel);
636}
637
638wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
639{
640 wxTreeViewItem tvItem(item, TVIF_PARAM);
641 if ( !DoGetItem(&tvItem) )
642 {
643 return NULL;
644 }
645
646 if ( HasIndirectData(item) )
647 {
648 return ((wxTreeItemIndirectData *)tvItem.lParam)->GetData();
649 }
650 else
651 {
652 return (wxTreeItemData *)tvItem.lParam;
653 }
654}
655
656void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
657{
658 wxTreeViewItem tvItem(item, TVIF_PARAM);
659
660 if ( HasIndirectData(item) )
661 {
662 if ( DoGetItem(&tvItem) )
663 {
664 ((wxTreeItemIndirectData *)tvItem.lParam)->SetData(data);
665 }
666 else
667 {
668 wxFAIL_MSG( wxT("failed to change tree items data") );
669 }
670 }
671 else
672 {
673 tvItem.lParam = (LPARAM)data;
674 DoSetItem(&tvItem);
675 }
676}
677
678void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId& item,
679 wxTreeItemIndirectData *data)
680{
681 // this should never happen because it's unnecessary and will probably lead
682 // to crash too because the code elsewhere supposes that the pointer the
683 // wxTreeItemIndirectData has is a real wxItemData and not
684 // wxTreeItemIndirectData as well
685 wxASSERT_MSG( !HasIndirectData(item), wxT("setting indirect data twice?") );
686
687 SetItemData(item, (wxTreeItemData *)data);
688
689 m_itemsWithIndirectData.Add(item);
690}
691
692bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
693{
694 return m_itemsWithIndirectData.Index(item) != wxNOT_FOUND;
695}
696
697void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
698{
699 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
700 tvItem.cChildren = (int)has;
701 DoSetItem(&tvItem);
702}
703
704void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
705{
706 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
707 tvItem.state = bold ? TVIS_BOLD : 0;
708 DoSetItem(&tvItem);
709}
710
711void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
712{
713 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
714 tvItem.state = highlight ? TVIS_DROPHILITED : 0;
715 DoSetItem(&tvItem);
716}
717
718// ----------------------------------------------------------------------------
719// Item status
720// ----------------------------------------------------------------------------
721
722bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
723{
724 // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
725 RECT rect;
726 return SendMessage(GetHwnd(), TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
727
728}
729
730bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
731{
732 wxTreeViewItem tvItem(item, TVIF_CHILDREN);
733 DoGetItem(&tvItem);
734
735 return tvItem.cChildren != 0;
736}
737
738bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
739{
740 // probably not a good idea to put it here
741 //wxASSERT( ItemHasChildren(item) );
742
743 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
744 DoGetItem(&tvItem);
745
746 return (tvItem.state & TVIS_EXPANDED) != 0;
747}
748
749bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
750{
751 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
752 DoGetItem(&tvItem);
753
754 return (tvItem.state & TVIS_SELECTED) != 0;
755}
756
757bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
758{
759 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
760 DoGetItem(&tvItem);
761
762 return (tvItem.state & TVIS_BOLD) != 0;
763}
764
765// ----------------------------------------------------------------------------
766// navigation
767// ----------------------------------------------------------------------------
768
769wxTreeItemId wxTreeCtrl::GetRootItem() const
770{
771 return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(GetHwnd()));
772}
773
774wxTreeItemId wxTreeCtrl::GetSelection() const
775{
776 wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), (WXHTREEITEM)0,
777 wxT("this only works with single selection controls") );
778
779 return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(GetHwnd()));
780}
781
782wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
783{
784 return wxTreeItemId((WXHTREEITEM) TreeView_GetParent(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
785}
786
787wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
788 long& _cookie) const
789{
790 // remember the last child returned in 'cookie'
791 _cookie = (long)TreeView_GetChild(GetHwnd(), (HTREEITEM) (WXHTREEITEM)item);
792
793 return wxTreeItemId((WXHTREEITEM)_cookie);
794}
795
796wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
797 long& _cookie) const
798{
799 wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(GetHwnd(),
800 (HTREEITEM)(WXHTREEITEM)_cookie));
801 _cookie = (long)l;
802
803 return l;
804}
805
806wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
807{
808 // can this be done more efficiently?
809 long cookie;
810
811 wxTreeItemId childLast,
812 child = GetFirstChild(item, cookie);
813 while ( child.IsOk() )
814 {
815 childLast = child;
816 child = GetNextChild(item, cookie);
817 }
818
819 return childLast;
820}
821
822wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
823{
824 return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
825}
826
827wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
828{
829 return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
830}
831
832wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
833{
834 return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(GetHwnd()));
835}
836
837wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
838{
839 wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() "
840 "for must be visible itself!"));
841
842 return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
843}
844
845wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
846{
847 wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() "
848 "for must be visible itself!"));
849
850 return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
851}
852
853// ----------------------------------------------------------------------------
854// multiple selections emulation
855// ----------------------------------------------------------------------------
856
857bool wxTreeCtrl::IsItemChecked(const wxTreeItemId& item) const
858{
859 // receive the desired information.
860 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
861 DoGetItem(&tvItem);
862
863 // state image indices are 1 based
864 return ((tvItem.state >> 12) - 1) == 1;
865}
866
867void wxTreeCtrl::SetItemCheck(const wxTreeItemId& item, bool check)
868{
869 // receive the desired information.
870 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
871
872 // state images are one-based
873 tvItem.state = (check ? 2 : 1) << 12;
874
875 DoSetItem(&tvItem);
876}
877
878size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
879{
880 TraverseSelections selector(this, selections);
881
882 return selections.GetCount();
883}
884
885// ----------------------------------------------------------------------------
886// Usual operations
887// ----------------------------------------------------------------------------
888
889wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
890 wxTreeItemId hInsertAfter,
891 const wxString& text,
892 int image, int selectedImage,
893 wxTreeItemData *data)
894{
895 TV_INSERTSTRUCT tvIns;
896 tvIns.hParent = (HTREEITEM) (WXHTREEITEM)parent;
897 tvIns.hInsertAfter = (HTREEITEM) (WXHTREEITEM) hInsertAfter;
898
899 // this is how we insert the item as the first child: supply a NULL
900 // hInsertAfter
901 if ( !tvIns.hInsertAfter )
902 {
903 tvIns.hInsertAfter = TVI_FIRST;
904 }
905
906 UINT mask = 0;
907 if ( !text.IsEmpty() )
908 {
909 mask |= TVIF_TEXT;
910 tvIns.item.pszText = (wxChar *)text.c_str(); // cast is ok
911 }
912
913 if ( image != -1 )
914 {
915 mask |= TVIF_IMAGE;
916 tvIns.item.iImage = image;
917
918 if ( selectedImage == -1 )
919 {
920 // take the same image for selected icon if not specified
921 selectedImage = image;
922 }
923 }
924
925 if ( selectedImage != -1 )
926 {
927 mask |= TVIF_SELECTEDIMAGE;
928 tvIns.item.iSelectedImage = selectedImage;
929 }
930
931 if ( data != NULL )
932 {
933 mask |= TVIF_PARAM;
934 tvIns.item.lParam = (LPARAM)data;
935 }
936
937 tvIns.item.mask = mask;
938
939 HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
940 if ( id == 0 )
941 {
942 wxLogLastError("TreeView_InsertItem");
943 }
944
945 if ( data != NULL )
946 {
947 // associate the application tree item with Win32 tree item handle
948 data->SetId((WXHTREEITEM)id);
949 }
950
951 return wxTreeItemId((WXHTREEITEM)id);
952}
953
954// for compatibility only
955wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
956 const wxString& text,
957 int image, int selImage,
958 long insertAfter)
959{
960 return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
961 image, selImage, NULL);
962}
963
964wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
965 int image, int selectedImage,
966 wxTreeItemData *data)
967{
968 return DoInsertItem(wxTreeItemId((WXHTREEITEM) 0), (WXHTREEITEM) 0,
969 text, image, selectedImage, data);
970}
971
972wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
973 const wxString& text,
974 int image, int selectedImage,
975 wxTreeItemData *data)
976{
977 return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,
978 text, image, selectedImage, data);
979}
980
981wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
982 const wxTreeItemId& idPrevious,
983 const wxString& text,
984 int image, int selectedImage,
985 wxTreeItemData *data)
986{
987 return DoInsertItem(parent, idPrevious, text, image, selectedImage, data);
988}
989
990wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
991 const wxString& text,
992 int image, int selectedImage,
993 wxTreeItemData *data)
994{
995 return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,
996 text, image, selectedImage, data);
997}
998
999void wxTreeCtrl::Delete(const wxTreeItemId& item)
1000{
1001 if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item) )
1002 {
1003 wxLogLastError("TreeView_DeleteItem");
1004 }
1005}
1006
1007// delete all children (but don't delete the item itself)
1008void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
1009{
1010 long cookie;
1011
1012 wxArrayLong children;
1013 wxTreeItemId child = GetFirstChild(item, cookie);
1014 while ( child.IsOk() )
1015 {
1016 children.Add((long)(WXHTREEITEM)child);
1017
1018 child = GetNextChild(item, cookie);
1019 }
1020
1021 size_t nCount = children.Count();
1022 for ( size_t n = 0; n < nCount; n++ )
1023 {
1024 if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)children[n]) )
1025 {
1026 wxLogLastError("TreeView_DeleteItem");
1027 }
1028 }
1029}
1030
1031void wxTreeCtrl::DeleteAllItems()
1032{
1033 if ( !TreeView_DeleteAllItems(GetHwnd()) )
1034 {
1035 wxLogLastError("TreeView_DeleteAllItems");
1036 }
1037}
1038
1039void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
1040{
1041 wxASSERT_MSG( flag == TVE_COLLAPSE ||
1042 flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
1043 flag == TVE_EXPAND ||
1044 flag == TVE_TOGGLE,
1045 wxT("Unknown flag in wxTreeCtrl::DoExpand") );
1046
1047 // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
1048 // emulate them. This behaviour has changed slightly with comctl32.dll
1049 // v 4.70 - now it does send them but only the first time. To maintain
1050 // compatible behaviour and also in order to not have surprises with the
1051 // future versions, don't rely on this and still do everything ourselves.
1052 // To avoid that the messages be sent twice when the item is expanded for
1053 // the first time we must clear TVIS_EXPANDEDONCE style manually.
1054
1055 wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDEDONCE);
1056 tvItem.state = 0;
1057 DoSetItem(&tvItem);
1058
1059 if ( TreeView_Expand(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item, flag) != 0 )
1060 {
1061 wxTreeEvent event(wxEVT_NULL, m_windowId);
1062 event.m_item = item;
1063
1064 bool isExpanded = IsExpanded(item);
1065
1066 event.SetEventObject(this);
1067
1068 // FIXME return value of {EXPAND|COLLAPS}ING event handler is discarded
1069 event.SetEventType(g_events[isExpanded][TRUE]);
1070 GetEventHandler()->ProcessEvent(event);
1071
1072 event.SetEventType(g_events[isExpanded][FALSE]);
1073 GetEventHandler()->ProcessEvent(event);
1074 }
1075 //else: change didn't took place, so do nothing at all
1076}
1077
1078void wxTreeCtrl::Expand(const wxTreeItemId& item)
1079{
1080 DoExpand(item, TVE_EXPAND);
1081}
1082
1083void wxTreeCtrl::Collapse(const wxTreeItemId& item)
1084{
1085 DoExpand(item, TVE_COLLAPSE);
1086}
1087
1088void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1089{
1090 DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);
1091}
1092
1093void wxTreeCtrl::Toggle(const wxTreeItemId& item)
1094{
1095 DoExpand(item, TVE_TOGGLE);
1096}
1097
1098void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
1099{
1100 DoExpand(item, action);
1101}
1102
1103void wxTreeCtrl::Unselect()
1104{
1105 wxASSERT_MSG( !(m_windowStyle & wxTR_MULTIPLE), wxT("doesn't make sense") );
1106
1107 // just remove the selection
1108 SelectItem(wxTreeItemId((WXHTREEITEM) 0));
1109}
1110
1111void wxTreeCtrl::UnselectAll()
1112{
1113 if ( m_windowStyle & wxTR_MULTIPLE )
1114 {
1115 wxArrayTreeItemIds selections;
1116 size_t count = GetSelections(selections);
1117 for ( size_t n = 0; n < count; n++ )
1118 {
1119 SetItemCheck(selections[n], FALSE);
1120 }
1121 }
1122 else
1123 {
1124 // just remove the selection
1125 Unselect();
1126 }
1127}
1128
1129void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
1130{
1131 if ( m_windowStyle & wxTR_MULTIPLE )
1132 {
1133 // selecting the item means checking it
1134 SetItemCheck(item);
1135 }
1136 else
1137 {
1138 // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
1139 // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
1140 // send them ourselves
1141
1142 wxTreeEvent event(wxEVT_NULL, m_windowId);
1143 event.m_item = item;
1144 event.SetEventObject(this);
1145
1146 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING);
1147 if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
1148 {
1149 if ( !TreeView_SelectItem(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item) )
1150 {
1151 wxLogLastError("TreeView_SelectItem");
1152 }
1153 else
1154 {
1155 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1156 (void)GetEventHandler()->ProcessEvent(event);
1157 }
1158 }
1159 //else: program vetoed the change
1160 }
1161}
1162
1163void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1164{
1165 // no error return
1166 TreeView_EnsureVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item);
1167}
1168
1169void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
1170{
1171 if ( !TreeView_SelectSetFirstVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item) )
1172 {
1173 wxLogLastError("TreeView_SelectSetFirstVisible");
1174 }
1175}
1176
1177wxTextCtrl* wxTreeCtrl::GetEditControl() const
1178{
1179 return m_textCtrl;
1180}
1181
1182void wxTreeCtrl::DeleteTextCtrl()
1183{
1184 if ( m_textCtrl )
1185 {
1186 m_textCtrl->UnsubclassWin();
1187 m_textCtrl->SetHWND(0);
1188 delete m_textCtrl;
1189 m_textCtrl = NULL;
1190 }
1191}
1192
1193wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
1194 wxClassInfo* textControlClass)
1195{
1196 wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
1197
1198 HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item);
1199
1200 // this is not an error - the TVN_BEGINLABELEDIT handler might have
1201 // returned FALSE
1202 if ( !hWnd )
1203 {
1204 return NULL;
1205 }
1206
1207 DeleteTextCtrl();
1208
1209 m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
1210 m_textCtrl->SetHWND((WXHWND)hWnd);
1211 m_textCtrl->SubclassWin((WXHWND)hWnd);
1212
1213 return m_textCtrl;
1214}
1215
1216// End label editing, optionally cancelling the edit
1217void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
1218{
1219 TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
1220
1221 DeleteTextCtrl();
1222}
1223
1224wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
1225{
1226 TV_HITTESTINFO hitTestInfo;
1227 hitTestInfo.pt.x = (int)point.x;
1228 hitTestInfo.pt.y = (int)point.y;
1229
1230 TreeView_HitTest(GetHwnd(), &hitTestInfo);
1231
1232 flags = 0;
1233
1234 // avoid repetition
1235 #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
1236 flags |= wxTREE_HITTEST_##flag
1237
1238 TRANSLATE_FLAG(ABOVE);
1239 TRANSLATE_FLAG(BELOW);
1240 TRANSLATE_FLAG(NOWHERE);
1241 TRANSLATE_FLAG(ONITEMBUTTON);
1242 TRANSLATE_FLAG(ONITEMICON);
1243 TRANSLATE_FLAG(ONITEMINDENT);
1244 TRANSLATE_FLAG(ONITEMLABEL);
1245 TRANSLATE_FLAG(ONITEMRIGHT);
1246 TRANSLATE_FLAG(ONITEMSTATEICON);
1247 TRANSLATE_FLAG(TOLEFT);
1248 TRANSLATE_FLAG(TORIGHT);
1249
1250 #undef TRANSLATE_FLAG
1251
1252 return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
1253}
1254
1255bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
1256 wxRect& rect,
1257 bool textOnly) const
1258{
1259 RECT rc;
1260 if ( TreeView_GetItemRect(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item,
1261 &rc, textOnly) )
1262 {
1263 rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
1264
1265 return TRUE;
1266 }
1267 else
1268 {
1269 // couldn't retrieve rect: for example, item isn't visible
1270 return FALSE;
1271 }
1272}
1273
1274// ----------------------------------------------------------------------------
1275// sorting stuff
1276// ----------------------------------------------------------------------------
1277
1278static int CALLBACK TreeView_CompareCallback(wxTreeItemData *pItem1,
1279 wxTreeItemData *pItem2,
1280 wxTreeCtrl *tree)
1281{
1282 wxCHECK_MSG( pItem1 && pItem2, 0,
1283 wxT("sorting tree without data doesn't make sense") );
1284
1285 return tree->OnCompareItems(pItem1->GetId(), pItem2->GetId());
1286}
1287
1288int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1289 const wxTreeItemId& item2)
1290{
1291 return wxStrcmp(GetItemText(item1), GetItemText(item2));
1292}
1293
1294void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
1295{
1296 // rely on the fact that TreeView_SortChildren does the same thing as our
1297 // default behaviour, i.e. sorts items alphabetically and so call it
1298 // directly if we're not in derived class (much more efficient!)
1299 if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
1300 {
1301 TreeView_SortChildren(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item, 0);
1302 }
1303 else
1304 {
1305 TV_SORTCB tvSort;
1306 tvSort.hParent = (HTREEITEM)(WXHTREEITEM)item;
1307 tvSort.lpfnCompare = (PFNTVCOMPARE)TreeView_CompareCallback;
1308 tvSort.lParam = (LPARAM)this;
1309 TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
1310 }
1311}
1312
1313// ----------------------------------------------------------------------------
1314// implementation
1315// ----------------------------------------------------------------------------
1316
1317bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
1318{
1319 if ( cmd == EN_UPDATE )
1320 {
1321 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1322 event.SetEventObject( this );
1323 ProcessCommand(event);
1324 }
1325 else if ( cmd == EN_KILLFOCUS )
1326 {
1327 wxCommandEvent event(wxEVT_KILL_FOCUS, id);
1328 event.SetEventObject( this );
1329 ProcessCommand(event);
1330 }
1331 else
1332 {
1333 // nothing done
1334 return FALSE;
1335 }
1336
1337 // command processed
1338 return TRUE;
1339}
1340
1341// process WM_NOTIFY Windows message
1342bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
1343{
1344 wxTreeEvent event(wxEVT_NULL, m_windowId);
1345 wxEventType eventType = wxEVT_NULL;
1346 NMHDR *hdr = (NMHDR *)lParam;
1347
1348 switch ( hdr->code )
1349 {
1350 case NM_RCLICK:
1351 {
1352 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
1353 return TRUE;
1354
1355 TV_HITTESTINFO tvhti;
1356 ::GetCursorPos(&(tvhti.pt));
1357 ::ScreenToClient(GetHwnd(),&(tvhti.pt));
1358 if ( TreeView_HitTest(GetHwnd(),&tvhti) )
1359 {
1360 if( tvhti.flags & TVHT_ONITEM )
1361 {
1362 event.m_item = (WXHTREEITEM) tvhti.hItem;
1363 eventType=wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
1364 }
1365 }
1366 break;
1367 }
1368
1369 case TVN_BEGINDRAG:
1370 eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
1371 // fall through
1372
1373 case TVN_BEGINRDRAG:
1374 {
1375 if ( eventType == wxEVT_NULL )
1376 eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
1377 //else: left drag, already set above
1378
1379 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
1380
1381 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
1382 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
1383 break;
1384 }
1385
1386 case TVN_BEGINLABELEDIT:
1387 {
1388 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
1389 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
1390
1391 event.m_item = (WXHTREEITEM) info->item.hItem;
1392 event.m_label = info->item.pszText;
1393 break;
1394 }
1395
1396 case TVN_DELETEITEM:
1397 {
1398 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
1399 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
1400
1401 event.m_item = (WXHTREEITEM) tv->itemOld.hItem;
1402 break;
1403 }
1404
1405 case TVN_ENDLABELEDIT:
1406 {
1407 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
1408 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
1409
1410 event.m_item = (WXHTREEITEM)info->item.hItem;
1411 event.m_label = info->item.pszText;
1412 if (info->item.pszText == NULL)
1413 return FALSE;
1414 break;
1415 }
1416
1417 case TVN_GETDISPINFO:
1418 eventType = wxEVT_COMMAND_TREE_GET_INFO;
1419 // fall through
1420
1421 case TVN_SETDISPINFO:
1422 {
1423 if ( eventType == wxEVT_NULL )
1424 eventType = wxEVT_COMMAND_TREE_SET_INFO;
1425 //else: get, already set above
1426
1427 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
1428
1429 event.m_item = (WXHTREEITEM) info->item.hItem;
1430 break;
1431 }
1432
1433 case TVN_ITEMEXPANDING:
1434 event.m_code = FALSE;
1435 // fall through
1436
1437 case TVN_ITEMEXPANDED:
1438 {
1439 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
1440
1441 bool expand = FALSE;
1442 switch ( tv->action )
1443 {
1444 case TVE_EXPAND:
1445 expand = TRUE;
1446 break;
1447
1448 case TVE_COLLAPSE:
1449 expand = FALSE;
1450 break;
1451
1452 default:
1453 wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND "
1454 "message"), tv->action);
1455 }
1456
1457 bool ing = ((int)hdr->code == TVN_ITEMEXPANDING);
1458 eventType = g_events[expand][ing];
1459
1460 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
1461 break;
1462 }
1463
1464 case TVN_KEYDOWN:
1465 {
1466 eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
1467 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
1468
1469 event.m_code = wxCharCodeMSWToWX(info->wVKey);
1470
1471 // a separate event for this case
1472 if ( info->wVKey == VK_SPACE || info->wVKey == VK_RETURN )
1473 {
1474 wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
1475 m_windowId);
1476 event2.SetEventObject(this);
1477
1478 GetEventHandler()->ProcessEvent(event2);
1479 }
1480 break;
1481 }
1482
1483 case TVN_SELCHANGED:
1484 eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
1485 // fall through
1486
1487 case TVN_SELCHANGING:
1488 {
1489 if ( eventType == wxEVT_NULL )
1490 eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
1491 //else: already set above
1492
1493 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
1494
1495 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
1496 event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
1497 break;
1498 }
1499
1500 default:
1501 return wxControl::MSWOnNotify(idCtrl, lParam, result);
1502 }
1503
1504 event.SetEventObject(this);
1505 event.SetEventType(eventType);
1506
1507 bool processed = GetEventHandler()->ProcessEvent(event);
1508
1509 // post processing
1510 switch ( hdr->code )
1511 {
1512 case TVN_DELETEITEM:
1513 {
1514 // NB: we might process this message using wxWindows event
1515 // tables, but due to overhead of wxWin event system we
1516 // prefer to do it here ourself (otherwise deleting a tree
1517 // with many items is just too slow)
1518 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
1519
1520 wxTreeItemId item = event.m_item;
1521 if ( HasIndirectData(item) )
1522 {
1523 wxTreeItemIndirectData *data = (wxTreeItemIndirectData *)
1524 tv->itemOld.lParam;
1525 delete data; // can't be NULL here
1526
1527 m_itemsWithIndirectData.Remove(item);
1528 }
1529 else
1530 {
1531 wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
1532 delete data; // may be NULL, ok
1533 }
1534
1535 processed = TRUE; // Make sure we don't get called twice
1536 }
1537 break;
1538
1539 case TVN_BEGINLABELEDIT:
1540 // return TRUE to cancel label editing
1541 *result = !event.IsAllowed();
1542 break;
1543
1544 case TVN_ENDLABELEDIT:
1545 // return TRUE to set the label to the new string
1546 *result = event.IsAllowed();
1547
1548 // ensure that we don't have the text ctrl which is going to be
1549 // deleted any more
1550 DeleteTextCtrl();
1551 break;
1552
1553 case TVN_SELCHANGING:
1554 case TVN_ITEMEXPANDING:
1555 // return TRUE to prevent the action from happening
1556 *result = !event.IsAllowed();
1557 break;
1558
1559 case TVN_GETDISPINFO:
1560 // NB: so far the user can't set the image himself anyhow, so do it
1561 // anyway - but this may change later
1562 if ( /* !processed && */ 1 )
1563 {
1564 wxTreeItemId item = event.m_item;
1565 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
1566 if ( info->item.mask & TVIF_IMAGE )
1567 {
1568 info->item.iImage =
1569 DoGetItemImageFromData
1570 (
1571 item,
1572 IsExpanded(item) ? wxTreeItemIcon_Expanded
1573 : wxTreeItemIcon_Normal
1574 );
1575 }
1576 if ( info->item.mask & TVIF_SELECTEDIMAGE )
1577 {
1578 info->item.iSelectedImage =
1579 DoGetItemImageFromData
1580 (
1581 item,
1582 IsExpanded(item) ? wxTreeItemIcon_SelectedExpanded
1583 : wxTreeItemIcon_Selected
1584 );
1585 }
1586 }
1587 break;
1588
1589 //default:
1590 // for the other messages the return value is ignored and there is
1591 // nothing special to do
1592 }
1593
1594 return processed;
1595}
1596
1597// ----------------------------------------------------------------------------
1598// Tree event
1599// ----------------------------------------------------------------------------
1600
1601IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
1602
1603wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)
1604 : wxNotifyEvent(commandType, id)
1605{
1606 m_code = 0;
1607 m_itemOld = 0;
1608}
1609
1610#endif // __WIN95__
1611