src/msw/treectrl.cpp

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