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