src/msw/treectrl.cpp

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