src/msw/treectrl.cpp

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