src/msw/treectrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        treectrl.cpp
   3 // Purpose:     wxTreeCtrl
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin to be less MSW-specific on 10.10.98
   6 // Created:     1997
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19 #ifdef __GNUG__
  20     #pragma implementation "treectrl.h"
  21 #endif
  22
  23 // For compilers that support precompilation, includes "wx.h".
  24 #include "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27     #pragma hdrstop
  28 #endif
  29
  30 #include "wx/window.h"
  31 #include "wx/msw/private.h"
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/settings.h"
  35 #endif
  36
  37 // Mingw32 is a bit mental even though this is done in winundef
  38 #ifdef GetFirstChild
  39     #undef GetFirstChild
  40 #endif
  41
  42 #ifdef GetNextSibling
  43     #undef GetNextSibling
  44 #endif
  45
  46 #if defined(__WIN95__)
  47
  48 #include "wx/log.h"
  49 #include "wx/dynarray.h"
  50 #include "wx/imaglist.h"
  51 #include "wx/treectrl.h"
  52
  53 #ifdef __GNUWIN32__
  54 #include "wx/msw/gnuwin32/extra.h"
  55 #endif
  56
  57 #if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__)
  58     #include <commctrl.h>
  59 #endif
  60
  61 // Bug in headers, sometimes
  62 #ifndef TVIS_FOCUSED
  63     #define TVIS_FOCUSED            0x0001
  64 #endif
  65
  66 // ----------------------------------------------------------------------------
  67 // private classes
  68 // ----------------------------------------------------------------------------
  69
  70 // a convenient wrapper around TV_ITEM struct which adds a ctor
  71 struct wxTreeViewItem : public TV_ITEM
  72 {
  73     wxTreeViewItem(const wxTreeItemId& item,
  74                    UINT mask_, UINT stateMask_ = 0)
  75     {
  76         mask = mask_;
  77         stateMask = stateMask_;
  78         hItem = (HTREEITEM) (WXHTREEITEM) item;
  79     }
  80 };
  81
  82 // ----------------------------------------------------------------------------
  83 // macros
  84 // ----------------------------------------------------------------------------
  85
  86 #if !USE_SHARED_LIBRARY
  87     IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl)
  88 #endif
  89
  90 // ----------------------------------------------------------------------------
  91 // variables
  92 // ----------------------------------------------------------------------------
  93
  94 // handy table for sending events
  95 static const wxEventType g_events[2][2] =
  96 {
  97     { wxEVT_COMMAND_TREE_ITEM_COLLAPSED, wxEVT_COMMAND_TREE_ITEM_COLLAPSING },
  98     { wxEVT_COMMAND_TREE_ITEM_EXPANDED,  wxEVT_COMMAND_TREE_ITEM_EXPANDING  }
  99 };
 100
 101 // ============================================================================
 102 // implementation
 103 // ============================================================================
 104
 105 // ----------------------------------------------------------------------------
 106 // construction and destruction
 107 // ----------------------------------------------------------------------------
 108
 109 void wxTreeCtrl::Init()
 110 {
 111     m_imageListNormal = NULL;
 112     m_imageListState = NULL;
 113     m_textCtrl = NULL;
 114 }
 115
 116 bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id,
 117                         const wxPoint& pos, const wxSize& size,
 118                         long style, const wxValidator& validator,
 119                         const wxString& name)
 120 {
 121     Init();
 122
 123     wxSystemSettings settings;
 124
 125     SetName(name);
 126     SetValidator(validator);
 127
 128     m_windowStyle = style;
 129
 130     SetParent(parent);
 131
 132     m_windowId = (id == -1) ? NewControlId() : id;
 133
 134     DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
 135                    TVS_HASLINES | TVS_SHOWSELALWAYS;
 136
 137     bool want3D;
 138     WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
 139
 140     // Even with extended styles, need to combine with WS_BORDER
 141     // for them to look right.
 142     if ( want3D || wxStyleHasBorder(m_windowStyle) )
 143     {
 144         wstyle |= WS_BORDER;
 145     }
 146
 147     if ( m_windowStyle & wxTR_HAS_BUTTONS )
 148         wstyle |= TVS_HASBUTTONS;
 149
 150     if ( m_windowStyle & wxTR_EDIT_LABELS )
 151         wstyle |= TVS_EDITLABELS;
 152
 153     if ( m_windowStyle & wxTR_LINES_AT_ROOT )
 154         wstyle |= TVS_LINESATROOT;
 155
 156     // Create the tree control.
 157     m_hWnd = (WXHWND)::CreateWindowEx
 158                        (
 159                         exStyle,
 160                         WC_TREEVIEW,
 161                         _T(""),
 162                         wstyle,
 163                         pos.x, pos.y, size.x, size.y,
 164                         (HWND)parent->GetHWND(),
 165                         (HMENU)m_windowId,
 166                         wxGetInstance(),
 167                         NULL
 168                        );
 169
 170     wxCHECK_MSG( m_hWnd, FALSE, _T("Failed to create tree ctrl") );
 171
 172     if ( parent )
 173         parent->AddChild(this);
 174
 175     SubclassWin(m_hWnd);
 176
 177     return TRUE;
 178 }
 179
 180 wxTreeCtrl::~wxTreeCtrl()
 181 {
 182     DeleteTextCtrl();
 183
 184     // delete user data to prevent memory leaks
 185     DeleteAllItems();
 186 }
 187
 188 // ----------------------------------------------------------------------------
 189 // accessors
 190 // ----------------------------------------------------------------------------
 191
 192 // simple wrappers which add error checking in debug mode
 193
 194 bool wxTreeCtrl::DoGetItem(wxTreeViewItem* tvItem) const
 195 {
 196     if ( !TreeView_GetItem(GetHwnd(), tvItem) )
 197     {
 198         wxLogLastError("TreeView_GetItem");
 199
 200         return FALSE;
 201     }
 202
 203     return TRUE;
 204 }
 205
 206 void wxTreeCtrl::DoSetItem(wxTreeViewItem* tvItem)
 207 {
 208     if ( TreeView_SetItem(GetHwnd(), tvItem) == -1 )
 209     {
 210         wxLogLastError("TreeView_SetItem");
 211     }
 212 }
 213
 214 size_t wxTreeCtrl::GetCount() const
 215 {
 216     return (size_t)TreeView_GetCount(GetHwnd());
 217 }
 218
 219 unsigned int wxTreeCtrl::GetIndent() const
 220 {
 221     return TreeView_GetIndent(GetHwnd());
 222 }
 223
 224 void wxTreeCtrl::SetIndent(unsigned int indent)
 225 {
 226     TreeView_SetIndent(GetHwnd(), indent);
 227 }
 228
 229 wxImageList *wxTreeCtrl::GetImageList() const
 230 {
 231     return m_imageListNormal;
 232 }
 233
 234 wxImageList *wxTreeCtrl::GetStateImageList() const
 235 {
 236     return m_imageListNormal;
 237 }
 238
 239 void wxTreeCtrl::SetAnyImageList(wxImageList *imageList, int which)
 240 {
 241     // no error return
 242     TreeView_SetImageList(GetHwnd(),
 243                           imageList ? imageList->GetHIMAGELIST() : 0,
 244                           which);
 245 }
 246
 247 void wxTreeCtrl::SetImageList(wxImageList *imageList)
 248 {
 249     SetAnyImageList(m_imageListNormal = imageList, TVSIL_NORMAL);
 250 }
 251
 252 void wxTreeCtrl::SetStateImageList(wxImageList *imageList)
 253 {
 254     SetAnyImageList(m_imageListState = imageList, TVSIL_STATE);
 255 }
 256
 257 size_t wxTreeCtrl::GetChildrenCount(const wxTreeItemId& item, bool recursively)
 258 {
 259     long cookie;
 260
 261     size_t result = 0;
 262
 263     wxArrayLong children;
 264     wxTreeItemId child = GetFirstChild(item, cookie);
 265     while ( child.IsOk() )
 266     {
 267         if ( recursively )
 268         {
 269             // recursive call
 270             result += GetChildrenCount(child, TRUE);
 271         }
 272
 273         // add the child to the result in any case
 274         result++;
 275
 276         child = GetNextChild(item, cookie);
 277     }
 278
 279     return result;
 280 }
 281
 282 // ----------------------------------------------------------------------------
 283 // Item access
 284 // ----------------------------------------------------------------------------
 285
 286 wxString wxTreeCtrl::GetItemText(const wxTreeItemId& item) const
 287 {
 288     wxChar buf[512];  // the size is arbitrary...
 289
 290     wxTreeViewItem tvItem(item, TVIF_TEXT);
 291     tvItem.pszText = buf;
 292     tvItem.cchTextMax = WXSIZEOF(buf);
 293     if ( !DoGetItem(&tvItem) )
 294     {
 295         // don't return some garbage which was on stack, but an empty string
 296         buf[0] = _T('\0');
 297     }
 298
 299     return wxString(buf);
 300 }
 301
 302 void wxTreeCtrl::SetItemText(const wxTreeItemId& item, const wxString& text)
 303 {
 304     wxTreeViewItem tvItem(item, TVIF_TEXT);
 305     tvItem.pszText = (wxChar *)text.c_str();  // conversion is ok
 306     DoSetItem(&tvItem);
 307 }
 308
 309 int wxTreeCtrl::GetItemImage(const wxTreeItemId& item) const
 310 {
 311     wxTreeViewItem tvItem(item, TVIF_IMAGE);
 312     DoGetItem(&tvItem);
 313
 314     return tvItem.iImage;
 315 }
 316
 317 void wxTreeCtrl::SetItemImage(const wxTreeItemId& item, int image)
 318 {
 319     wxTreeViewItem tvItem(item, TVIF_IMAGE);
 320     tvItem.iImage = image;
 321     DoSetItem(&tvItem);
 322 }
 323
 324 int wxTreeCtrl::GetItemSelectedImage(const wxTreeItemId& item) const
 325 {
 326     wxTreeViewItem tvItem(item, TVIF_SELECTEDIMAGE);
 327     DoGetItem(&tvItem);
 328
 329     return tvItem.iSelectedImage;
 330 }
 331
 332 void wxTreeCtrl::SetItemSelectedImage(const wxTreeItemId& item, int image)
 333 {
 334     wxTreeViewItem tvItem(item, TVIF_SELECTEDIMAGE);
 335     tvItem.iSelectedImage = image;
 336     DoSetItem(&tvItem);
 337 }
 338
 339 wxTreeItemData *wxTreeCtrl::GetItemData(const wxTreeItemId& item) const
 340 {
 341     wxTreeViewItem tvItem(item, TVIF_PARAM);
 342     if ( !DoGetItem(&tvItem) )
 343     {
 344         return NULL;
 345     }
 346
 347     return (wxTreeItemData *)tvItem.lParam;
 348 }
 349
 350 void wxTreeCtrl::SetItemData(const wxTreeItemId& item, wxTreeItemData *data)
 351 {
 352     wxTreeViewItem tvItem(item, TVIF_PARAM);
 353     tvItem.lParam = (LPARAM)data;
 354     DoSetItem(&tvItem);
 355 }
 356
 357 void wxTreeCtrl::SetItemHasChildren(const wxTreeItemId& item, bool has)
 358 {
 359     wxTreeViewItem tvItem(item, TVIF_CHILDREN);
 360     tvItem.cChildren = (int)has;
 361     DoSetItem(&tvItem);
 362 }
 363
 364 void wxTreeCtrl::SetItemBold(const wxTreeItemId& item, bool bold)
 365 {
 366     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
 367     tvItem.state = bold ? TVIS_BOLD : 0;
 368     DoSetItem(&tvItem);
 369 }
 370
 371 void wxTreeCtrl::SetItemDropHighlight(const wxTreeItemId& item, bool highlight)
 372 {
 373     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_DROPHILITED);
 374     tvItem.state = highlight ? TVIS_DROPHILITED : 0;
 375     DoSetItem(&tvItem);
 376 }
 377
 378 // ----------------------------------------------------------------------------
 379 // Item status
 380 // ----------------------------------------------------------------------------
 381
 382 bool wxTreeCtrl::IsVisible(const wxTreeItemId& item) const
 383 {
 384     // Bug in Gnu-Win32 headers, so don't use the macro TreeView_GetItemRect
 385     RECT rect;
 386     return SendMessage(GetHwnd(), TVM_GETITEMRECT, FALSE, (LPARAM)&rect) != 0;
 387
 388 }
 389
 390 bool wxTreeCtrl::ItemHasChildren(const wxTreeItemId& item) const
 391 {
 392     wxTreeViewItem tvItem(item, TVIF_CHILDREN);
 393     DoGetItem(&tvItem);
 394
 395     return tvItem.cChildren != 0;
 396 }
 397
 398 bool wxTreeCtrl::IsExpanded(const wxTreeItemId& item) const
 399 {
 400     // probably not a good idea to put it here
 401     //wxASSERT( ItemHasChildren(item) );
 402
 403     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDED);
 404     DoGetItem(&tvItem);
 405
 406     return (tvItem.state & TVIS_EXPANDED) != 0;
 407 }
 408
 409 bool wxTreeCtrl::IsSelected(const wxTreeItemId& item) const
 410 {
 411     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_SELECTED);
 412     DoGetItem(&tvItem);
 413
 414     return (tvItem.state & TVIS_SELECTED) != 0;
 415 }
 416
 417 bool wxTreeCtrl::IsBold(const wxTreeItemId& item) const
 418 {
 419     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_BOLD);
 420     DoGetItem(&tvItem);
 421
 422     return (tvItem.state & TVIS_BOLD) != 0;
 423 }
 424
 425 // ----------------------------------------------------------------------------
 426 // navigation
 427 // ----------------------------------------------------------------------------
 428
 429 wxTreeItemId wxTreeCtrl::GetRootItem() const
 430 {
 431     return wxTreeItemId((WXHTREEITEM) TreeView_GetRoot(GetHwnd()));
 432 }
 433
 434 wxTreeItemId wxTreeCtrl::GetSelection() const
 435 {
 436     return wxTreeItemId((WXHTREEITEM) TreeView_GetSelection(GetHwnd()));
 437 }
 438
 439 wxTreeItemId wxTreeCtrl::GetParent(const wxTreeItemId& item) const
 440 {
 441     return wxTreeItemId((WXHTREEITEM) TreeView_GetParent(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
 442 }
 443
 444 wxTreeItemId wxTreeCtrl::GetFirstChild(const wxTreeItemId& item,
 445                                        long& _cookie) const
 446 {
 447     // remember the last child returned in 'cookie'
 448     _cookie = (long)TreeView_GetChild(GetHwnd(), (HTREEITEM) (WXHTREEITEM)item);
 449
 450     return wxTreeItemId((WXHTREEITEM)_cookie);
 451 }
 452
 453 wxTreeItemId wxTreeCtrl::GetNextChild(const wxTreeItemId& WXUNUSED(item),
 454                                       long& _cookie) const
 455 {
 456     wxTreeItemId l = wxTreeItemId((WXHTREEITEM)TreeView_GetNextSibling(GetHwnd(),
 457                                    (HTREEITEM)(WXHTREEITEM)_cookie));
 458     _cookie = (long)l;
 459
 460     return l;
 461 }
 462
 463 wxTreeItemId wxTreeCtrl::GetLastChild(const wxTreeItemId& item) const
 464 {
 465     // can this be done more efficiently?
 466     long cookie;
 467
 468     wxTreeItemId childLast,
 469     child = GetFirstChild(item, cookie);
 470     while ( child.IsOk() )
 471     {
 472         childLast = child;
 473         child = GetNextChild(item, cookie);
 474     }
 475
 476     return childLast;
 477 }
 478
 479 wxTreeItemId wxTreeCtrl::GetNextSibling(const wxTreeItemId& item) const
 480 {
 481     return wxTreeItemId((WXHTREEITEM) TreeView_GetNextSibling(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
 482 }
 483
 484 wxTreeItemId wxTreeCtrl::GetPrevSibling(const wxTreeItemId& item) const
 485 {
 486     return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevSibling(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
 487 }
 488
 489 wxTreeItemId wxTreeCtrl::GetFirstVisibleItem() const
 490 {
 491     return wxTreeItemId((WXHTREEITEM) TreeView_GetFirstVisible(GetHwnd()));
 492 }
 493
 494 wxTreeItemId wxTreeCtrl::GetNextVisible(const wxTreeItemId& item) const
 495 {
 496     wxASSERT_MSG( IsVisible(item), _T("The item you call GetNextVisible() "
 497                                       "for must be visible itself!"));
 498
 499     return wxTreeItemId((WXHTREEITEM) TreeView_GetNextVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
 500 }
 501
 502 wxTreeItemId wxTreeCtrl::GetPrevVisible(const wxTreeItemId& item) const
 503 {
 504     wxASSERT_MSG( IsVisible(item), _T("The item you call GetPrevVisible() "
 505                                       "for must be visible itself!"));
 506
 507     return wxTreeItemId((WXHTREEITEM) TreeView_GetPrevVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item));
 508 }
 509
 510 // ----------------------------------------------------------------------------
 511 // Usual operations
 512 // ----------------------------------------------------------------------------
 513
 514 wxTreeItemId wxTreeCtrl::DoInsertItem(const wxTreeItemId& parent,
 515                                       wxTreeItemId hInsertAfter,
 516                                       const wxString& text,
 517                                       int image, int selectedImage,
 518                                       wxTreeItemData *data)
 519 {
 520     TV_INSERTSTRUCT tvIns;
 521     tvIns.hParent = (HTREEITEM) (WXHTREEITEM)parent;
 522     tvIns.hInsertAfter = (HTREEITEM) (WXHTREEITEM) hInsertAfter;
 523
 524     // This is how we insert the item as the first child: supply a NULL hInsertAfter
 525     if (tvIns.hInsertAfter == (HTREEITEM) 0)
 526     {
 527         tvIns.hInsertAfter = TVI_FIRST;
 528     }
 529
 530     UINT mask = 0;
 531     if ( !text.IsEmpty() )
 532     {
 533         mask |= TVIF_TEXT;
 534         tvIns.item.pszText = (wxChar *)text.c_str();  // cast is ok
 535     }
 536
 537     if ( image != -1 )
 538     {
 539         mask |= TVIF_IMAGE;
 540         tvIns.item.iImage = image;
 541
 542         if ( selectedImage == -1 )
 543         {
 544             // take the same image for selected icon if not specified
 545             selectedImage = image;
 546         }
 547     }
 548
 549     if ( selectedImage != -1 )
 550     {
 551         mask |= TVIF_SELECTEDIMAGE;
 552         tvIns.item.iSelectedImage = selectedImage;
 553     }
 554
 555     if ( data != NULL )
 556     {
 557         mask |= TVIF_PARAM;
 558         tvIns.item.lParam = (LPARAM)data;
 559     }
 560
 561     tvIns.item.mask = mask;
 562
 563     HTREEITEM id = (HTREEITEM) TreeView_InsertItem(GetHwnd(), &tvIns);
 564     if ( id == 0 )
 565     {
 566         wxLogLastError("TreeView_InsertItem");
 567     }
 568
 569     if ( data != NULL )
 570     {
 571         // associate the application tree item with Win32 tree item handle
 572         data->SetId((WXHTREEITEM)id);
 573     }
 574
 575     return wxTreeItemId((WXHTREEITEM)id);
 576 }
 577
 578 // for compatibility only
 579 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
 580                                     const wxString& text,
 581                                     int image, int selImage,
 582                                     long insertAfter)
 583 {
 584     return DoInsertItem(parent, (WXHTREEITEM)insertAfter, text,
 585                         image, selImage, NULL);
 586 }
 587
 588 wxTreeItemId wxTreeCtrl::AddRoot(const wxString& text,
 589                                  int image, int selectedImage,
 590                                  wxTreeItemData *data)
 591 {
 592     return DoInsertItem(wxTreeItemId((WXHTREEITEM) 0), (WXHTREEITEM) 0,
 593                         text, image, selectedImage, data);
 594 }
 595
 596 wxTreeItemId wxTreeCtrl::PrependItem(const wxTreeItemId& parent,
 597                                      const wxString& text,
 598                                      int image, int selectedImage,
 599                                      wxTreeItemData *data)
 600 {
 601     return DoInsertItem(parent, (WXHTREEITEM) TVI_FIRST,
 602                         text, image, selectedImage, data);
 603 }
 604
 605 wxTreeItemId wxTreeCtrl::InsertItem(const wxTreeItemId& parent,
 606                                     const wxTreeItemId& idPrevious,
 607                                     const wxString& text,
 608                                     int image, int selectedImage,
 609                                     wxTreeItemData *data)
 610 {
 611     return DoInsertItem(parent, idPrevious, text, image, selectedImage, data);
 612 }
 613
 614 wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId& parent,
 615                                     const wxString& text,
 616                                     int image, int selectedImage,
 617                                     wxTreeItemData *data)
 618 {
 619     return DoInsertItem(parent, (WXHTREEITEM) TVI_LAST,
 620                         text, image, selectedImage, data);
 621 }
 622
 623 void wxTreeCtrl::Delete(const wxTreeItemId& item)
 624 {
 625     if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item) )
 626     {
 627         wxLogLastError("TreeView_DeleteItem");
 628     }
 629 }
 630
 631 // delete all children (but don't delete the item itself)
 632 void wxTreeCtrl::DeleteChildren(const wxTreeItemId& item)
 633 {
 634     long cookie;
 635
 636     wxArrayLong children;
 637     wxTreeItemId child = GetFirstChild(item, cookie);
 638     while ( child.IsOk() )
 639     {
 640         children.Add((long)(WXHTREEITEM)child);
 641
 642         child = GetNextChild(item, cookie);
 643     }
 644
 645     size_t nCount = children.Count();
 646     for ( size_t n = 0; n < nCount; n++ )
 647     {
 648         if ( !TreeView_DeleteItem(GetHwnd(), (HTREEITEM)children[n]) )
 649         {
 650             wxLogLastError("TreeView_DeleteItem");
 651         }
 652     }
 653 }
 654
 655 void wxTreeCtrl::DeleteAllItems()
 656 {
 657     if ( !TreeView_DeleteAllItems(GetHwnd()) )
 658     {
 659         wxLogLastError("TreeView_DeleteAllItems");
 660     }
 661 }
 662
 663 void wxTreeCtrl::DoExpand(const wxTreeItemId& item, int flag)
 664 {
 665     wxASSERT_MSG( flag == TVE_COLLAPSE ||
 666                   flag == (TVE_COLLAPSE | TVE_COLLAPSERESET) ||
 667                   flag == TVE_EXPAND   ||
 668                   flag == TVE_TOGGLE,
 669                   _T("Unknown flag in wxTreeCtrl::DoExpand") );
 670
 671     // TreeView_Expand doesn't send TVN_ITEMEXPAND(ING) messages, so we must
 672     // emulate them. This behaviour has changed slightly with comctl32.dll
 673     // v 4.70 - now it does send them but only the first time. To maintain
 674     // compatible behaviour and also in order to not have surprises with the
 675     // future versions, don't rely on this and still do everything ourselves.
 676     // To avoid that the messages be sent twice when the item is expanded for
 677     // the first time we must clear TVIS_EXPANDEDONCE style manually.
 678
 679     wxTreeViewItem tvItem(item, TVIF_STATE, TVIS_EXPANDEDONCE);
 680     tvItem.state = 0;
 681     DoSetItem(&tvItem);
 682
 683     if ( TreeView_Expand(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item, flag) != 0 )
 684     {
 685         wxTreeEvent event(wxEVT_NULL, m_windowId);
 686         event.m_item = item;
 687
 688         bool isExpanded = IsExpanded(item);
 689
 690         event.SetEventObject(this);
 691
 692         // FIXME return value of {EXPAND|COLLAPS}ING event handler is discarded
 693         event.SetEventType(g_events[isExpanded][TRUE]);
 694         GetEventHandler()->ProcessEvent(event);
 695
 696         event.SetEventType(g_events[isExpanded][FALSE]);
 697         GetEventHandler()->ProcessEvent(event);
 698     }
 699     //else: change didn't took place, so do nothing at all
 700 }
 701
 702 void wxTreeCtrl::Expand(const wxTreeItemId& item)
 703 {
 704     DoExpand(item, TVE_EXPAND);
 705 }
 706
 707 void wxTreeCtrl::Collapse(const wxTreeItemId& item)
 708 {
 709     DoExpand(item, TVE_COLLAPSE);
 710 }
 711
 712 void wxTreeCtrl::CollapseAndReset(const wxTreeItemId& item)
 713 {
 714     DoExpand(item, TVE_COLLAPSE | TVE_COLLAPSERESET);
 715 }
 716
 717 void wxTreeCtrl::Toggle(const wxTreeItemId& item)
 718 {
 719     DoExpand(item, TVE_TOGGLE);
 720 }
 721
 722 void wxTreeCtrl::ExpandItem(const wxTreeItemId& item, int action)
 723 {
 724         DoExpand(item, action);
 725 }
 726
 727 void wxTreeCtrl::Unselect()
 728 {
 729     SelectItem(wxTreeItemId((WXHTREEITEM) 0));
 730 }
 731
 732 void wxTreeCtrl::SelectItem(const wxTreeItemId& item)
 733 {
 734     // inspite of the docs (MSDN Jan 99 edition), we don't seem to receive
 735     // the notification from the control (i.e. TVN_SELCHANG{ED|ING}), so
 736     // send them ourselves
 737
 738     wxTreeEvent event(wxEVT_NULL, m_windowId);
 739     event.m_item = item;
 740     event.SetEventObject(this);
 741
 742     event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGING);
 743     if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
 744     {
 745         if ( !TreeView_SelectItem(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item) )
 746         {
 747             wxLogLastError("TreeView_SelectItem");
 748         }
 749         else
 750         {
 751             event.SetEventType(wxEVT_COMMAND_TREE_SEL_CHANGED);
 752             (void)GetEventHandler()->ProcessEvent(event);
 753         }
 754     }
 755     //else: program vetoed the change
 756 }
 757
 758 void wxTreeCtrl::EnsureVisible(const wxTreeItemId& item)
 759 {
 760     // no error return
 761     TreeView_EnsureVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item);
 762 }
 763
 764 void wxTreeCtrl::ScrollTo(const wxTreeItemId& item)
 765 {
 766     if ( !TreeView_SelectSetFirstVisible(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item) )
 767     {
 768         wxLogLastError("TreeView_SelectSetFirstVisible");
 769     }
 770 }
 771
 772 wxTextCtrl* wxTreeCtrl::GetEditControl() const
 773 {
 774     return m_textCtrl;
 775 }
 776
 777 void wxTreeCtrl::DeleteTextCtrl()
 778 {
 779     if ( m_textCtrl )
 780     {
 781         m_textCtrl->UnsubclassWin();
 782         m_textCtrl->SetHWND(0);
 783         delete m_textCtrl;
 784         m_textCtrl = NULL;
 785     }
 786 }
 787
 788 wxTextCtrl* wxTreeCtrl::EditLabel(const wxTreeItemId& item,
 789                                   wxClassInfo* textControlClass)
 790 {
 791     wxASSERT( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)) );
 792
 793     HWND hWnd = (HWND) TreeView_EditLabel(GetHwnd(), (HTREEITEM) (WXHTREEITEM) item);
 794
 795     // this is not an error - the TVN_BEGINLABELEDIT handler might have
 796     // returned FALSE
 797     if ( !hWnd )
 798     {
 799         return NULL;
 800     }
 801
 802     DeleteTextCtrl();
 803
 804     m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
 805     m_textCtrl->SetHWND((WXHWND)hWnd);
 806     m_textCtrl->SubclassWin((WXHWND)hWnd);
 807
 808     return m_textCtrl;
 809 }
 810
 811 // End label editing, optionally cancelling the edit
 812 void wxTreeCtrl::EndEditLabel(const wxTreeItemId& item, bool discardChanges)
 813 {
 814     TreeView_EndEditLabelNow(GetHwnd(), discardChanges);
 815
 816     DeleteTextCtrl();
 817 }
 818
 819 wxTreeItemId wxTreeCtrl::HitTest(const wxPoint& point, int& flags)
 820 {
 821     TV_HITTESTINFO hitTestInfo;
 822     hitTestInfo.pt.x = (int)point.x;
 823     hitTestInfo.pt.y = (int)point.y;
 824
 825     TreeView_HitTest(GetHwnd(), &hitTestInfo);
 826
 827     flags = 0;
 828
 829     // avoid repetition
 830     #define TRANSLATE_FLAG(flag) if ( hitTestInfo.flags & TVHT_##flag ) \
 831                                     flags |= wxTREE_HITTEST_##flag
 832
 833     TRANSLATE_FLAG(ABOVE);
 834     TRANSLATE_FLAG(BELOW);
 835     TRANSLATE_FLAG(NOWHERE);
 836     TRANSLATE_FLAG(ONITEMBUTTON);
 837     TRANSLATE_FLAG(ONITEMICON);
 838     TRANSLATE_FLAG(ONITEMINDENT);
 839     TRANSLATE_FLAG(ONITEMLABEL);
 840     TRANSLATE_FLAG(ONITEMRIGHT);
 841     TRANSLATE_FLAG(ONITEMSTATEICON);
 842     TRANSLATE_FLAG(TOLEFT);
 843     TRANSLATE_FLAG(TORIGHT);
 844
 845     #undef TRANSLATE_FLAG
 846
 847     return wxTreeItemId((WXHTREEITEM) hitTestInfo.hItem);
 848 }
 849
 850 bool wxTreeCtrl::GetBoundingRect(const wxTreeItemId& item,
 851                                  wxRect& rect,
 852                                  bool textOnly) const
 853 {
 854     RECT rc;
 855     if ( TreeView_GetItemRect(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item,
 856                               &rc, textOnly) )
 857     {
 858         rect = wxRect(wxPoint(rc.left, rc.top), wxPoint(rc.right, rc.bottom));
 859
 860         return TRUE;
 861     }
 862     else
 863     {
 864         // couldn't retrieve rect: for example, item isn't visible
 865         return FALSE;
 866     }
 867 }
 868
 869 // ----------------------------------------------------------------------------
 870 // sorting stuff
 871 // ----------------------------------------------------------------------------
 872
 873 static int CALLBACK TreeView_CompareCallback(wxTreeItemData *pItem1,
 874                                              wxTreeItemData *pItem2,
 875                                              wxTreeCtrl *tree)
 876 {
 877     wxCHECK_MSG( pItem1 && pItem2, 0,
 878                  _T("sorting tree without data doesn't make sense") );
 879
 880     return tree->OnCompareItems(pItem1->GetId(), pItem2->GetId());
 881 }
 882
 883 int wxTreeCtrl::OnCompareItems(const wxTreeItemId& item1,
 884                                const wxTreeItemId& item2)
 885 {
 886     return wxStrcmp(GetItemText(item1), GetItemText(item2));
 887 }
 888
 889 void wxTreeCtrl::SortChildren(const wxTreeItemId& item)
 890 {
 891     // rely on the fact that TreeView_SortChildren does the same thing as our
 892     // default behaviour, i.e. sorts items alphabetically and so call it
 893     // directly if we're not in derived class (much more efficient!)
 894     if ( GetClassInfo() == CLASSINFO(wxTreeCtrl) )
 895     {
 896         TreeView_SortChildren(GetHwnd(), (HTREEITEM)(WXHTREEITEM)item, 0);
 897     }
 898     else
 899     {
 900         TV_SORTCB tvSort;
 901         tvSort.hParent = (HTREEITEM)(WXHTREEITEM)item;
 902         tvSort.lpfnCompare = (PFNTVCOMPARE)TreeView_CompareCallback;
 903         tvSort.lParam = (LPARAM)this;
 904         TreeView_SortChildrenCB(GetHwnd(), &tvSort, 0 /* reserved */);
 905     }
 906 }
 907
 908 // ----------------------------------------------------------------------------
 909 // implementation
 910 // ----------------------------------------------------------------------------
 911
 912 bool wxTreeCtrl::MSWCommand(WXUINT cmd, WXWORD id)
 913 {
 914     if ( cmd == EN_UPDATE )
 915     {
 916         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
 917         event.SetEventObject( this );
 918         ProcessCommand(event);
 919     }
 920     else if ( cmd == EN_KILLFOCUS )
 921     {
 922         wxCommandEvent event(wxEVT_KILL_FOCUS, id);
 923         event.SetEventObject( this );
 924         ProcessCommand(event);
 925     }
 926     else
 927     {
 928         // nothing done
 929         return FALSE;
 930     }
 931
 932     // command processed
 933     return TRUE;
 934 }
 935
 936 // process WM_NOTIFY Windows message
 937 bool wxTreeCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
 938 {
 939     wxTreeEvent event(wxEVT_NULL, m_windowId);
 940     wxEventType eventType = wxEVT_NULL;
 941     NMHDR *hdr = (NMHDR *)lParam;
 942
 943     switch ( hdr->code )
 944     {
 945         case TVN_BEGINDRAG:
 946             eventType = wxEVT_COMMAND_TREE_BEGIN_DRAG;
 947             // fall through
 948
 949         case TVN_BEGINRDRAG:
 950             {
 951                 if ( eventType == wxEVT_NULL )
 952                     eventType = wxEVT_COMMAND_TREE_BEGIN_RDRAG;
 953                 //else: left drag, already set above
 954
 955                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 956
 957                 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
 958                 event.m_pointDrag = wxPoint(tv->ptDrag.x, tv->ptDrag.y);
 959                 break;
 960             }
 961
 962         case TVN_BEGINLABELEDIT:
 963             {
 964                 eventType = wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
 965                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 966
 967                 event.m_item = (WXHTREEITEM) info->item.hItem;
 968                 event.m_label = info->item.pszText;
 969                 break;
 970             }
 971
 972         case TVN_DELETEITEM:
 973             {
 974                 eventType = wxEVT_COMMAND_TREE_DELETE_ITEM;
 975                 NM_TREEVIEW *tv = (NM_TREEVIEW *)lParam;
 976
 977                 event.m_item = (WXHTREEITEM) tv->itemOld.hItem;
 978                 break;
 979             }
 980
 981         case TVN_ENDLABELEDIT:
 982             {
 983                 eventType = wxEVT_COMMAND_TREE_END_LABEL_EDIT;
 984                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
 985
 986                 event.m_item = (WXHTREEITEM)info->item.hItem;
 987                 event.m_label = info->item.pszText;
 988                 break;
 989             }
 990
 991         case TVN_GETDISPINFO:
 992             eventType = wxEVT_COMMAND_TREE_GET_INFO;
 993             // fall through
 994
 995         case TVN_SETDISPINFO:
 996             {
 997                 if ( eventType == wxEVT_NULL )
 998                     eventType = wxEVT_COMMAND_TREE_SET_INFO;
 999                 //else: get, already set above
1000
1001                 TV_DISPINFO *info = (TV_DISPINFO *)lParam;
1002
1003                 event.m_item = (WXHTREEITEM) info->item.hItem;
1004                 break;
1005             }
1006
1007         case TVN_ITEMEXPANDING:
1008             event.m_code = FALSE;
1009             // fall through
1010
1011         case TVN_ITEMEXPANDED:
1012             {
1013                 NM_TREEVIEW* tv = (NM_TREEVIEW*)lParam;
1014
1015                 bool expand = FALSE;
1016                 switch ( tv->action )
1017                 {
1018                     case TVE_EXPAND:
1019                         expand = TRUE;
1020                         break;
1021
1022                     case TVE_COLLAPSE:
1023                         expand = FALSE;
1024                         break;
1025
1026                     default:
1027                         wxLogDebug(_T("unexpected code %d in TVN_ITEMEXPAND "
1028                                       "message"), tv->action);
1029                 }
1030
1031                 bool ing = (hdr->code == TVN_ITEMEXPANDING);
1032                 eventType = g_events[expand][ing];
1033
1034                 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
1035                 break;
1036             }
1037
1038         case TVN_KEYDOWN:
1039             {
1040                 eventType = wxEVT_COMMAND_TREE_KEY_DOWN;
1041                 TV_KEYDOWN *info = (TV_KEYDOWN *)lParam;
1042
1043                 event.m_code = wxCharCodeMSWToWX(info->wVKey);
1044
1045                 // a separate event for this case
1046                 if ( info->wVKey == VK_SPACE || info->wVKey == VK_RETURN )
1047                 {
1048                     wxTreeEvent event2(wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
1049                                        m_windowId);
1050                     event2.SetEventObject(this);
1051
1052                     GetEventHandler()->ProcessEvent(event2);
1053                 }
1054                 break;
1055             }
1056
1057         case TVN_SELCHANGED:
1058             eventType = wxEVT_COMMAND_TREE_SEL_CHANGED;
1059             // fall through
1060
1061         case TVN_SELCHANGING:
1062             {
1063                 if ( eventType == wxEVT_NULL )
1064                     eventType = wxEVT_COMMAND_TREE_SEL_CHANGING;
1065                 //else: already set above
1066
1067                 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
1068
1069                 event.m_item = (WXHTREEITEM) tv->itemNew.hItem;
1070                 event.m_itemOld = (WXHTREEITEM) tv->itemOld.hItem;
1071                 break;
1072             }
1073
1074         default:
1075             return wxControl::MSWOnNotify(idCtrl, lParam, result);
1076     }
1077
1078     event.SetEventObject(this);
1079     event.SetEventType(eventType);
1080
1081     bool processed = GetEventHandler()->ProcessEvent(event);
1082
1083     // post processing
1084     switch ( hdr->code )
1085     {
1086         case TVN_DELETEITEM:
1087             {
1088                 // NB: we might process this message using wxWindows event
1089                 //     tables, but due to overhead of wxWin event system we
1090                 //     prefer to do it here ourself (otherwise deleting a tree
1091                 //     with many items is just too slow)
1092                 NM_TREEVIEW* tv = (NM_TREEVIEW *)lParam;
1093                 wxTreeItemData *data = (wxTreeItemData *)tv->itemOld.lParam;
1094                 delete data; // may be NULL, ok
1095
1096                 processed = TRUE; // Make sure we don't get called twice
1097             }
1098             break;
1099
1100         case TVN_BEGINLABELEDIT:
1101             // return TRUE to cancel label editing
1102             *result = !event.IsAllowed();
1103             break;
1104
1105         case TVN_ENDLABELEDIT:
1106             // return TRUE to set the label to the new string
1107             *result = event.IsAllowed();
1108
1109             // ensure that we don't have the text ctrl which is going to be
1110             // deleted any more
1111             DeleteTextCtrl();
1112             break;
1113
1114         case TVN_SELCHANGING:
1115         case TVN_ITEMEXPANDING:
1116             // return TRUE to prevent the action from happening
1117             *result = !event.IsAllowed();
1118             break;
1119
1120         //default:
1121             // for the other messages the return value is ignored and there is
1122             // nothing special to do
1123     }
1124
1125     return processed;
1126 }
1127
1128 // ----------------------------------------------------------------------------
1129 // Tree event
1130 // ----------------------------------------------------------------------------
1131
1132 IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxNotifyEvent)
1133
1134 wxTreeEvent::wxTreeEvent(wxEventType commandType, int id)
1135            : wxNotifyEvent(commandType, id)
1136 {
1137     m_code = 0;
1138     m_itemOld = 0;
1139 }
1140
1141 #endif // __WIN95__
1142