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