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