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_TREEBOOK_PAGE_CHANGING,  wxBookCtrlEvent );
  51 wxDEFINE_EVENT( wxEVT_TREEBOOK_PAGE_CHANGED,   wxBookCtrlEvent );
  52 wxDEFINE_EVENT( wxEVT_TREEBOOK_NODE_COLLAPSED, wxBookCtrlEvent );
  53 wxDEFINE_EVENT( wxEVT_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::DoSetSelection(size_t pagePos, int flags)
 560 {
 561     wxCHECK_MSG( IS_VALID_PAGE(pagePos), wxNOT_FOUND,
 562                  wxT("invalid page index in wxListbook::DoSetSelection()") );
 563     wxASSERT_MSG( GetPageCount() == DoInternalGetPageCount(),
 564                   wxT("wxTreebook logic error: m_treeIds and m_pages not in sync!"));
 565
 566     wxBookCtrlEvent event(wxEVT_TREEBOOK_PAGE_CHANGING, m_windowId);
 567     const int oldSel = m_selection;
 568     wxTreeCtrl *tree = GetTreeCtrl();
 569     bool allowed = false;
 570
 571     if (flags & SetSelection_SendEvent)
 572     {
 573         event.SetEventObject(this);
 574         event.SetSelection(pagePos);
 575         event.SetOldSelection(m_selection);
 576
 577         // don't send the event if the old and new pages are the same; do send it
 578         // otherwise and be prepared for it to be vetoed
 579         allowed = (int)pagePos == m_selection ||
 580                   !GetEventHandler()->ProcessEvent(event) ||
 581                   event.IsAllowed();
 582     }
 583
 584     if ( !(flags & SetSelection_SendEvent) || allowed )
 585     {
 586         // hide the previously shown page
 587         wxTreebookPage * const oldPage = DoGetCurrentPage();
 588         if ( oldPage )
 589             oldPage->Hide();
 590
 591         // then show the new one
 592         m_selection = pagePos;
 593         wxTreebookPage *page = wxBookCtrlBase::GetPage(m_selection);
 594         if ( !page )
 595         {
 596             // find the next page suitable to be shown: the first (grand)child
 597             // of this one with a non-NULL associated page
 598             wxTreeItemId childId = m_treeIds[pagePos];
 599             int actualPagePos = pagePos;
 600             while ( !page && childId.IsOk() )
 601             {
 602                 wxTreeItemIdValue cookie;
 603                 childId = tree->GetFirstChild( childId, cookie );
 604                 if ( childId.IsOk() )
 605                 {
 606                     page = wxBookCtrlBase::GetPage(++actualPagePos);
 607                 }
 608             }
 609
 610             m_actualSelection = page ? actualPagePos : m_selection;
 611         }
 612
 613         if ( page )
 614             page->Show();
 615
 616         tree->SelectItem(DoInternalGetPage(pagePos));
 617
 618         if (flags & SetSelection_SendEvent)
 619         {
 620             // notify about the (now completed) page change
 621             event.SetEventType(wxEVT_TREEBOOK_PAGE_CHANGED);
 622             (void)GetEventHandler()->ProcessEvent(event);
 623         }
 624     }
 625     else if ( (flags & SetSelection_SendEvent) && !allowed) // page change vetoed
 626     {
 627         // tree selection might have already had changed
 628         if ( oldSel != wxNOT_FOUND )
 629             tree->SelectItem(DoInternalGetPage(oldSel));
 630     }
 631
 632     return oldSel;
 633 }
 634
 635 wxTreebookPage *wxTreebook::DoGetCurrentPage() const
 636 {
 637     if ( m_selection == wxNOT_FOUND )
 638         return NULL;
 639
 640     wxTreebookPage *page = wxBookCtrlBase::GetPage(m_selection);
 641     if ( !page && m_actualSelection != wxNOT_FOUND )
 642     {
 643         page = wxBookCtrlBase::GetPage(m_actualSelection);
 644     }
 645
 646     return page;
 647 }
 648
 649 void wxTreebook::SetImageList(wxImageList *imageList)
 650 {
 651     wxBookCtrlBase::SetImageList(imageList);
 652     GetTreeCtrl()->SetImageList(imageList);
 653 }
 654
 655 void wxTreebook::AssignImageList(wxImageList *imageList)
 656 {
 657     wxBookCtrlBase::AssignImageList(imageList);
 658     GetTreeCtrl()->SetImageList(imageList);
 659 }
 660
 661 // ----------------------------------------------------------------------------
 662 // event handlers
 663 // ----------------------------------------------------------------------------
 664
 665 void wxTreebook::OnTreeSelectionChange(wxTreeEvent& event)
 666 {
 667     if ( event.GetEventObject() != m_bookctrl )
 668     {
 669         event.Skip();
 670         return;
 671     }
 672
 673     wxTreeItemId newId = event.GetItem();
 674
 675     if ( (m_selection == wxNOT_FOUND &&
 676                 (!newId.IsOk() || newId == GetTreeCtrl()->GetRootItem())) ||
 677             (m_selection != wxNOT_FOUND && newId == m_treeIds[m_selection]) )
 678     {
 679         // this event can only come when we modify the tree selection ourselves
 680         // so we should simply ignore it
 681         return;
 682     }
 683
 684     int newPos = DoInternalFindPageById(newId);
 685
 686     if ( newPos != wxNOT_FOUND )
 687         SetSelection( newPos );
 688 }
 689
 690 void wxTreebook::OnTreeNodeExpandedCollapsed(wxTreeEvent & event)
 691 {
 692     if ( event.GetEventObject() != m_bookctrl )
 693     {
 694         event.Skip();
 695         return;
 696     }
 697
 698     wxTreeItemId nodeId = event.GetItem();
 699     if ( !nodeId.IsOk() || nodeId == GetTreeCtrl()->GetRootItem() )
 700         return;
 701     int pagePos = DoInternalFindPageById(nodeId);
 702     wxCHECK_RET( pagePos != wxNOT_FOUND, wxT("Internal problem in wxTreebook!..") );
 703
 704     wxBookCtrlEvent ev(GetTreeCtrl()->IsExpanded(nodeId)
 705             ? wxEVT_TREEBOOK_NODE_EXPANDED
 706             : wxEVT_TREEBOOK_NODE_COLLAPSED,
 707         m_windowId);
 708
 709     ev.SetSelection(pagePos);
 710     ev.SetOldSelection(pagePos);
 711     ev.SetEventObject(this);
 712
 713     GetEventHandler()->ProcessEvent(ev);
 714 }
 715
 716 // ----------------------------------------------------------------------------
 717 // wxTreebook geometry management
 718 // ----------------------------------------------------------------------------
 719
 720 int wxTreebook::HitTest(wxPoint const & pt, long * flags) const
 721 {
 722     int pagePos = wxNOT_FOUND;
 723
 724     if ( flags )
 725         *flags = wxBK_HITTEST_NOWHERE;
 726
 727     // convert from wxTreebook coorindates to wxTreeCtrl ones
 728     const wxTreeCtrl * const tree = GetTreeCtrl();
 729     const wxPoint treePt = tree->ScreenToClient(ClientToScreen(pt));
 730
 731     // is it over the tree?
 732     if ( wxRect(tree->GetSize()).Contains(treePt) )
 733     {
 734         int flagsTree;
 735         wxTreeItemId id = tree->HitTest(treePt, flagsTree);
 736
 737         if ( id.IsOk() && (flagsTree & wxTREE_HITTEST_ONITEM) )
 738         {
 739             pagePos = DoInternalFindPageById(id);
 740         }
 741
 742         if ( flags )
 743         {
 744             if ( pagePos != wxNOT_FOUND )
 745                 *flags = 0;
 746
 747             if ( flagsTree & (wxTREE_HITTEST_ONITEMBUTTON |
 748                               wxTREE_HITTEST_ONITEMICON |
 749                               wxTREE_HITTEST_ONITEMSTATEICON) )
 750                 *flags |= wxBK_HITTEST_ONICON;
 751
 752             if ( flagsTree & wxTREE_HITTEST_ONITEMLABEL )
 753                 *flags |= wxBK_HITTEST_ONLABEL;
 754         }
 755     }
 756     else // not over the tree
 757     {
 758         if ( flags && GetPageRect().Contains( pt ) )
 759             *flags |= wxBK_HITTEST_ONPAGE;
 760     }
 761
 762     return pagePos;
 763 }
 764
 765 #endif // wxUSE_TREEBOOK