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