src/msw/treectrl.cpp

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