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