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