src/generic/treebkg.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/treebkg.cpp
   3 // Purpose:     generic implementation of wxTreebook
   4 // Author:      Evgeniy Tarassov, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     2005-09-15
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2005 Vadim Zeitlin <vadim@wxwidgets.org>
   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_TREEBOOK
  28
  29 #include "wx/treebook.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/settings.h"
  33 #endif
  34
  35 #include "wx/imaglist.h"
  36
  37 // ----------------------------------------------------------------------------
  38 // various wxWidgets macros
  39 // ----------------------------------------------------------------------------
  40
  41 // check that the page index is valid
  42 #define IS_VALID_PAGE(nPage) ((nPage) < DoInternalGetPageCount())
  43
  44 // ----------------------------------------------------------------------------
  45 // event table
  46 // ----------------------------------------------------------------------------
  47
  48 IMPLEMENT_DYNAMIC_CLASS(wxTreebook, wxBookCtrlBase)
  49
  50 wxDEFINE_EVENT( wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING,  wxBookCtrlEvent );
  51 wxDEFINE_EVENT( wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED,   wxBookCtrlEvent );
  52 wxDEFINE_EVENT( wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED, wxBookCtrlEvent );
  53 wxDEFINE_EVENT( wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED,  wxBookCtrlEvent );
  54
  55 BEGIN_EVENT_TABLE(wxTreebook, wxBookCtrlBase)
  56     EVT_TREE_SEL_CHANGED   (wxID_ANY, wxTreebook::OnTreeSelectionChange)
  57     EVT_TREE_ITEM_EXPANDED (wxID_ANY, wxTreebook::OnTreeNodeExpandedCollapsed)
  58     EVT_TREE_ITEM_COLLAPSED(wxID_ANY, wxTreebook::OnTreeNodeExpandedCollapsed)
  59 END_EVENT_TABLE()
  60
  61 // ============================================================================
  62 // wxTreebook implementation
  63 // ============================================================================
  64
  65 // ----------------------------------------------------------------------------
  66 // wxTreebook creation
  67 // ----------------------------------------------------------------------------
  68
  69 void wxTreebook::Init()
  70 {
  71     m_selection =
  72     m_actualSelection = wxNOT_FOUND;
  73 }
  74
  75 bool
  76 wxTreebook::Create(wxWindow *parent,
  77                    wxWindowID id,
  78                    const wxPoint& pos,
  79                    const wxSize& size,
  80                    long style,
  81                    const wxString& name)
  82 {
  83     // Check the style flag to have either wxTBK_RIGHT or wxTBK_LEFT
  84     if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
  85     {
  86         style |= wxBK_LEFT;
  87     }
  88     style |= wxTAB_TRAVERSAL;
  89
  90     // no border for this control, it doesn't look nice together with the tree
  91     style &= ~wxBORDER_MASK;
  92     style |= wxBORDER_NONE;
  93
  94     if ( !wxControl::Create(parent, id, pos, size,
  95                             style, wxDefaultValidator, name) )
  96         return false;
  97
  98     m_bookctrl = new wxTreeCtrl
  99                  (
 100                     this,
 101                     wxID_ANY,
 102                     wxDefaultPosition,
 103                     wxDefaultSize,
 104                     wxBORDER_THEME |
 105                     wxTR_DEFAULT_STYLE |
 106                     wxTR_HIDE_ROOT |
 107                     wxTR_SINGLE
 108                  );
 109     GetTreeCtrl()->SetQuickBestSize(false); // do full size calculation
 110     GetTreeCtrl()->AddRoot(wxEmptyString); // label doesn't matter, it's hidden
 111
 112 #ifdef __WXMSW__
 113     // We need to add dummy size event to force possible scrollbar hiding
 114     wxSizeEvent evt;
 115     GetEventHandler()->AddPendingEvent(evt);
 116 #endif
 117
 118     return true;
 119 }
 120
 121
 122 // insert a new page just before the pagePos
 123 bool wxTreebook::InsertPage(size_t pagePos,
 124                             wxWindow *page,
 125                             const wxString& text,
 126                             bool bSelect,
 127                             int imageId)
 128 {
 129     return DoInsertPage(pagePos, page, text, bSelect, imageId);
 130 }
 131
 132 bool wxTreebook::InsertSubPage(size_t pagePos,
 133                                wxWindow *page,
 134                                const wxString& text,
 135                                bool bSelect,
 136                                int imageId)
 137 {
 138     return DoInsertSubPage(pagePos, page, text, bSelect, imageId);
 139 }
 140
 141 bool wxTreebook::AddPage(wxWindow *page, const wxString& text, bool bSelect,
 142                          int imageId)
 143 {
 144     return DoInsertPage(m_treeIds.GetCount(), page, text, bSelect, imageId);
 145 }
 146
 147 // insertion time is linear to the number of top-pages
 148 bool wxTreebook::AddSubPage(wxWindow *page, const wxString& text, bool bSelect, int imageId)
 149 {
 150     return DoAddSubPage(page, text, bSelect, imageId);
 151 }
 152
 153
 154 bool wxTreebook::DoInsertPage(size_t pagePos,
 155                               wxWindow *page,
 156                               const wxString& text,
 157                               bool bSelect,
 158                               int imageId)
 159 {
 160     wxCHECK_MSG( pagePos <= DoInternalGetPageCount(), false,
 161                         wxT("Invalid treebook page position") );
 162
 163     if ( !wxBookCtrlBase::InsertPage(pagePos, page, text, bSelect, imageId) )
 164         return false;
 165
 166     wxTreeCtrl *tree = GetTreeCtrl();
 167     wxTreeItemId newId;
 168     if ( pagePos == DoInternalGetPageCount() )
 169     {
 170         // append the page to the end
 171         wxTreeItemId rootId = tree->GetRootItem();
 172
 173         newId = tree->AppendItem(rootId, text, imageId);
 174     }
 175     else // insert the new page before the given one
 176     {
 177         wxTreeItemId nodeId = m_treeIds[pagePos];
 178
 179         wxTreeItemId previousId = tree->GetPrevSibling(nodeId);
 180         wxTreeItemId parentId = tree->GetItemParent(nodeId);
 181
 182         if ( previousId.IsOk() )
 183         {
 184             // insert before the sibling - previousId
 185             newId = tree->InsertItem(parentId, previousId, text, imageId);
 186         }
 187         else // no prev siblings -- insert as a first child
 188         {
 189             wxASSERT_MSG( parentId.IsOk(), wxT( "Tree has no root node?" ) );
 190
 191             newId = tree->PrependItem(parentId, text, imageId);
 192         }
 193     }
 194
 195     if ( !newId.IsOk() )
 196     {
 197         //something wrong -> cleaning and returning with false
 198         (void)wxBookCtrlBase::DoRemovePage(pagePos);
 199
 200         wxFAIL_MSG( wxT("Failed to insert treebook page") );
 201         return false;
 202     }
 203
 204     DoInternalAddPage(pagePos, page, newId);
 205
 206     DoUpdateSelection(bSelect, pagePos);
 207
 208     return true;
 209 }
 210
 211 bool wxTreebook::DoAddSubPage(wxWindow *page, const wxString& text, bool bSelect, int imageId)
 212 {
 213     wxTreeCtrl *tree = GetTreeCtrl();
 214
 215     wxTreeItemId rootId = tree->GetRootItem();
 216
 217     wxTreeItemId lastNodeId = tree->GetLastChild(rootId);
 218
 219     wxCHECK_MSG( lastNodeId.IsOk(), false,
 220                         wxT("Can't insert sub page when there are no pages") );
 221
 222     // now calculate its position (should we save/update it too?)
 223     size_t newPos = tree->GetCount() -
 224                         (tree->GetChildrenCount(lastNodeId, true) + 1);
 225
 226     return DoInsertSubPage(newPos, page, text, bSelect, imageId);
 227 }
 228
 229 bool wxTreebook::DoInsertSubPage(size_t pagePos,
 230                                  wxTreebookPage *page,
 231                                  const wxString& text,
 232                                  bool bSelect,
 233                                  int imageId)
 234 {
 235     wxTreeItemId parentId = DoInternalGetPage(pagePos);
 236     wxCHECK_MSG( parentId.IsOk(), false, wxT("invalid tree item") );
 237
 238     wxTreeCtrl *tree = GetTreeCtrl();
 239
 240     size_t newPos = pagePos + tree->GetChildrenCount(parentId, true) + 1;
 241     wxASSERT_MSG( newPos <= DoInternalGetPageCount(),
 242                     wxT("Internal error in tree insert point calculation") );
 243
 244     if ( !wxBookCtrlBase::InsertPage(newPos, page, text, bSelect, imageId) )
 245         return false;
 246
 247     wxTreeItemId newId = tree->AppendItem(parentId, text, imageId);
 248
 249     if ( !newId.IsOk() )
 250     {
 251         (void)wxBookCtrlBase::DoRemovePage(newPos);
 252
 253         wxFAIL_MSG( wxT("Failed to insert treebook page") );
 254         return false;
 255     }
 256
 257     DoInternalAddPage(newPos, page, newId);
 258
 259     DoUpdateSelection(bSelect, newPos);
 260
 261     return true;
 262 }
 263
 264 bool wxTreebook::DeletePage(size_t pagePos)
 265 {
 266     wxCHECK_MSG( IS_VALID_PAGE(pagePos), false, wxT("Invalid tree index") );
 267
 268     wxTreebookPage *oldPage = DoRemovePage(pagePos);
 269     if ( !oldPage )
 270         return false;
 271
 272     delete oldPage;
 273
 274     return true;
 275 }
 276
 277 wxTreebookPage *wxTreebook::DoRemovePage(size_t pagePos)
 278 {
 279     wxTreeItemId pageId = DoInternalGetPage(pagePos);
 280     wxCHECK_MSG( pageId.IsOk(), NULL, wxT("Invalid tree index") );
 281
 282     wxTreebookPage * oldPage = GetPage(pagePos);
 283     wxTreeCtrl *tree = GetTreeCtrl();
 284
 285     size_t subCount = tree->GetChildrenCount(pageId, true);
 286     wxASSERT_MSG ( IS_VALID_PAGE(pagePos + subCount),
 287                         wxT("Internal error in wxTreebook::DoRemovePage") );
 288
 289     // here we are going to delete ALL the pages in the range
 290     // [pagePos, pagePos + subCount] -- the page and its children
 291
 292     // deleting all the pages from the base class
 293     for ( size_t i = 0; i <= subCount; ++i )
 294     {
 295         wxTreebookPage *page = wxBookCtrlBase::DoRemovePage(pagePos);
 296
 297         // don't delete the page itself though -- it will be deleted in
 298         // DeletePage() when we return
 299         if ( i )
 300         {
 301             delete page;
 302         }
 303     }
 304
 305     DoInternalRemovePageRange(pagePos, subCount);
 306
 307     tree->DeleteChildren( pageId );
 308     tree->Delete( pageId );
 309
 310     return oldPage;
 311 }
 312
 313 bool wxTreebook::DeleteAllPages()
 314 {
 315     wxBookCtrlBase::DeleteAllPages();
 316     m_treeIds.Clear();
 317     m_selection =
 318     m_actualSelection = wxNOT_FOUND;
 319
 320     wxTreeCtrl *tree = GetTreeCtrl();
 321     tree->DeleteChildren(tree->GetRootItem());
 322
 323     return true;
 324 }
 325
 326 void wxTreebook::DoInternalAddPage(size_t newPos,
 327                                    wxTreebookPage *page,
 328                                    wxTreeItemId pageId)
 329 {
 330     wxASSERT_MSG( newPos <= m_treeIds.GetCount(), wxT("Ivalid index passed to wxTreebook::DoInternalAddPage") );
 331
 332     // hide newly inserted page initially (it will be shown when selected)
 333     if ( page )
 334         page->Hide();
 335
 336     if ( newPos == m_treeIds.GetCount() )
 337     {
 338         // append
 339         m_treeIds.Add(pageId);
 340     }
 341     else // insert
 342     {
 343         m_treeIds.Insert(pageId, newPos);
 344
 345         if ( m_selection != wxNOT_FOUND && newPos <= (size_t)m_selection )
 346         {
 347             // selection has been moved one unit toward the end
 348             ++m_selection;
 349             if ( m_actualSelection != wxNOT_FOUND )
 350                 ++m_actualSelection;
 351         }
 352         else if ( m_actualSelection != wxNOT_FOUND &&
 353                     newPos <= (size_t)m_actualSelection )
 354         {
 355             DoSetSelection(m_selection);
 356         }
 357     }
 358 }
 359
 360 void wxTreebook::DoInternalRemovePageRange(size_t pagePos, size_t subCount)
 361 {
 362     // Attention: this function is only for a situation when we delete a node
 363     // with all its children so pagePos is the node's index and subCount is the
 364     // node children count
 365     wxASSERT_MSG( pagePos + subCount < m_treeIds.GetCount(),
 366                     wxT("Ivalid page index") );
 367
 368     wxTreeItemId pageId = m_treeIds[pagePos];
 369
 370     m_treeIds.RemoveAt(pagePos, subCount + 1);
 371
 372     if ( m_selection != wxNOT_FOUND )
 373     {
 374         if ( (size_t)m_selection > pagePos + subCount)
 375         {
 376             // selection is far after the deleted page, so just update the index and move on
 377             m_selection -= 1 + subCount;
 378             if ( m_actualSelection != wxNOT_FOUND)
 379             {
 380                 m_actualSelection -= subCount + 1;
 381             }
 382         }
 383         else if ( (size_t)m_selection >= pagePos )
 384         {
 385             wxTreeCtrl *tree = GetTreeCtrl();
 386
 387             // as selected page is going to be deleted, try to select the next
 388             // sibling if exists, if not then the parent
 389             wxTreeItemId nodeId = tree->GetNextSibling(pageId);
 390
 391             m_selection = wxNOT_FOUND;
 392             m_actualSelection = wxNOT_FOUND;
 393
 394             if ( nodeId.IsOk() )
 395             {
 396                 // selecting next siblings
 397                 tree->SelectItem(nodeId);
 398             }
 399             else // no next sibling, select the parent
 400             {
 401                 wxTreeItemId parentId = tree->GetItemParent(pageId);
 402
 403                 if ( parentId.IsOk() && parentId != tree->GetRootItem() )
 404                 {
 405                     tree->SelectItem(parentId);
 406                 }
 407                 else // parent is root
 408                 {
 409                     // we can't select it as it's hidden
 410                     DoUpdateSelection(false, wxNOT_FOUND);
 411                 }
 412             }
 413         }
 414         else if ( m_actualSelection != wxNOT_FOUND &&
 415                     (size_t)m_actualSelection >= pagePos )
 416         {
 417             // nothing to do -- selection is before the deleted node, but
 418             // actually shown page (the first (sub)child with page != NULL) is
 419             // already deleted
 420             m_actualSelection = m_selection;
 421
 422             // send event as documented
 423             DoSetSelection(m_selection, SetSelection_SendEvent);
 424         }
 425         //else: nothing to do -- selection is before the deleted node
 426     }
 427     else
 428     {
 429         DoUpdateSelection(false, wxNOT_FOUND);
 430     }
 431 }
 432
 433
 434 void wxTreebook::DoUpdateSelection(bool bSelect, int newPos)
 435 {
 436     int newSelPos;
 437     if ( bSelect )
 438     {
 439         newSelPos = newPos;
 440     }
 441     else if ( m_selection == wxNOT_FOUND && DoInternalGetPageCount() > 0 )
 442     {
 443         newSelPos = 0;
 444     }
 445     else
 446     {
 447         newSelPos = wxNOT_FOUND;
 448     }
 449
 450     if ( newSelPos != wxNOT_FOUND )
 451     {
 452         SetSelection((size_t)newSelPos);
 453     }
 454 }
 455
 456 wxTreeItemId wxTreebook::DoInternalGetPage(size_t pagePos) const
 457 {
 458     if ( pagePos >= m_treeIds.GetCount() )
 459     {
 460         // invalid position but ok here, in this internal function, don't assert
 461         // (the caller will do it)
 462         return wxTreeItemId();
 463     }
 464
 465     return m_treeIds[pagePos];
 466 }
 467
 468 int wxTreebook::DoInternalFindPageById(wxTreeItemId pageId) const
 469 {
 470     const size_t count = m_treeIds.GetCount();
 471     for ( size_t i = 0; i < count; ++i )
 472     {
 473         if ( m_treeIds[i] == pageId )
 474             return i;
 475     }
 476
 477     return wxNOT_FOUND;
 478 }
 479
 480 bool wxTreebook::IsNodeExpanded(size_t pagePos) const
 481 {
 482     wxTreeItemId pageId = DoInternalGetPage(pagePos);
 483
 484     wxCHECK_MSG( pageId.IsOk(), false, wxT("invalid tree item") );
 485
 486     return GetTreeCtrl()->IsExpanded(pageId);
 487 }
 488
 489 bool wxTreebook::ExpandNode(size_t pagePos, bool expand)
 490 {
 491     wxTreeItemId pageId = DoInternalGetPage(pagePos);
 492
 493     wxCHECK_MSG( pageId.IsOk(), false, wxT("invalid tree item") );
 494
 495     if ( expand )
 496     {
 497         GetTreeCtrl()->Expand( pageId );
 498     }
 499     else // collapse
 500     {
 501         GetTreeCtrl()->Collapse( pageId );
 502
 503         // rely on the events generated by wxTreeCtrl to update selection
 504     }
 505
 506     return true;
 507 }
 508
 509 int wxTreebook::GetPageParent(size_t pagePos) const
 510 {
 511     wxTreeItemId nodeId = DoInternalGetPage( pagePos );
 512     wxCHECK_MSG( nodeId.IsOk(), wxNOT_FOUND, wxT("Invalid page index spacified!") );
 513
 514     const wxTreeItemId parent = GetTreeCtrl()->GetItemParent( nodeId );
 515
 516     return parent.IsOk() ? DoInternalFindPageById(parent) : wxNOT_FOUND;
 517 }
 518
 519 bool wxTreebook::SetPageText(size_t n, const wxString& strText)
 520 {
 521     wxTreeItemId pageId = DoInternalGetPage(n);
 522
 523     wxCHECK_MSG( pageId.IsOk(), false, wxT("invalid tree item") );
 524
 525     GetTreeCtrl()->SetItemText(pageId, strText);
 526
 527     return true;
 528 }
 529
 530 wxString wxTreebook::GetPageText(size_t n) const
 531 {
 532     wxTreeItemId pageId = DoInternalGetPage(n);
 533
 534     wxCHECK_MSG( pageId.IsOk(), wxString(), wxT("invalid tree item") );
 535
 536     return GetTreeCtrl()->GetItemText(pageId);
 537 }
 538
 539 int wxTreebook::GetPageImage(size_t n) const
 540 {
 541     wxTreeItemId pageId = DoInternalGetPage(n);
 542
 543     wxCHECK_MSG( pageId.IsOk(), wxNOT_FOUND, wxT("invalid tree item") );
 544
 545     return GetTreeCtrl()->GetItemImage(pageId);
 546 }
 547
 548 bool wxTreebook::SetPageImage(size_t n, int imageId)
 549 {
 550     wxTreeItemId pageId = DoInternalGetPage(n);
 551
 552     wxCHECK_MSG( pageId.IsOk(), false, wxT("invalid tree item") );
 553
 554     GetTreeCtrl()->SetItemImage(pageId, imageId);
 555
 556     return true;
 557 }
 558
 559 int wxTreebook::GetSelection() const
 560 {
 561    return m_selection;
 562 }
 563
 564 int wxTreebook::DoSetSelection(size_t pagePos, int flags)
 565 {
 566     wxCHECK_MSG( IS_VALID_PAGE(pagePos), wxNOT_FOUND,
 567                  wxT("invalid page index in wxListbook::DoSetSelection()") );
 568     wxASSERT_MSG( GetPageCount() == DoInternalGetPageCount(),
 569                   wxT("wxTreebook logic error: m_treeIds and m_pages not in sync!"));
 570
 571     wxBookCtrlEvent event(wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING, m_windowId);
 572     const int oldSel = m_selection;
 573     wxTreeCtrl *tree = GetTreeCtrl();
 574     bool allowed = false;
 575
 576     if (flags & SetSelection_SendEvent)
 577     {
 578         event.SetEventObject(this);
 579         event.SetSelection(pagePos);
 580         event.SetOldSelection(m_selection);
 581
 582         // don't send the event if the old and new pages are the same; do send it
 583         // otherwise and be prepared for it to be vetoed
 584         allowed = (int)pagePos == m_selection ||
 585                   !GetEventHandler()->ProcessEvent(event) ||
 586                   event.IsAllowed();
 587     }
 588
 589     if ( !(flags & SetSelection_SendEvent) || allowed )
 590     {
 591         // hide the previously shown page
 592         wxTreebookPage * const oldPage = DoGetCurrentPage();
 593         if ( oldPage )
 594             oldPage->Hide();
 595
 596         // then show the new one
 597         m_selection = pagePos;
 598         wxTreebookPage *page = wxBookCtrlBase::GetPage(m_selection);
 599         if ( !page )
 600         {
 601             // find the next page suitable to be shown: the first (grand)child
 602             // of this one with a non-NULL associated page
 603             wxTreeItemId childId = m_treeIds[pagePos];
 604             int actualPagePos = pagePos;
 605             while ( !page && childId.IsOk() )
 606             {
 607                 wxTreeItemIdValue cookie;
 608                 childId = tree->GetFirstChild( childId, cookie );
 609                 if ( childId.IsOk() )
 610                 {
 611                     page = wxBookCtrlBase::GetPage(++actualPagePos);
 612                 }
 613             }
 614
 615             m_actualSelection = page ? actualPagePos : m_selection;
 616         }
 617
 618         if ( page )
 619             page->Show();
 620
 621         tree->SelectItem(DoInternalGetPage(pagePos));
 622
 623         if (flags & SetSelection_SendEvent)
 624         {
 625             // notify about the (now completed) page change
 626             event.SetEventType(wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED);
 627             (void)GetEventHandler()->ProcessEvent(event);
 628         }
 629     }
 630     else if ( (flags & SetSelection_SendEvent) && !allowed) // page change vetoed
 631     {
 632         // tree selection might have already had changed
 633         if ( oldSel != wxNOT_FOUND )
 634             tree->SelectItem(DoInternalGetPage(oldSel));
 635     }
 636
 637     return oldSel;
 638 }
 639
 640 wxTreebookPage *wxTreebook::DoGetCurrentPage() const
 641 {
 642     if ( m_selection == wxNOT_FOUND )
 643         return NULL;
 644
 645     wxTreebookPage *page = wxBookCtrlBase::GetPage(m_selection);
 646     if ( !page && m_actualSelection != wxNOT_FOUND )
 647     {
 648         page = wxBookCtrlBase::GetPage(m_actualSelection);
 649     }
 650
 651     return page;
 652 }
 653
 654 void wxTreebook::SetImageList(wxImageList *imageList)
 655 {
 656     wxBookCtrlBase::SetImageList(imageList);
 657     GetTreeCtrl()->SetImageList(imageList);
 658 }
 659
 660 void wxTreebook::AssignImageList(wxImageList *imageList)
 661 {
 662     wxBookCtrlBase::AssignImageList(imageList);
 663     GetTreeCtrl()->SetImageList(imageList);
 664 }
 665
 666 // ----------------------------------------------------------------------------
 667 // event handlers
 668 // ----------------------------------------------------------------------------
 669
 670 void wxTreebook::OnTreeSelectionChange(wxTreeEvent& event)
 671 {
 672     if ( event.GetEventObject() != m_bookctrl )
 673     {
 674         event.Skip();
 675         return;
 676     }
 677
 678     wxTreeItemId newId = event.GetItem();
 679
 680     if ( (m_selection == wxNOT_FOUND &&
 681                 (!newId.IsOk() || newId == GetTreeCtrl()->GetRootItem())) ||
 682             (m_selection != wxNOT_FOUND && newId == m_treeIds[m_selection]) )
 683     {
 684         // this event can only come when we modify the tree selection ourselves
 685         // so we should simply ignore it
 686         return;
 687     }
 688
 689     int newPos = DoInternalFindPageById(newId);
 690
 691     if ( newPos != wxNOT_FOUND )
 692         SetSelection( newPos );
 693 }
 694
 695 void wxTreebook::OnTreeNodeExpandedCollapsed(wxTreeEvent & event)
 696 {
 697     if ( event.GetEventObject() != m_bookctrl )
 698     {
 699         event.Skip();
 700         return;
 701     }
 702
 703     wxTreeItemId nodeId = event.GetItem();
 704     if ( !nodeId.IsOk() || nodeId == GetTreeCtrl()->GetRootItem() )
 705         return;
 706     int pagePos = DoInternalFindPageById(nodeId);
 707     wxCHECK_RET( pagePos != wxNOT_FOUND, wxT("Internal problem in wxTreebook!..") );
 708
 709     wxBookCtrlEvent ev(GetTreeCtrl()->IsExpanded(nodeId)
 710             ? wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED
 711             : wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED,
 712         m_windowId);
 713
 714     ev.SetSelection(pagePos);
 715     ev.SetOldSelection(pagePos);
 716     ev.SetEventObject(this);
 717
 718     GetEventHandler()->ProcessEvent(ev);
 719 }
 720
 721 // ----------------------------------------------------------------------------
 722 // wxTreebook geometry management
 723 // ----------------------------------------------------------------------------
 724
 725 int wxTreebook::HitTest(wxPoint const & pt, long * flags) const
 726 {
 727     int pagePos = wxNOT_FOUND;
 728
 729     if ( flags )
 730         *flags = wxBK_HITTEST_NOWHERE;
 731
 732     // convert from wxTreebook coorindates to wxTreeCtrl ones
 733     const wxTreeCtrl * const tree = GetTreeCtrl();
 734     const wxPoint treePt = tree->ScreenToClient(ClientToScreen(pt));
 735
 736     // is it over the tree?
 737     if ( wxRect(tree->GetSize()).Contains(treePt) )
 738     {
 739         int flagsTree;
 740         wxTreeItemId id = tree->HitTest(treePt, flagsTree);
 741
 742         if ( id.IsOk() && (flagsTree & wxTREE_HITTEST_ONITEM) )
 743         {
 744             pagePos = DoInternalFindPageById(id);
 745         }
 746
 747         if ( flags )
 748         {
 749             if ( pagePos != wxNOT_FOUND )
 750                 *flags = 0;
 751
 752             if ( flagsTree & (wxTREE_HITTEST_ONITEMBUTTON |
 753                               wxTREE_HITTEST_ONITEMICON |
 754                               wxTREE_HITTEST_ONITEMSTATEICON) )
 755                 *flags |= wxBK_HITTEST_ONICON;
 756
 757             if ( flagsTree & wxTREE_HITTEST_ONITEMLABEL )
 758                 *flags |= wxBK_HITTEST_ONLABEL;
 759         }
 760     }
 761     else // not over the tree
 762     {
 763         if ( flags && GetPageRect().Contains( pt ) )
 764             *flags |= wxBK_HITTEST_ONPAGE;
 765     }
 766
 767     return pagePos;
 768 }
 769
 770 #endif // wxUSE_TREEBOOK