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(__TWIN32__)) && !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 ( !CreateControl(parent, id, pos, size, style, validator, name) )
 605         return false;
 606
 607     DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
 608                    TVS_SHOWSELALWAYS;
 609
 610     if ( m_windowStyle & wxCLIP_SIBLINGS )
 611         wstyle |= WS_CLIPSIBLINGS;
 612
 613     if ((m_windowStyle & wxTR_NO_LINES) == 0)
 614         wstyle |= TVS_HASLINES;
 615     if ( m_windowStyle & wxTR_HAS_BUTTONS )
 616         wstyle |= TVS_HASBUTTONS;
 617
 618     if ( m_windowStyle & wxTR_EDIT_LABELS )
 619         wstyle |= TVS_EDITLABELS;
 620
 621     if ( m_windowStyle & wxTR_LINES_AT_ROOT )
 622         wstyle |= TVS_LINESATROOT;
 623
 624     if ( m_windowStyle & wxTR_FULL_ROW_HIGHLIGHT )
 625     {
 626         if ( wxTheApp->GetComCtl32Version() >= 471 )
 627             wstyle |= TVS_FULLROWSELECT;
 628     }
 629
 630     // using TVS_CHECKBOXES for emulation of a multiselection tree control
 631     // doesn't work without the new enough headers
 632 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE && \
 633     !defined( __GNUWIN32_OLD__ ) && \
 634     !defined( __BORLANDC__ ) && \
 635     !defined( __WATCOMC__ ) && \
 636     (!defined(__VISUALC__) || (__VISUALC__ > 1010))
 637
 638     // we emulate the multiple selection tree controls by using checkboxes: set
 639     // up the image list we need for this if we do have multiple selections
 640     if ( m_windowStyle & wxTR_MULTIPLE )
 641         wstyle |= TVS_CHECKBOXES;
 642 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
 643
 644     // Create the tree control.
 645     if ( !MSWCreateControl(WC_TREEVIEW, wstyle) )
 646         return false;
 647
 648 #if wxUSE_COMCTL32_SAFELY
 649     wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 650     wxWindow::SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 651 #elif 1
 652     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 653     SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 654 #else
 655     // This works around a bug in the Windows tree control whereby for some versions
 656     // of comctrl32, setting any colour actually draws the background in black.
 657     // This will initialise the background to the system colour.
 658     // THIS FIX NOW REVERTED since it caused problems on _other_ systems.
 659     // Assume the user has an updated comctl32.dll.
 660     ::SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0,-1);
 661     wxWindow::SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
 662     SetForegroundColour(wxWindow::GetParent()->GetForegroundColour());
 663 #endif
 664
 665
 666     // VZ: this is some experimental code which may be used to get the
 667     //     TVS_CHECKBOXES style functionality for comctl32.dll < 4.71.
 668     //     AFAIK, the standard DLL does about the same thing anyhow.
 669 #if 0
 670     if ( m_windowStyle & wxTR_MULTIPLE )
 671     {
 672         wxBitmap bmp;
 673
 674         // create the DC compatible with the current screen
 675         HDC hdcMem = CreateCompatibleDC(NULL);
 676
 677         // create a mono bitmap of the standard size
 678         int x = GetSystemMetrics(SM_CXMENUCHECK);
 679         int y = GetSystemMetrics(SM_CYMENUCHECK);
 680         wxImageList imagelistCheckboxes(x, y, false, 2);
 681         HBITMAP hbmpCheck = CreateBitmap(x, y,   // bitmap size
 682                                          1,      // # of color planes
 683                                          1,      // # bits needed for one pixel
 684                                          0);     // array containing colour data
 685         SelectObject(hdcMem, hbmpCheck);
 686
 687         // then draw a check mark into it
 688         RECT rect = { 0, 0, x, y };
 689         if ( !::DrawFrameControl(hdcMem, &rect,
 690                                  DFC_BUTTON,
 691                                  DFCS_BUTTONCHECK | DFCS_CHECKED) )
 692         {
 693             wxLogLastError(wxT("DrawFrameControl(check)"));
 694         }
 695
 696         bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
 697         imagelistCheckboxes.Add(bmp);
 698
 699         if ( !::DrawFrameControl(hdcMem, &rect,
 700                                  DFC_BUTTON,
 701                                  DFCS_BUTTONCHECK) )
 702         {
 703             wxLogLastError(wxT("DrawFrameControl(uncheck)"));
 704         }
 705
 706         bmp.SetHBITMAP((WXHBITMAP)hbmpCheck);
 707         imagelistCheckboxes.Add(bmp);
 708
 709         // clean up
 710         ::DeleteDC(hdcMem);
 711
 712         // set the imagelist
 713         SetStateImageList(&imagelistCheckboxes);
 714     }
 715 #endif // 0
 716
 717     SetSize(pos.x, pos.y, size.x, size.y);
 718
 719     return true;
 720 }
 721
 722 wxTreeCtrl::~wxTreeCtrl()
 723 {
 724     // delete any attributes
 725     if ( m_hasAnyAttr )
 726     {
 727         for ( wxNode *node = m_attrs.Next(); node; node = m_attrs.Next() )
 728         {
 729             delete (wxTreeItemAttr *)node->GetData();
 730         }
 731
 732         // prevent TVN_DELETEITEM handler from deleting the attributes again!
 733         m_hasAnyAttr = false;
 734     }
 735
 736     DeleteTextCtrl();
 737
 738     // delete user data to prevent memory leaks
 739     // also deletes hidden root node storage.
 740     DeleteAllItems();
 741
 742     if (m_ownsImageListNormal) delete m_imageListNormal;
 743     if (m_ownsImageListState) delete m_imageListState;
 744 }
 745
 746 // ----------------------------------------------------------------------------
 747 // accessors
 748 // ----------------------------------------------------------------------------
 749
 750 // simple wrappers which add error checking in debug mode
 751
 752 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 753 {
 754     wxCHECK_MSG( tvItem->hItem != TVI_ROOT, false,
 755                  _T("can't retrieve virtual root item") );
 756
 757     if ( !TreeView_GetItem(GetHwnd(), tvItem) )
 758     {
 759         wxLogLastError(wxT("TreeView_GetItem"));
 760
 761         return false;
 762     }
 763
 764     return true;
 765 }
 766
 767 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 768 {
 769     if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
 770     {
 771         wxLogLastError(wxT("TreeView_SetItem"));
 772     }
 773 }
 774
 775 size_t wxTreeCtrl::GetCount() const
 776 {
 777     return (size_t)TreeView_GetCount(GetHwnd());
 778 }
 779
 780 unsigned int wxTreeCtrl::GetIndent() const
 781 {
 782     return TreeView_GetIndent(GetHwnd());
 783 }
 784
 785 void wxTreeCtrl::SetIndent(unsigned int indent)
 786 {
 787     TreeView_SetIndent(GetHwnd(), indent);
 788 }
 789
 790 wxImageList *wxTreeCtrl::GetImageList() const
 791 {
 792     return m_imageListNormal;
 793 }
 794
 795 wxImageList *wxTreeCtrl::GetStateImageList() const
 796 {
 797     return m_imageListNormal;
 798 }
 799
 800 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 801 {
 802     // no error return
 803     TreeView_SetImageList(GetHwnd(),
 804                           imageList ? imageList->GetHIMAGELIST() : 0,
 805                           which);
 806 }
 807
 808 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 809 {
 810     if (m_ownsImageListNormal)
 811         delete m_imageListNormal;
 812
 813     SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
 814     m_ownsImageListNormal = false;
 815 }
 816
 817 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
 818 {
 819     if (m_ownsImageListState) delete m_imageListState;
 820     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
 821     m_ownsImageListState = false;
 822 }
 823
 824 void wxTreeCtrl::AssignImageList(wxImageList *imageList)
 825 {
 826     SetImageList(imageList);
 827     m_ownsImageListNormal = true;
 828 }
 829
 830 void wxTreeCtrl::AssignStateImageList(wxImageList *imageList)
 831 {
 832     SetStateImageList(imageList);
 833     m_ownsImageListState = true;
 834 }
 835
 836 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item,
 837                                     bool recursively) const
 838 {
 839     TraverseCounter counter(this, item, recursively);
 840
 841     return counter.GetCount() - 1;
 842 }
 843
 844 // ----------------------------------------------------------------------------
 845 // control colours
 846 // ----------------------------------------------------------------------------
 847
 848 bool wxTreeCtrl::SetBackgroundColour(const wxColour &colour)
 849 {
 850 #if !wxUSE_COMCTL32_SAFELY
 851     if ( !wxWindowBase::SetBackgroundColour(colour) )
 852         return false;
 853
 854     SendMessage(GetHwnd(), TVM_SETBKCOLOR, 0, colour.GetPixel());
 855 #endif
 856
 857     return true;
 858 }
 859
 860 bool wxTreeCtrl::SetForegroundColour(const wxColour &colour)
 861 {
 862 #if !wxUSE_COMCTL32_SAFELY
 863     if ( !wxWindowBase::SetForegroundColour(colour) )
 864         return false;
 865
 866     SendMessage(GetHwnd(), TVM_SETTEXTCOLOR, 0, colour.GetPixel());
 867 #endif
 868
 869     return true;
 870 }
 871
 872 // ----------------------------------------------------------------------------
 873 // Item access
 874 // ----------------------------------------------------------------------------
 875
 876 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
 877 {
 878     wxChar buf[512];  // the size is arbitrary...
 879
 880     wxTreeViewItem tvItem(item, TVIF_TEXT);
 881     tvItem.pszText = buf;
 882     tvItem.cchTextMax = WXSIZEOF(buf);
 883     if ( !DoGetItem(&tvItem) )
 884     {
 885         // don't return some garbage which was on stack, but an empty string
 886         buf[0] = wxT('\0');
 887     }
 888
 889     return wxString(buf);
 890 }
 891
 892 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 893 {
 894     if ( IS_VIRTUAL_ROOT(item) )
 895         return;
 896
 897     wxTreeViewItem tvItem(item, TVIF_TEXT);
 898     tvItem.pszText = (wxChar *)text.c_str();  // conversion is ok
 899     DoSetItem(&tvItem);
 900
 901     // when setting the text of the item being edited, the text control should
 902     // be updated to reflect the new text as well, otherwise calling
 903     // SetItemText() in the OnBeginLabelEdit() handler doesn't have any effect
 904     //
 905     // don't use GetEditControl() here because m_textCtrl is not set yet
 906     HWND hwndEdit = TreeView_GetEditControl(GetHwnd());
 907     if ( hwndEdit )
 908     {
 909         if ( item == GetSelection() )
 910         {
 911             ::SetWindowText(hwndEdit, text);
 912         }
 913     }
 914 }
 915
 916 int wxTreeCtrl::DoGetItemImageFromData(const wxTreeItemId& item,
 917                                        wxTreeItemIcon which) const
 918 {
 919     wxTreeViewItem tvItem(item, TVIF_PARAM);
 920     if ( !DoGetItem(&tvItem) )
 921     {
 922         return -1;
 923     }
 924
 925     return ((wxTreeItemIndirectData *)tvItem.lParam)->GetImage(which);
 926 }
 927
 928 void wxTreeCtrl::DoSetItemImageFromData(const wxTreeItemId& item,
 929                                         int image,
 930                                         wxTreeItemIcon which) const
 931 {
 932     wxTreeViewItem tvItem(item, TVIF_PARAM);
 933     if ( !DoGetItem(&tvItem) )
 934     {
 935         return;
 936     }
 937
 938     wxTreeItemIndirectData *data = ((wxTreeItemIndirectData *)tvItem.lParam);
 939
 940     data->SetImage(image, which);
 941
 942     // make sure that we have selected images as well
 943     if ( which == wxTreeItemIcon_Normal &&
 944          !data->HasImage(wxTreeItemIcon_Selected) )
 945     {
 946         data->SetImage(image, wxTreeItemIcon_Selected);
 947     }
 948
 949     if ( which == wxTreeItemIcon_Expanded &&
 950          !data->HasImage(wxTreeItemIcon_SelectedExpanded) )
 951     {
 952         data->SetImage(image, wxTreeItemIcon_SelectedExpanded);
 953     }
 954 }
 955
 956 void wxTreeCtrl::DoSetItemImages(const wxTreeItemId& item,
 957                                  int image,
 958                                  int imageSel)
 959 {
 960     wxTreeViewItem tvItem(item, TVIF_IMAGE | TVIF_SELECTEDIMAGE);
 961     tvItem.iSelectedImage = imageSel;
 962     tvItem.iImage = image;
 963     DoSetItem(&tvItem);
 964 }
 965
 966 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item,
 967                              wxTreeItemIcon which) const
 968 {
 969     if ( (HITEM(item) == TVI_ROOT) && (m_windowStyle & wxTR_HIDE_ROOT) )
 970     {
 971         // TODO: Maybe a hidden root can still provide images?
 972         return -1;
 973     }
 974
 975     if ( HasIndirectData(item) )
 976     {
 977         return DoGetItemImageFromData(item, which);
 978     }
 979
 980     UINT mask;
 981     switch ( which )
 982     {
 983         default:
 984             wxFAIL_MSG( wxT("unknown tree item image type") );
 985
 986         case wxTreeItemIcon_Normal:
 987             mask = TVIF_IMAGE;
 988             break;
 989
 990         case wxTreeItemIcon_Selected:
 991             mask = TVIF_SELECTEDIMAGE;
 992             break;
 993
 994         case wxTreeItemIcon_Expanded:
 995         case wxTreeItemIcon_SelectedExpanded:
 996             return -1;
 997     }
 998
 999     wxTreeViewItem tvItem(item, mask);
1000     DoGetItem(&tvItem);
1001
1002     return mask == TVIF_IMAGE ? tvItem.iImage : tvItem.iSelectedImage;
1003 }
1004
1005 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image,
1006                               wxTreeItemIcon which)
1007 {
1008     if ( IS_VIRTUAL_ROOT(item) )
1009     {
1010         // TODO: Maybe a hidden root can still store images?
1011         return;
1012     }
1013
1014     int imageNormal, imageSel;
1015     switch ( which )
1016     {
1017         default:
1018             wxFAIL_MSG( wxT("unknown tree item image type") );
1019
1020         case wxTreeItemIcon_Normal:
1021             imageNormal = image;
1022             imageSel = GetItemSelectedImage(item);
1023             break;
1024
1025         case wxTreeItemIcon_Selected:
1026             imageNormal = GetItemImage(item);
1027             imageSel = image;
1028             break;
1029
1030         case wxTreeItemIcon_Expanded:
1031         case wxTreeItemIcon_SelectedExpanded:
1032             if ( !HasIndirectData(item) )
1033             {
1034                 // we need to get the old images first, because after we create
1035                 // the wxTreeItemIndirectData GetItemXXXImage() will use it to
1036                 // get the images
1037                 imageNormal = GetItemImage(item);
1038                 imageSel = GetItemSelectedImage(item);
1039
1040                 // if it doesn't have it yet, add it
1041                 wxTreeItemIndirectData *data = new
1042                     wxTreeItemIndirectData(this, item);
1043
1044                 // copy the data to the new location
1045                 data->SetImage(imageNormal, wxTreeItemIcon_Normal);
1046                 data->SetImage(imageSel, wxTreeItemIcon_Selected);
1047             }
1048
1049             DoSetItemImageFromData(item, image, which);
1050
1051             // reset the normal/selected images because we won't use them any
1052             // more - now they're stored inside the indirect data
1053             imageNormal =
1054             imageSel = I_IMAGECALLBACK;
1055             break;
1056     }
1057
1058     // NB: at least in version 5.00.0518.9 of comctl32.dll we need to always
1059     //     change both normal and selected image - otherwise the change simply
1060     //     doesn't take place!
1061     DoSetItemImages(item, imageNormal, imageSel);
1062 }
1063
1064 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
1065 {
1066     wxTreeViewItem tvItem(item, TVIF_PARAM);
1067
1068     // Hidden root may have data.
1069     if ( IS_VIRTUAL_ROOT(item) )
1070     {
1071         return GET_VIRTUAL_ROOT()->GetData();
1072     }
1073
1074     // Visible node.
1075     if ( !DoGetItem(&tvItem) )
1076     {
1077         return NULL;
1078     }
1079
1080     wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
1081     if ( IsDataIndirect(data) )
1082     {
1083         data = ((wxTreeItemIndirectData *)data)->GetData();
1084     }
1085
1086     return data;
1087 }
1088
1089 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
1090 {
1091     if ( IS_VIRTUAL_ROOT(item) )
1092     {
1093         GET_VIRTUAL_ROOT()->SetData(data);
1094     }
1095
1096     // first, associate this piece of data with this item
1097     if ( data )
1098     {
1099         data->SetId(item);
1100     }
1101
1102     wxTreeViewItem tvItem(item, TVIF_PARAM);
1103
1104     if ( HasIndirectData(item) )
1105     {
1106         if ( DoGetItem(&tvItem) )
1107         {
1108             ((wxTreeItemIndirectData *)tvItem.lParam)->SetData(data);
1109         }
1110         else
1111         {
1112             wxFAIL_MSG( wxT("failed to change tree items data") );
1113         }
1114     }
1115     else
1116     {
1117         tvItem.lParam = (LPARAM)data;
1118         DoSetItem(&tvItem);
1119     }
1120 }
1121
1122 void wxTreeCtrl::SetIndirectItemData(const wxTreeItemId& item,
1123                                      wxTreeItemIndirectData *data)
1124 {
1125     // this should never happen because it's unnecessary and will probably lead
1126     // to crash too because the code elsewhere supposes that the pointer the
1127     // wxTreeItemIndirectData has is a real wxItemData and not
1128     // wxTreeItemIndirectData as well
1129     wxASSERT_MSG( !HasIndirectData(item), wxT("setting indirect data twice?") );
1130
1131     SetItemData(item, data);
1132 }
1133
1134 bool wxTreeCtrl::HasIndirectData(const wxTreeItemId& item) const
1135 {
1136     // query the item itself
1137     wxTreeViewItem tvItem(item, TVIF_PARAM);
1138     if ( !DoGetItem(&tvItem) )
1139     {
1140         return false;
1141     }
1142
1143     wxTreeItemData *data = (wxTreeItemData *)tvItem.lParam;
1144
1145     return data && IsDataIndirect(data);
1146 }
1147
1148 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
1149 {
1150     if ( IS_VIRTUAL_ROOT(item) )
1151         return;
1152
1153     wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1154     tvItem.cChildren = (int)has;
1155     DoSetItem(&tvItem);
1156 }
1157
1158 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
1159 {
1160     if ( IS_VIRTUAL_ROOT(item) )
1161         return;
1162
1163     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1164     tvItem.state = bold ? TVIS_BOLD : 0;
1165     DoSetItem(&tvItem);
1166 }
1167
1168 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
1169 {
1170     if ( IS_VIRTUAL_ROOT(item) )
1171         return;
1172
1173     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
1174     tvItem.state = highlight ? TVIS_DROPHILITED : 0;
1175     DoSetItem(&tvItem);
1176 }
1177
1178 void wxTreeCtrl::RefreshItem(const wxTreeItemId& item)
1179 {
1180     if ( IS_VIRTUAL_ROOT(item) )
1181         return;
1182
1183     wxRect rect;
1184     if ( GetBoundingRect(item, rect) )
1185     {
1186         RefreshRect(rect);
1187     }
1188 }
1189
1190 wxColour wxTreeCtrl::GetItemTextColour(const wxTreeItemId& item) const
1191 {
1192     long id = (long)(WXHTREEITEM)item;
1193     wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1194     if ( !attr )
1195     {
1196         return wxNullColour;
1197     }
1198
1199     return attr->GetTextColour();
1200 }
1201
1202 wxColour wxTreeCtrl::GetItemBackgroundColour(const wxTreeItemId& item) const
1203 {
1204     long id = (long)(WXHTREEITEM)item;
1205     wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1206     if ( !attr )
1207     {
1208         return wxNullColour;
1209     }
1210
1211     return attr->GetBackgroundColour();
1212 }
1213
1214 wxFont wxTreeCtrl::GetItemFont(const wxTreeItemId& item) const
1215 {
1216     long id = (long)(WXHTREEITEM)item;
1217     wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1218     if ( !attr )
1219     {
1220         return wxNullFont;
1221     }
1222
1223     return attr->GetFont();
1224 }
1225
1226 void wxTreeCtrl::SetItemTextColour(const wxTreeItemId& item,
1227                                    const wxColour& col)
1228 {
1229     m_hasAnyAttr = true;
1230
1231     long id = (long)(WXHTREEITEM)item;
1232     wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1233     if ( !attr )
1234     {
1235         attr = new wxTreeItemAttr;
1236         m_attrs.Put(id, (wxObject *)attr);
1237     }
1238
1239     attr->SetTextColour(col);
1240
1241     RefreshItem(item);
1242 }
1243
1244 void wxTreeCtrl::SetItemBackgroundColour(const wxTreeItemId& item,
1245                                          const wxColour& col)
1246 {
1247     m_hasAnyAttr = true;
1248
1249     long id = (long)(WXHTREEITEM)item;
1250     wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1251     if ( !attr )
1252     {
1253         attr = new wxTreeItemAttr;
1254         m_attrs.Put(id, (wxObject *)attr);
1255     }
1256
1257     attr->SetBackgroundColour(col);
1258
1259     RefreshItem(item);
1260 }
1261
1262 void wxTreeCtrl::SetItemFont(const wxTreeItemId& item, const wxFont& font)
1263 {
1264     m_hasAnyAttr = true;
1265
1266     long id = (long)(WXHTREEITEM)item;
1267     wxTreeItemAttr *attr = (wxTreeItemAttr *)m_attrs.Get(id);
1268     if ( !attr )
1269     {
1270         attr = new wxTreeItemAttr;
1271         m_attrs.Put(id, (wxObject *)attr);
1272     }
1273
1274     attr->SetFont(font);
1275
1276     RefreshItem(item);
1277 }
1278
1279 // ----------------------------------------------------------------------------
1280 // Item status
1281 // ----------------------------------------------------------------------------
1282
1283 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
1284 {
1285     if ( item == wxTreeItemId(TVI_ROOT) )
1286     {
1287         // virtual (hidden) root is never visible
1288         return false;
1289     }
1290
1291     // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
1292     RECT rect;
1293
1294     // this ugliness comes directly from MSDN - it *is* the correct way to pass
1295     // the HTREEITEM with TVM_GETITEMRECT
1296     *(WXHTREEITEM *)&rect = (WXHTREEITEM)item;
1297
1298     // false means get item rect for the whole item, not only text
1299     return SendMessage(GetHwnd(), TVM_GETITEMRECT, false, (LPARAM)&rect) != 0;
1300 }
1301
1302 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
1303 {
1304     wxTreeViewItem tvItem(item, TVIF_CHILDREN);
1305     DoGetItem(&tvItem);
1306
1307     return tvItem.cChildren != 0;
1308 }
1309
1310 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
1311 {
1312     // probably not a good idea to put it here
1313     //wxASSERT( ItemHasChildren(item) );
1314
1315     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
1316     DoGetItem(&tvItem);
1317
1318     return (tvItem.state & TVIS_EXPANDED) != 0;
1319 }
1320
1321 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
1322 {
1323     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
1324     DoGetItem(&tvItem);
1325
1326     return (tvItem.state & TVIS_SELECTED) != 0;
1327 }
1328
1329 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
1330 {
1331     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
1332     DoGetItem(&tvItem);
1333
1334     return (tvItem.state & TVIS_BOLD) != 0;
1335 }
1336
1337 // ----------------------------------------------------------------------------
1338 // navigation
1339 // ----------------------------------------------------------------------------
1340
1341 wxTreeItemId wxTreeCtrl::GetRootItem() const
1342 {
1343     // Root may be real (visible) or virtual (hidden).
1344     if ( GET_VIRTUAL_ROOT() )
1345         return TVI_ROOT;
1346
1347     return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(GetHwnd()));
1348 }
1349
1350 wxTreeItemId wxTreeCtrl::GetSelection() const
1351 {
1352     wxCHECK_MSG( !(m_windowStyle & wxTR_MULTIPLE), (long)(WXHTREEITEM)0,
1353                  wxT("this only works with single selection controls") );
1354
1355     return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(GetHwnd()));
1356 }
1357
1358 wxTreeItemId wxTreeCtrl::GetItemParent(const wxTreeItemId& item) const
1359 {
1360     HTREEITEM hItem;
1361
1362     if ( IS_VIRTUAL_ROOT(item) )
1363     {
1364         // no parent for the virtual root
1365         hItem = 0;
1366     }
1367     else // normal item
1368     {
1369         hItem = TreeView_GetParent(GetHwnd(), HITEM(item));
1370         if ( !hItem && HasFlag(wxTR_HIDE_ROOT) )
1371         {
1372             // the top level items should have the virtual root as their parent
1373             hItem = TVI_ROOT;
1374         }
1375     }
1376
1377     return wxTreeItemId((WXHTREEITEM)hItem);
1378 }
1379
1380 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
1381                                        long& _cookie) const
1382 {
1383     // remember the last child returned in 'cookie'
1384     _cookie = (long)TreeView_GetChild(GetHwnd(), HITEM(item));
1385
1386     return wxTreeItemId((WXHTREEITEM)_cookie);
1387 }
1388
1389 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
1390                                       long& _cookie) const
1391 {
1392     wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(GetHwnd(),
1393                                    HITEM(_cookie)));
1394     _cookie = (long)l;
1395
1396     return l;
1397 }
1398
1399 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
1400 {
1401     // can this be done more efficiently?
1402     long cookie;
1403
1404     wxTreeItemId childLast,
1405     child = GetFirstChild(item, cookie);
1406     while ( child.IsOk() )
1407     {
1408         childLast = child;
1409         child = GetNextChild(item, cookie);
1410     }
1411
1412     return childLast;
1413 }
1414
1415 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
1416 {
1417     return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(GetHwnd(), HITEM(item)));
1418 }
1419
1420 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
1421 {
1422     return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(GetHwnd(), HITEM(item)));
1423 }
1424
1425 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
1426 {
1427     return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(GetHwnd()));
1428 }
1429
1430 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
1431 {
1432     wxASSERT_MSG( IsVisible(item), wxT("The item you call GetNextVisible() for must be visible itself!"));
1433
1434     return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(GetHwnd(), HITEM(item)));
1435 }
1436
1437 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
1438 {
1439     wxASSERT_MSG( IsVisible(item), wxT("The item you call GetPrevVisible() for must be visible itself!"));
1440
1441     return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(GetHwnd(), HITEM(item)));
1442 }
1443
1444 // ----------------------------------------------------------------------------
1445 // multiple selections emulation
1446 // ----------------------------------------------------------------------------
1447
1448 bool wxTreeCtrl::IsItemChecked(const wxTreeItemId& item) const
1449 {
1450     // receive the desired information.
1451     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
1452     DoGetItem(&tvItem);
1453
1454     // state image indices are 1 based
1455     return ((tvItem.state >> 12) - 1) == 1;
1456 }
1457
1458 void wxTreeCtrl::SetItemCheck(const wxTreeItemId& item, bool check)
1459 {
1460     // receive the desired information.
1461     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_STATEIMAGEMASK);
1462
1463     DoGetItem(&tvItem);
1464
1465     // state images are one-based
1466     tvItem.state = (check ? 2 : 1) << 12;
1467
1468     DoSetItem(&tvItem);
1469 }
1470
1471 size_t wxTreeCtrl::GetSelections(wxArrayTreeItemIds& selections) const
1472 {
1473     TraverseSelections selector(this, selections);
1474
1475     return selector.GetCount();
1476 }
1477
1478 // ----------------------------------------------------------------------------
1479 // Usual operations
1480 // ----------------------------------------------------------------------------
1481
1482 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
1483                                       wxTreeItemId hInsertAfter,
1484                                       const wxString& text,
1485                                       int image, int selectedImage,
1486                                       wxTreeItemData *data)
1487 {
1488     wxCHECK_MSG( parent.IsOk() || !TreeView_GetRoot(GetHwnd()),
1489                  wxTreeItemId(),
1490                  _T("can't have more than one root in the tree") );
1491
1492     TV_INSERTSTRUCT tvIns;
1493     tvIns.hParent = HITEM(parent);
1494     tvIns.hInsertAfter = HITEM(hInsertAfter);
1495
1496     // this is how we insert the item as the first child: supply a NULL
1497     // hInsertAfter
1498     if ( !tvIns.hInsertAfter )
1499     {
1500         tvIns.hInsertAfter = TVI_FIRST;
1501     }
1502
1503     UINT mask = 0;
1504     if ( !text.IsEmpty() )
1505     {
1506         mask |= TVIF_TEXT;
1507         tvIns.item.pszText = (wxChar *)text.c_str();  // cast is ok
1508     }
1509     else
1510     {
1511         tvIns.item.pszText = NULL;
1512         tvIns.item.cchTextMax = 0;
1513     }
1514
1515     if ( image != -1 )
1516     {
1517         mask |= TVIF_IMAGE;
1518         tvIns.item.iImage = image;
1519
1520         if ( selectedImage == -1 )
1521         {
1522             // take the same image for selected icon if not specified
1523             selectedImage = image;
1524         }
1525     }
1526
1527     if ( selectedImage != -1 )
1528     {
1529         mask |= TVIF_SELECTEDIMAGE;
1530         tvIns.item.iSelectedImage = selectedImage;
1531     }
1532
1533     if ( data != NULL )
1534     {
1535         mask |= TVIF_PARAM;
1536         tvIns.item.lParam = (LPARAM)data;
1537     }
1538
1539     tvIns.item.mask = mask;
1540
1541     HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
1542     if ( id == 0 )
1543     {
1544         wxLogLastError(wxT("TreeView_InsertItem"));
1545     }
1546
1547     if ( data != NULL )
1548     {
1549         // associate the application tree item with Win32 tree item handle
1550         data->SetId((WXHTREEITEM)id);
1551     }
1552
1553     return wxTreeItemId((WXHTREEITEM)id);
1554 }
1555
1556 // for compatibility only
1557 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1558                                     const wxString& text,
1559                                     int image, int selImage,
1560                                     long insertAfter)
1561 {
1562     return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
1563                         image, selImage, NULL);
1564 }
1565
1566 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
1567                                  int image, int selectedImage,
1568                                  wxTreeItemData *data)
1569 {
1570
1571     if ( m_windowStyle & wxTR_HIDE_ROOT )
1572     {
1573         // create a virtual root item, the parent for all the others
1574         m_pVirtualRoot = new wxVirtualNode(data);
1575
1576         return TVI_ROOT;
1577     }
1578
1579     return DoInsertItem(wxTreeItemId((long)(WXHTREEITEM) 0), (long)(WXHTREEITEM) 0,
1580                         text, image, selectedImage, data);
1581 }
1582
1583 wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
1584                                      const wxString& text,
1585                                      int image, int selectedImage,
1586                                      wxTreeItemData *data)
1587 {
1588     return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,
1589                         text, image, selectedImage, data);
1590 }
1591
1592 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1593                                     const wxTreeItemId& idPrevious,
1594                                     const wxString& text,
1595                                     int image, int selectedImage,
1596                                     wxTreeItemData *data)
1597 {
1598     return DoInsertItem(parent, idPrevious, text, image, selectedImage, data);
1599 }
1600
1601 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
1602                                     size_t index,
1603                                     const wxString& text,
1604                                     int image, int selectedImage,
1605                                     wxTreeItemData *data)
1606 {
1607     // find the item from index
1608     long cookie;
1609     wxTreeItemId idPrev, idCur = GetFirstChild(parent, cookie);
1610     while ( index != 0 && idCur.IsOk() )
1611     {
1612         index--;
1613
1614         idPrev = idCur;
1615         idCur = GetNextChild(parent, cookie);
1616     }
1617
1618     // assert, not check: if the index is invalid, we will append the item
1619     // to the end
1620     wxASSERT_MSG( index == 0, _T("bad index in wxTreeCtrl::InsertItem") );
1621
1622     return DoInsertItem(parent, idPrev, text, image, selectedImage, data);
1623 }
1624
1625 wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
1626                                     const wxString& text,
1627                                     int image, int selectedImage,
1628                                     wxTreeItemData *data)
1629 {
1630     return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,
1631                         text, image, selectedImage, data);
1632 }
1633
1634 void wxTreeCtrl::Delete(const wxTreeItemId& item)
1635 {
1636     if ( !TreeView_DeleteItem(GetHwnd(), HITEM(item)) )
1637     {
1638         wxLogLastError(wxT("TreeView_DeleteItem"));
1639     }
1640 }
1641
1642 // delete all children (but don't delete the item itself)
1643 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
1644 {
1645     long cookie;
1646
1647     wxArrayLong children;
1648     wxTreeItemId child = GetFirstChild(item, cookie);
1649     while ( child.IsOk() )
1650     {
1651         children.Add((long)(WXHTREEITEM)child);
1652
1653         child = GetNextChild(item, cookie);
1654     }
1655
1656     size_t nCount = children.Count();
1657     for ( size_t n = 0; n < nCount; n++ )
1658     {
1659         if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)children[n]) )
1660         {
1661             wxLogLastError(wxT("TreeView_DeleteItem"));
1662         }
1663     }
1664 }
1665
1666 void wxTreeCtrl::DeleteAllItems()
1667 {
1668     // delete the "virtual" root item.
1669     if ( GET_VIRTUAL_ROOT() )
1670     {
1671         delete GET_VIRTUAL_ROOT();
1672         m_pVirtualRoot = NULL;
1673     }
1674
1675     // and all the real items
1676
1677     if ( !TreeView_DeleteAllItems(GetHwnd()) )
1678     {
1679         wxLogLastError(wxT("TreeView_DeleteAllItems"));
1680     }
1681 }
1682
1683 void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
1684 {
1685     wxASSERT_MSG( flag == TVE_COLLAPSE ||
1686                   flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
1687                   flag == TVE_EXPAND   ||
1688                   flag == TVE_TOGGLE,
1689                   wxT("Unknown flag in wxTreeCtrl::DoExpand") );
1690
1691     // A hidden root can be neither expanded nor collapsed.
1692     wxCHECK_RET( !(m_windowStyle & wxTR_HIDE_ROOT) || (HITEM(item) != TVI_ROOT),
1693                  wxT("Can't expand/collapse hidden root node!") )
1694
1695     // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
1696     // emulate them. This behaviour has changed slightly with comctl32.dll
1697     // v 4.70 - now it does send them but only the first time. To maintain
1698     // compatible behaviour and also in order to not have surprises with the
1699     // future versions, don't rely on this and still do everything ourselves.
1700     // To avoid that the messages be sent twice when the item is expanded for
1701     // the first time we must clear TVIS_EXPANDEDONCE style manually.
1702
1703     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDEDONCE);
1704     tvItem.state = 0;
1705     DoSetItem(&tvItem);
1706
1707     if ( TreeView_Expand(GetHwnd(), HITEM(item), flag) != 0 )
1708     {
1709         wxTreeEvent event(wxEVT_NULL, m_windowId);
1710         event.m_item = item;
1711         event.SetEventObject(this);
1712
1713         // note that the {EXPAND|COLLAPS}ING event is sent by TreeView_Expand()
1714         // itself
1715         event.SetEventType(gs_expandEvents[IsExpanded(item) ? IDX_EXPAND
1716                                                             : IDX_COLLAPSE]
1717                                           [IDX_DONE]);
1718
1719         (void)GetEventHandler()->ProcessEvent(event);
1720     }
1721     //else: change didn't took place, so do nothing at all
1722 }
1723
1724 void wxTreeCtrl::Expand(const wxTreeItemId& item)
1725 {
1726     DoExpand(item, TVE_EXPAND);
1727 }
1728
1729 void wxTreeCtrl::Collapse(const wxTreeItemId& item)
1730 {
1731     DoExpand(item, TVE_COLLAPSE);
1732 }
1733
1734 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
1735 {
1736     DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);
1737 }
1738
1739 void wxTreeCtrl::Toggle(const wxTreeItemId& item)
1740 {
1741     DoExpand(item, TVE_TOGGLE);
1742 }
1743
1744 void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
1745 {
1746     DoExpand(item, action);
1747 }
1748
1749 void wxTreeCtrl::Unselect()
1750 {
1751     wxASSERT_MSG( !(m_windowStyle & wxTR_MULTIPLE),
1752                   wxT("doesn't make sense, may be you want UnselectAll()?") );
1753
1754     // just remove the selection
1755     SelectItem(wxTreeItemId((long) (WXHTREEITEM) 0));
1756 }
1757
1758 void wxTreeCtrl::UnselectAll()
1759 {
1760     if ( m_windowStyle & wxTR_MULTIPLE )
1761     {
1762         wxArrayTreeItemIds selections;
1763         size_t count = GetSelections(selections);
1764         for ( size_t n = 0; n < count; n++ )
1765         {
1766 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1767             SetItemCheck(selections[n], false);
1768 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1769             ::UnselectItem(GetHwnd(), HITEM(selections[n]));
1770 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1771         }
1772     }
1773     else
1774     {
1775         // just remove the selection
1776         Unselect();
1777     }
1778 }
1779
1780 void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
1781 {
1782     if ( m_windowStyle & wxTR_MULTIPLE )
1783     {
1784 #if wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1785         // selecting the item means checking it
1786         SetItemCheck(item);
1787 #else // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1788         ::SelectItem(GetHwnd(), HITEM(item));
1789 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE/!wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
1790     }
1791     else
1792     {
1793         // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
1794         // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
1795         // send them ourselves
1796
1797         wxTreeEvent event(wxEVT_NULL, m_windowId);
1798         event.m_item = item;
1799         event.SetEventObject(this);
1800
1801         event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING);
1802         if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
1803         {
1804             if ( !TreeView_SelectItem(GetHwnd(), HITEM(item)) )
1805             {
1806                 wxLogLastError(wxT("TreeView_SelectItem"));
1807             }
1808             else
1809             {
1810                 event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
1811                 (void)GetEventHandler()->ProcessEvent(event);
1812             }
1813         }
1814         //else: program vetoed the change
1815     }
1816 }
1817
1818 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
1819 {
1820     // no error return
1821     TreeView_EnsureVisible(GetHwnd(), HITEM(item));
1822 }
1823
1824 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
1825 {
1826     if ( !TreeView_SelectSetFirstVisible(GetHwnd(), HITEM(item)) )
1827     {
1828         wxLogLastError(wxT("TreeView_SelectSetFirstVisible"));
1829     }
1830 }
1831
1832 wxTextCtrl *wxTreeCtrl::GetEditControl() const
1833 {
1834     return m_textCtrl;
1835 }
1836
1837 void wxTreeCtrl::DeleteTextCtrl()
1838 {
1839     if ( m_textCtrl )
1840     {
1841         // the HWND corresponding to this control is deleted by the tree
1842         // control itself and we don't know when exactly this happens, so check
1843         // if the window still exists before calling UnsubclassWin()
1844         if ( !::IsWindow(GetHwndOf(m_textCtrl)) )
1845         {
1846             m_textCtrl->SetHWND(0);
1847         }
1848
1849         m_textCtrl->UnsubclassWin();
1850         m_textCtrl->SetHWND(0);
1851         delete m_textCtrl;
1852         m_textCtrl = NULL;
1853     }
1854 }
1855
1856 wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
1857                                   wxClassInfo* textControlClass)
1858 {
1859     wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
1860
1861     DeleteTextCtrl();
1862
1863     m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
1864     HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), HITEM(item));
1865
1866     // this is not an error - the TVN_BEGINLABELEDIT handler might have
1867     // returned false
1868     if ( !hWnd )
1869     {
1870         delete m_textCtrl;
1871         m_textCtrl = NULL;
1872         return NULL;
1873     }
1874
1875     // textctrl is subclassed in MSWOnNotify
1876     return m_textCtrl;
1877 }
1878
1879 // End label editing, optionally cancelling the edit
1880 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& WXUNUSED(item), bool discardChanges)
1881 {
1882     TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
1883
1884     DeleteTextCtrl();
1885 }
1886
1887 wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
1888 {
1889     TV_HITTESTINFO hitTestInfo;
1890     hitTestInfo.pt.x = (int)point.x;
1891     hitTestInfo.pt.y = (int)point.y;
1892
1893     TreeView_HitTest(GetHwnd(), &hitTestInfo);
1894
1895     flags = 0;
1896
1897     // avoid repetition
1898     #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
1899                                     flags |= wxTREE_HITTEST_##flag
1900
1901     TRANSLATE_FLAG(ABOVE);
1902     TRANSLATE_FLAG(BELOW);
1903     TRANSLATE_FLAG(NOWHERE);
1904     TRANSLATE_FLAG(ONITEMBUTTON);
1905     TRANSLATE_FLAG(ONITEMICON);
1906     TRANSLATE_FLAG(ONITEMINDENT);
1907     TRANSLATE_FLAG(ONITEMLABEL);
1908     TRANSLATE_FLAG(ONITEMRIGHT);
1909     TRANSLATE_FLAG(ONITEMSTATEICON);
1910     TRANSLATE_FLAG(TOLEFT);
1911     TRANSLATE_FLAG(TORIGHT);
1912
1913     #undef TRANSLATE_FLAG
1914
1915     return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
1916 }
1917
1918 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
1919                                  wxRect& rect,
1920                                  bool textOnly) const
1921 {
1922     RECT rc;
1923     if ( TreeView_GetItemRect(GetHwnd(), HITEM(item),
1924                               &rc, textOnly) )
1925     {
1926         rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
1927
1928         return true;
1929     }
1930     else
1931     {
1932         // couldn't retrieve rect: for example, item isn't visible
1933         return false;
1934     }
1935 }
1936
1937 // ----------------------------------------------------------------------------
1938 // sorting stuff
1939 // ----------------------------------------------------------------------------
1940
1941 // this is just a tiny namespace which is friend to wxTreeCtrl and so can use
1942 // functions such as IsDataIndirect()
1943 class wxTreeSortHelper
1944 {
1945 public:
1946     static int CALLBACK Compare(LPARAM data1, LPARAM data2, LPARAM tree);
1947
1948 private:
1949     static wxTreeItemId GetIdFromData(wxTreeCtrl *tree, LPARAM item)
1950     {
1951         wxTreeItemData *data = (wxTreeItemData *)item;
1952         if ( tree->IsDataIndirect(data) )
1953         {
1954             data = ((wxTreeItemIndirectData *)data)->GetData();
1955         }
1956
1957         return data->GetId();
1958     }
1959 };
1960
1961 int CALLBACK wxTreeSortHelper::Compare(LPARAM pItem1,
1962                                        LPARAM pItem2,
1963                                        LPARAM htree)
1964 {
1965     wxCHECK_MSG( pItem1 && pItem2, 0,
1966                  wxT("sorting tree without data doesn't make sense") );
1967
1968     wxTreeCtrl *tree = (wxTreeCtrl *)htree;
1969
1970     return tree->OnCompareItems(GetIdFromData(tree, pItem1),
1971                                 GetIdFromData(tree, pItem2));
1972 }
1973
1974 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
1975                                const wxTreeItemId& item2)
1976 {
1977     return wxStrcmp(GetItemText(item1), GetItemText(item2));
1978 }
1979
1980 void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
1981 {
1982     // rely on the fact that TreeView_SortChildren does the same thing as our
1983     // default behaviour, i.e. sorts items alphabetically and so call it
1984     // directly if we're not in derived class (much more efficient!)
1985     if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
1986     {
1987         TreeView_SortChildren(GetHwnd(), HITEM(item), 0);
1988     }
1989     else
1990     {
1991         TV_SORTCB tvSort;
1992         tvSort.hParent = HITEM(item);
1993         tvSort.lpfnCompare = wxTreeSortHelper::Compare;
1994         tvSort.lParam = (LPARAM)this;
1995         TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
1996     }
1997 }
1998
1999 // ----------------------------------------------------------------------------
2000 // implementation
2001 // ----------------------------------------------------------------------------
2002
2003 bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
2004 {
2005     if ( cmd == EN_UPDATE )
2006     {
2007         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
2008         event.SetEventObject( this );
2009         ProcessCommand(event);
2010     }
2011     else if ( cmd == EN_KILLFOCUS )
2012     {
2013         wxCommandEvent event(wxEVT_KILL_FOCUS, id);
2014         event.SetEventObject( this );
2015         ProcessCommand(event);
2016     }
2017     else
2018     {
2019         // nothing done
2020         return false;
2021     }
2022
2023     // command processed
2024     return true;
2025 }
2026
2027 // we hook into WndProc to process WM_MOUSEMOVE/WM_BUTTONUP messages - as we
2028 // only do it during dragging, minimize wxWin overhead (this is important for
2029 // WM_MOUSEMOVE as they're a lot of them) by catching Windows messages directly
2030 // instead of passing by wxWin events
2031 long wxTreeCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2032 {
2033     bool processed = false;
2034     long rc = 0;
2035     bool isMultiple = (GetWindowStyle() & wxTR_MULTIPLE) != 0;
2036
2037     if ( (nMsg >= WM_MOUSEFIRST) && (nMsg <= WM_MOUSELAST) )
2038     {
2039         // we only process mouse messages here and these parameters have the
2040         // same meaning for all of them
2041         int x = GET_X_LPARAM(lParam),
2042             y = GET_Y_LPARAM(lParam);
2043         HTREEITEM htItem = GetItemFromPoint(GetHwnd(), x, y);
2044
2045         switch ( nMsg )
2046         {
2047             case WM_RBUTTONDOWN:
2048                 // if the item we are about to right click on
2049                 // is not already select, remove the entire
2050                 // previous selection
2051                 if (!::IsItemSelected(GetHwnd(), htItem))
2052                 {
2053                     UnselectAll();
2054                 }
2055
2056                 // select item and set the focus to the
2057                 // newly selected item
2058                 ::SelectItem(GetHwnd(), htItem);
2059                 ::SetFocus(GetHwnd(), htItem);
2060                 break;
2061
2062 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2063             case WM_LBUTTONDOWN:
2064                 if ( htItem && isMultiple )
2065                 {
2066                     if ( wParam & MK_CONTROL )
2067                     {
2068                         SetFocus();
2069
2070                         // toggle selected state
2071                         ToggleItemSelection(GetHwnd(), htItem);
2072
2073                         ::SetFocus(GetHwnd(), htItem);
2074
2075                         // reset on any click without Shift
2076                         m_htSelStart = 0;
2077
2078                         processed = true;
2079                     }
2080                     else if ( wParam & MK_SHIFT )
2081                     {
2082                         // this selects all items between the starting one and
2083                         // the current
2084
2085                         if ( !m_htSelStart )
2086                         {
2087                             // take the focused item
2088                             m_htSelStart = (WXHTREEITEM)
2089                                 TreeView_GetSelection(GetHwnd());
2090                         }
2091
2092                         SelectRange(GetHwnd(), HITEM(m_htSelStart), htItem,
2093                                     !(wParam & MK_CONTROL));
2094
2095                         ::SetFocus(GetHwnd(), htItem);
2096
2097                         processed = true;
2098                     }
2099                     else // normal click
2100                     {
2101                         // avoid doing anything if we click on the only
2102                         // currently selected item
2103                         wxArrayTreeItemIds selections;
2104                         size_t count = GetSelections(selections);
2105                         if ( count == 0 ||
2106                                 count > 1 ||
2107                                     HITEM(selections[0]) != htItem )
2108                         {
2109                             // clear the previously selected items
2110                             UnselectAll();
2111
2112                             // prevent the click from starting in-place editing
2113                             // which should only happen if we click on the
2114                             // already selected item (and nothing else is
2115                             // selected)
2116                             TreeView_SelectItem(GetHwnd(), 0);
2117                         }
2118
2119                         // reset on any click without Shift
2120                         m_htSelStart = 0;
2121                     }
2122                 }
2123                 break;
2124 #endif // wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2125
2126             case WM_MOUSEMOVE:
2127                 if ( m_dragImage )
2128                 {
2129                     m_dragImage->Move(wxPoint(x, y));
2130                     if ( htItem )
2131                     {
2132                         // highlight the item as target (hiding drag image is
2133                         // necessary - otherwise the display will be corrupted)
2134                         m_dragImage->Hide();
2135                         TreeView_SelectDropTarget(GetHwnd(), htItem);
2136                         m_dragImage->Show();
2137                     }
2138                 }
2139                 break;
2140
2141             case WM_LBUTTONUP:
2142             case WM_RBUTTONUP:
2143                 if ( m_dragImage )
2144                 {
2145                     m_dragImage->EndDrag();
2146                     delete m_dragImage;
2147                     m_dragImage = NULL;
2148
2149                     // generate the drag end event
2150                     wxTreeEvent event(wxEVT_COMMAND_TREE_END_DRAG, m_windowId);
2151
2152                     event.m_item = (WXHTREEITEM)htItem;
2153                     event.m_pointDrag = wxPoint(x, y);
2154                     event.SetEventObject(this);
2155
2156                     (void)GetEventHandler()->ProcessEvent(event);
2157
2158                     // if we don't do it, the tree seems to think that 2 items
2159                     // are selected simultaneously which is quite weird
2160                     TreeView_SelectDropTarget(GetHwnd(), 0);
2161                 }
2162                 break;
2163         }
2164     }
2165 #if !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2166     else if ( (nMsg == WM_SETFOCUS || nMsg == WM_KILLFOCUS) && isMultiple )
2167     {
2168         // the tree control greys out the selected item when it loses focus and
2169         // paints it as selected again when it regains it, but it won't do it
2170         // for the other items itself - help it
2171         wxArrayTreeItemIds selections;
2172         size_t count = GetSelections(selections);
2173         RECT rect;
2174         for ( size_t n = 0; n < count; n++ )
2175         {
2176             // TreeView_GetItemRect() will return false if item is not visible,
2177             // which may happen perfectly well
2178             if ( TreeView_GetItemRect(GetHwnd(), HITEM(selections[n]),
2179                                       &rect, true) )
2180             {
2181                 ::InvalidateRect(GetHwnd(), &rect, false);
2182             }
2183         }
2184     }
2185     else if ( nMsg == WM_KEYDOWN && isMultiple )
2186     {
2187         bool bCtrl = wxIsCtrlDown(),
2188              bShift = wxIsShiftDown();
2189
2190         // we handle.arrows and space, but not page up/down and home/end: the
2191         // latter should be easy, but not the former
2192
2193         HTREEITEM htSel = (HTREEITEM)TreeView_GetSelection(GetHwnd());
2194         if ( !m_htSelStart )
2195         {
2196             m_htSelStart = (WXHTREEITEM)htSel;
2197         }
2198
2199         if ( wParam == VK_SPACE )
2200         {
2201             if ( bCtrl )
2202             {
2203                 ToggleItemSelection(GetHwnd(), htSel);
2204             }
2205             else
2206             {
2207                 UnselectAll();
2208
2209                 ::SelectItem(GetHwnd(), htSel);
2210             }
2211
2212             processed = true;
2213         }
2214         else if ( wParam == VK_UP || wParam == VK_DOWN )
2215         {
2216             if ( !bCtrl && !bShift )
2217             {
2218                 // no modifiers, just clear selection and then let the default
2219                 // processing to take place
2220                 UnselectAll();
2221             }
2222             else if ( htSel )
2223             {
2224                 (void)wxControl::MSWWindowProc(nMsg, wParam, lParam);
2225
2226                 HTREEITEM htNext = (HTREEITEM)(wParam == VK_UP
2227                                     ? TreeView_GetPrevVisible(GetHwnd(), htSel)
2228                                     : TreeView_GetNextVisible(GetHwnd(), htSel));
2229
2230                 if ( !htNext )
2231                 {
2232                     // at the top/bottom
2233                     htNext = htSel;
2234                 }
2235
2236                 if ( bShift )
2237                 {
2238                     SelectRange(GetHwnd(), HITEM(m_htSelStart), htNext);
2239                 }
2240                 else // bCtrl
2241                 {
2242                     // without changing selection
2243                     ::SetFocus(GetHwnd(), htNext);
2244                 }
2245
2246                 processed = true;
2247             }
2248         }
2249     }
2250 #endif // !wxUSE_CHECKBOXES_IN_MULTI_SEL_TREE
2251     else if ( nMsg == WM_CHAR )
2252     {
2253         // don't let the control process Space and Return keys because it
2254         // doesn't do anything useful with them anyhow but always beeps
2255         // annoyingly when it receives them and there is no way to turn it off
2256         // simply if you just process TREEITEM_ACTIVATED event to which Space
2257         // and Enter presses are mapped in your code
2258         if ( wParam == VK_SPACE || wParam == VK_RETURN )
2259         {
2260             processed = true;
2261         }
2262     }
2263
2264     if ( !processed )
2265         rc = wxControl::MSWWindowProc(nMsg, wParam, lParam);
2266
2267     return rc;
2268 }
2269
2270 // process WM_NOTIFY Windows message
2271 bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
2272 {
2273     wxTreeEvent event(wxEVT_NULL, m_windowId);
2274     wxEventType eventType = wxEVT_NULL;
2275     NMHDR *hdr = (NMHDR *)lParam;
2276
2277     switch ( hdr->code )
2278     {
2279         case TVN_BEGINDRAG:
2280             eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
2281             // fall through
2282
2283         case TVN_BEGINRDRAG:
2284             {
2285                 if ( eventType == wxEVT_NULL )
2286                     eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
2287                 //else: left drag, already set above
2288
2289                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
2290
2291                 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2292                 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
2293
2294                 // don't allow dragging by default: the user code must
2295                 // explicitly say that it wants to allow it to avoid breaking
2296                 // the old apps
2297                 event.Veto();
2298             }
2299             break;
2300
2301         case TVN_BEGINLABELEDIT:
2302             {
2303                 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
2304                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2305
2306                 event.m_item = (WXHTREEITEM) info->item.hItem;
2307                 event.m_label = info->item.pszText;
2308                 event.m_editCancelled = false;
2309             }
2310             break;
2311
2312         case TVN_DELETEITEM:
2313             {
2314                 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
2315                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
2316
2317                 event.m_item = (WXHTREEITEM)tv->itemOld.hItem;
2318
2319                 if ( m_hasAnyAttr )
2320                 {
2321                     delete (wxTreeItemAttr *)m_attrs.
2322                                 Delete((long)tv->itemOld.hItem);
2323                 }
2324             }
2325             break;
2326
2327         case TVN_ENDLABELEDIT:
2328             {
2329                 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
2330                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2331
2332                 event.m_item = (WXHTREEITEM)info->item.hItem;
2333                 event.m_label = info->item.pszText;
2334                 if (info->item.pszText == NULL)
2335                 {
2336                     event.m_editCancelled = true;
2337                 }
2338                  else
2339                 {
2340                     event.m_editCancelled = false;
2341                 }
2342                 break;
2343             }
2344
2345         case TVN_GETDISPINFO:
2346             eventType = wxEVT_COMMAND_TREE_GET_INFO;
2347             // fall through
2348
2349         case TVN_SETDISPINFO:
2350             {
2351                 if ( eventType == wxEVT_NULL )
2352                     eventType = wxEVT_COMMAND_TREE_SET_INFO;
2353                 //else: get, already set above
2354
2355                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2356
2357                 event.m_item = (WXHTREEITEM) info->item.hItem;
2358                 break;
2359             }
2360
2361         case TVN_ITEMEXPANDING:
2362         case TVN_ITEMEXPANDED:
2363             {
2364                 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
2365
2366                 int what;
2367                 switch ( tv->action )
2368                 {
2369                     default:
2370                         wxLogDebug(wxT("unexpected code %d in TVN_ITEMEXPAND message"), tv->action);
2371                         // fall through
2372
2373                     case TVE_EXPAND:
2374                         what = IDX_EXPAND;
2375                         break;
2376
2377                     case TVE_COLLAPSE:
2378                         what = IDX_COLLAPSE;
2379                         break;
2380                 }
2381
2382                 int how = hdr->code == TVN_ITEMEXPANDING ? IDX_DOING
2383                                                          : IDX_DONE;
2384
2385                 eventType = gs_expandEvents[what][how];
2386
2387                 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2388             }
2389             break;
2390
2391         case TVN_KEYDOWN:
2392             {
2393                 eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
2394                 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
2395
2396                 // fabricate the lParam and wParam parameters sufficiently
2397                 // similar to the ones from a "real" WM_KEYDOWN so that
2398                 // CreateKeyEvent() works correctly
2399                 WXLPARAM lParam =
2400                     (::GetKeyState(VK_MENU) & 0x100 ? KF_ALTDOWN : 0) << 16;
2401
2402                 WXWPARAM wParam = info->wVKey;
2403
2404                 int keyCode = wxCharCodeMSWToWX(info->wVKey);
2405                 if ( !keyCode )
2406                 {
2407                     // wxCharCodeMSWToWX() returns 0 to indicate that this is a
2408                     // simple ASCII key
2409                     keyCode = wParam;
2410                 }
2411
2412                 event.m_evtKey = CreateKeyEvent(wxEVT_KEY_DOWN,
2413                                                 keyCode,
2414                                                 lParam,
2415                                                 wParam);
2416
2417                 // a separate event for Space/Return
2418                 if ( !wxIsCtrlDown() && !wxIsShiftDown() &&
2419                      ((info->wVKey == VK_SPACE) || (info->wVKey == VK_RETURN)) )
2420                 {
2421                     wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
2422                                        m_windowId);
2423                     event2.SetEventObject(this);
2424                     if ( !(GetWindowStyle() & wxTR_MULTIPLE) )
2425                     {
2426                         event2.m_item = GetSelection();
2427                     }
2428                     //else: don't know how to get it
2429
2430                     (void)GetEventHandler()->ProcessEvent(event2);
2431                 }
2432             }
2433             break;
2434
2435         // NB: MSLU is broken and sends TVN_SELCHANGEDA instead of
2436         //     TVN_SELCHANGEDW in Unicode mode under Win98. Therefore
2437         //     we have to handle both messages:
2438         case TVN_SELCHANGEDA:
2439         case TVN_SELCHANGEDW:
2440             eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
2441             // fall through
2442
2443         case TVN_SELCHANGINGA:
2444         case TVN_SELCHANGINGW:
2445             {
2446                 if ( eventType == wxEVT_NULL )
2447                     eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
2448                 //else: already set above
2449
2450                 if (hdr->code == TVN_SELCHANGINGW ||
2451                     hdr->code == TVN_SELCHANGEDW)
2452                 {
2453                     NM_TREEVIEWW* tv = (NM_TREEVIEWW *)lParam;
2454                     event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2455                     event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
2456                 }
2457                 else
2458                 {
2459                     NM_TREEVIEWA* tv = (NM_TREEVIEWA *)lParam;
2460                     event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
2461                     event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
2462                 }
2463             }
2464             break;
2465
2466 #if defined(_WIN32_IE) && _WIN32_IE >= 0x300 && !wxUSE_COMCTL32_SAFELY && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
2467         case NM_CUSTOMDRAW:
2468             {
2469                 LPNMTVCUSTOMDRAW lptvcd = (LPNMTVCUSTOMDRAW)lParam;
2470                 NMCUSTOMDRAW& nmcd = lptvcd->nmcd;
2471                 switch ( nmcd.dwDrawStage )
2472                 {
2473                     case CDDS_PREPAINT:
2474                         // if we've got any items with non standard attributes,
2475                         // notify us before painting each item
2476                         *result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
2477                                                : CDRF_DODEFAULT;
2478                         break;
2479
2480                     case CDDS_ITEMPREPAINT:
2481                         {
2482                             wxTreeItemAttr *attr =
2483                                 (wxTreeItemAttr *)m_attrs.Get(nmcd.dwItemSpec);
2484
2485                             if ( !attr )
2486                             {
2487                                 // nothing to do for this item
2488                                 *result = CDRF_DODEFAULT;
2489                                 break;
2490                             }
2491
2492                             HFONT hFont;
2493                             if ( attr->HasFont() )
2494                             {
2495                                 hFont = GetHfontOf(attr->GetFont());
2496                             }
2497                             else
2498                             {
2499                                 hFont = 0;
2500                             }
2501
2502                             wxColour colText;
2503                             if ( attr->HasTextColour() )
2504                             {
2505                                 colText = attr->GetTextColour();
2506                             }
2507                             else
2508                             {
2509                                 colText = GetForegroundColour();
2510                             }
2511
2512                             // selection colours should override ours
2513                             if ( nmcd.uItemState & CDIS_SELECTED )
2514                             {
2515                                 lptvcd->clrTextBk =
2516                                     ::GetSysColor(COLOR_HIGHLIGHT);
2517                                 lptvcd->clrText =
2518                                     ::GetSysColor(COLOR_HIGHLIGHTTEXT);
2519                             }
2520                             else // !selected
2521                             {
2522                                 wxColour colBack;
2523                                 if ( attr->HasBackgroundColour() )
2524                                 {
2525                                     colBack = attr->GetBackgroundColour();
2526                                 }
2527                                 else
2528                                 {
2529                                     colBack = GetBackgroundColour();
2530                                 }
2531
2532                                 lptvcd->clrText = wxColourToRGB(colText);
2533                                 lptvcd->clrTextBk = wxColourToRGB(colBack);
2534                             }
2535
2536                             // note that if we wanted to set colours for
2537                             // individual columns (subitems), we would have
2538                             // returned CDRF_NOTIFYSUBITEMREDRAW from here
2539                             if ( hFont )
2540                             {
2541                                 ::SelectObject(nmcd.hdc, hFont);
2542
2543                                 *result = CDRF_NEWFONT;
2544                             }
2545                             else
2546                             {
2547                                 *result = CDRF_DODEFAULT;
2548                             }
2549                         }
2550                         break;
2551
2552                     default:
2553                         *result = CDRF_DODEFAULT;
2554                 }
2555             }
2556
2557             // we always process it
2558             return true;
2559 #endif // _WIN32_IE >= 0x300
2560
2561         case NM_DBLCLK:
2562         case NM_RCLICK:
2563             {
2564                 TV_HITTESTINFO tvhti;
2565                 ::GetCursorPos(&tvhti.pt);
2566                 ::ScreenToClient(GetHwnd(), &tvhti.pt);
2567                 if ( TreeView_HitTest(GetHwnd(), &tvhti) )
2568                 {
2569                     if ( tvhti.flags & TVHT_ONITEM )
2570                     {
2571                         event.m_item = (WXHTREEITEM) tvhti.hItem;
2572                         eventType = (int)hdr->code == NM_DBLCLK
2573                                     ? wxEVT_COMMAND_TREE_ITEM_ACTIVATED
2574                                     : wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
2575
2576                         event.m_pointDrag.x = tvhti.pt.x;
2577                         event.m_pointDrag.y = tvhti.pt.y;
2578                     }
2579
2580                     break;
2581                 }
2582             }
2583             // fall through
2584
2585         default:
2586             return wxControl::MSWOnNotify(idCtrl, lParam, result);
2587     }
2588
2589     event.SetEventObject(this);
2590     event.SetEventType(eventType);
2591
2592     bool processed = GetEventHandler()->ProcessEvent(event);
2593
2594     // post processing
2595     switch ( hdr->code )
2596     {
2597         case NM_DBLCLK:
2598             // we translate NM_DBLCLK into ACTIVATED event, so don't interpret
2599             // the return code of this event handler as the return value for
2600             // NM_DBLCLK - otherwise, double clicking the item to toggle its
2601             // expanded status would never work
2602             *result = false;
2603             break;
2604
2605         case TVN_BEGINDRAG:
2606         case TVN_BEGINRDRAG:
2607             if ( event.IsAllowed() )
2608             {
2609                 // normally this is impossible because the m_dragImage is
2610                 // deleted once the drag operation is over
2611                 wxASSERT_MSG( !m_dragImage, _T("starting to drag once again?") );
2612
2613                 m_dragImage = new wxDragImage(*this, event.m_item);
2614                 m_dragImage->BeginDrag(wxPoint(0, 0), this);
2615                 m_dragImage->Show();
2616             }
2617             break;
2618
2619         case TVN_DELETEITEM:
2620             {
2621                 // NB: we might process this message using wxWindows event
2622                 //     tables, but due to overhead of wxWin event system we
2623                 //     prefer to do it here ourself (otherwise deleting a tree
2624                 //     with many items is just too slow)
2625                 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
2626
2627                 wxTreeItemId item = event.m_item;
2628                 if ( HasIndirectData(item) )
2629                 {
2630                     wxTreeItemIndirectData *data = (wxTreeItemIndirectData *)
2631                                                         tv->itemOld.lParam;
2632                     delete data; // can't be NULL here
2633                 }
2634                 else
2635                 {
2636                     wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
2637                     delete data; // may be NULL, ok
2638                 }
2639
2640                 processed = true; // Make sure we don't get called twice
2641             }
2642             break;
2643
2644         case TVN_BEGINLABELEDIT:
2645             // return true to cancel label editing
2646             *result = !event.IsAllowed();
2647             // set ES_WANTRETURN ( like we do in BeginLabelEdit )
2648             if(event.IsAllowed())
2649             {
2650                 HWND hText = TreeView_GetEditControl(GetHwnd());
2651                 if(hText != NULL)
2652                 {
2653                     // MBN: if m_textCtrl already has an HWND, it is a stale
2654                     // pointer from a previous edit (because the user
2655                     // didn't modify the label before dismissing the control,
2656                     // and TVN_ENDLABELEDIT was not sent), so delete it
2657                     if(m_textCtrl && m_textCtrl->GetHWND() != 0)
2658                         DeleteTextCtrl();
2659                     if(!m_textCtrl)
2660                         m_textCtrl = new wxTextCtrl();
2661                     m_textCtrl->SetParent(this);
2662                     m_textCtrl->SetHWND((WXHWND)hText);
2663                     m_textCtrl->SubclassWin((WXHWND)hText);
2664
2665                     // set wxTE_PROCESS_ENTER style for the text control to
2666                     // force it to process the Enter presses itself, otherwise
2667                     // they could be stolen from it by the dialog
2668                     // navigation code
2669                     m_textCtrl->SetWindowStyle(m_textCtrl->GetWindowStyle()
2670                                                | wxTE_PROCESS_ENTER);
2671                 }
2672             }
2673             break;
2674
2675         case TVN_ENDLABELEDIT:
2676             // return true to set the label to the new string: note that we
2677             // also must pretend that we did process the message or it is going
2678             // to be passed to DefWindowProc() which will happily return false
2679             // cancelling the label change
2680             *result = event.IsAllowed();
2681             processed = true;
2682
2683             // ensure that we don't have the text ctrl which is going to be
2684             // deleted any more
2685             DeleteTextCtrl();
2686             break;
2687
2688         case TVN_SELCHANGING:
2689         case TVN_ITEMEXPANDING:
2690             // return true to prevent the action from happening
2691             *result = !event.IsAllowed();
2692             break;
2693
2694         case TVN_ITEMEXPANDED:
2695             // the item is not refreshed properly after expansion when it has
2696             // an image depending on the expanded/collapsed state - bug in
2697             // comctl32.dll or our code?
2698             {
2699                 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
2700                 wxTreeItemId id = (WXHTREEITEM)tv->itemNew.hItem;
2701
2702                 int image = GetItemImage(id, wxTreeItemIcon_Expanded);
2703                 if ( image != -1 )
2704                 {
2705                     RefreshItem(id);
2706                 }
2707             }
2708             break;
2709
2710         case TVN_GETDISPINFO:
2711             // NB: so far the user can't set the image himself anyhow, so do it
2712             //     anyway - but this may change later
2713             //if ( /* !processed && */ 1 )
2714             {
2715                 wxTreeItemId item = event.m_item;
2716                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
2717                 if ( info->item.mask & TVIF_IMAGE )
2718                 {
2719                     info->item.iImage =
2720                         DoGetItemImageFromData
2721                         (
2722                          item,
2723                          IsExpanded(item) ? wxTreeItemIcon_Expanded
2724                                           : wxTreeItemIcon_Normal
2725                         );
2726                 }
2727                 if ( info->item.mask & TVIF_SELECTEDIMAGE )
2728                 {
2729                     info->item.iSelectedImage =
2730                         DoGetItemImageFromData
2731                         (
2732                          item,
2733                          IsExpanded(item) ? wxTreeItemIcon_SelectedExpanded
2734                                           : wxTreeItemIcon_Selected
2735                         );
2736                 }
2737             }
2738             break;
2739
2740         //default:
2741             // for the other messages the return value is ignored and there is
2742             // nothing special to do
2743     }
2744     return processed;
2745 }
2746
2747 #endif // __WIN95__
2748
2749 #endif // wxUSE_TREECTRL