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