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