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