src/univ/notebook.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        univ/notebook.cpp
   3 // Purpose:     wxNotebook implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     01.02.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "univnotebook.h"
  22 #endif
  23
  24 #include "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27     #pragma hdrstop
  28 #endif
  29
  30 #if wxUSE_NOTEBOOK
  31
  32 #include "wx/imaglist.h"
  33 #include "wx/notebook.h"
  34 #include "wx/spinbutt.h"
  35 #include "wx/dcmemory.h"
  36
  37 #include "wx/univ/renderer.h"
  38
  39 // ----------------------------------------------------------------------------
  40 // macros
  41 // ----------------------------------------------------------------------------
  42
  43 #define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
  44
  45 // ----------------------------------------------------------------------------
  46 // constants
  47 // ----------------------------------------------------------------------------
  48
  49 static const size_t INVALID_PAGE = (size_t)-1;
  50
  51 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
  52 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
  53
  54 // ----------------------------------------------------------------------------
  55 // private classes
  56 // ----------------------------------------------------------------------------
  57
  58 class wxNotebookSpinBtn : public wxSpinButton
  59 {
  60 public:
  61     wxNotebookSpinBtn(wxNotebook *nb)
  62         : wxSpinButton(nb, -1,
  63                        wxDefaultPosition, wxDefaultSize,
  64                        nb->IsVertical() ? wxSP_VERTICAL : wxSP_HORIZONTAL)
  65     {
  66         m_nb = nb;
  67     }
  68
  69 protected:
  70     void OnSpin(wxSpinEvent& event)
  71     {
  72         m_nb->PerformAction(wxACTION_NOTEBOOK_GOTO, event.GetPosition());
  73     }
  74
  75 private:
  76     wxNotebook *m_nb;
  77
  78     DECLARE_EVENT_TABLE()
  79 };
  80
  81 BEGIN_EVENT_TABLE(wxNotebookSpinBtn, wxSpinButton)
  82     EVT_SPIN(-1, wxNotebookSpinBtn::OnSpin)
  83 END_EVENT_TABLE()
  84
  85 // ============================================================================
  86 // implementation
  87 // ============================================================================
  88
  89 IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
  90 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
  91
  92 // ----------------------------------------------------------------------------
  93 // wxNotebook creation
  94 // ----------------------------------------------------------------------------
  95
  96 void wxNotebook::Init()
  97 {
  98     m_sel = INVALID_PAGE;
  99
 100     m_heightTab =
 101     m_widthMax = 0;
 102
 103     m_firstVisible =
 104     m_lastVisible =
 105     m_lastFullyVisible = 0;
 106
 107     m_offset = 0;
 108
 109     m_spinbtn = NULL;
 110 }
 111
 112 bool wxNotebook::Create(wxWindow *parent,
 113                         wxWindowID id,
 114                         const wxPoint& pos,
 115                         const wxSize& size,
 116                         long style,
 117                         const wxString& name)
 118 {
 119     if ( !wxControl::Create(parent, id, pos, size, style,
 120                             wxDefaultValidator, name) )
 121         return FALSE;
 122
 123     m_sizePad = GetRenderer()->GetTabPadding();
 124
 125     SetBestSize(size);
 126
 127     CreateInputHandler(wxINP_HANDLER_NOTEBOOK);
 128
 129     return TRUE;
 130 }
 131
 132 // ----------------------------------------------------------------------------
 133 // wxNotebook page titles and images
 134 // ----------------------------------------------------------------------------
 135
 136 wxString wxNotebook::GetPageText(int nPage) const
 137 {
 138     wxCHECK_MSG( IS_VALID_PAGE(nPage), _T(""), _T("invalid notebook page") );
 139
 140     return m_titles[nPage];
 141 }
 142
 143 bool wxNotebook::SetPageText(int nPage, const wxString& strText)
 144 {
 145     wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, _T("invalid notebook page") );
 146
 147     if ( strText != m_titles[nPage] )
 148     {
 149         m_accels[nPage] = FindAccelIndex(strText, &m_titles[nPage]);
 150
 151         if ( FixedSizeTabs() )
 152         {
 153             // it's enough to just reresh this one
 154             RefreshTab(nPage);
 155         }
 156         else // var width tabs
 157         {
 158             // we need to resize the tab to fit the new string
 159             ResizeTab(nPage);
 160         }
 161     }
 162
 163     return TRUE;
 164 }
 165
 166 int wxNotebook::GetPageImage(int nPage) const
 167 {
 168     wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, _T("invalid notebook page") );
 169
 170     return m_images[nPage];
 171 }
 172
 173 bool wxNotebook::SetPageImage(int nPage, int nImage)
 174 {
 175     wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, _T("invalid notebook page") );
 176
 177     wxCHECK_MSG( m_imageList && nImage < m_imageList->GetImageCount(), FALSE,
 178                  _T("invalid image index in SetPageImage()") );
 179
 180     if ( nImage != m_images[nPage] )
 181     {
 182         // if the item didn't have an icon before or, on the contrary, did have
 183         // it but has lost it now, its size will change - but if the icon just
 184         // changes, it won't
 185         bool tabSizeChanges = nImage == -1 || m_images[nPage] == -1;
 186         m_images[nPage] = nImage;
 187
 188         if ( tabSizeChanges )
 189             RefreshAllTabs();
 190         else
 191             RefreshTab(nPage);
 192     }
 193
 194     return TRUE;
 195 }
 196
 197 wxNotebook::~wxNotebook()
 198 {
 199 }
 200
 201 // ----------------------------------------------------------------------------
 202 // wxNotebook page switching
 203 // ----------------------------------------------------------------------------
 204
 205 int wxNotebook::SetSelection(int nPage)
 206 {
 207     wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, _T("invalid notebook page") );
 208
 209     if ( (size_t)nPage == m_sel )
 210     {
 211         // don't do anything if there is nothing to do
 212         return m_sel;
 213     }
 214
 215     // we need to change m_sel first, before calling RefreshTab() below as
 216     // otherwise the previously selected tab wouldn't be redrawn properly under
 217     // wxGTK which calls Refresh() immediately and not during the next event
 218     // loop iteration as wxMSW does and as it should
 219     size_t selOld = m_sel;
 220
 221     m_sel = nPage;
 222
 223     if ( selOld != INVALID_PAGE )
 224     {
 225         RefreshTab(selOld, TRUE /* this tab was selected */);
 226
 227         m_pages[selOld]->Hide();
 228     }
 229
 230     if ( m_sel != INVALID_PAGE ) // this is impossible - but test nevertheless
 231     {
 232         if ( HasSpinBtn() )
 233         {
 234             // keep it in sync
 235             m_spinbtn->SetValue(m_sel);
 236         }
 237
 238         if ( m_sel < m_firstVisible )
 239         {
 240             // selection is to the left of visible part of tabs
 241             ScrollTo(m_sel);
 242         }
 243         else if ( m_sel > m_lastFullyVisible )
 244         {
 245             // selection is to the right of visible part of tabs
 246             ScrollLastTo(m_sel);
 247         }
 248         else // we already see this tab
 249         {
 250             // no need to scroll
 251             RefreshTab(m_sel);
 252         }
 253
 254         m_pages[m_sel]->SetSize(GetPageRect());
 255         m_pages[m_sel]->Show();
 256     }
 257
 258     return m_sel;
 259 }
 260
 261 void wxNotebook::ChangePage(int nPage)
 262 {
 263     wxCHECK_RET( IS_VALID_PAGE(nPage), _T("invalid notebook page") );
 264
 265     if ( (size_t)nPage == m_sel )
 266     {
 267         // nothing to do
 268         return;
 269     }
 270
 271     wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
 272     event.SetSelection(nPage);
 273     event.SetOldSelection(m_sel);
 274     event.SetEventObject(this);
 275     if ( GetEventHandler()->ProcessEvent(event) && !event.IsAllowed() )
 276     {
 277         // program doesn't allow the page change
 278         return;
 279     }
 280
 281     SetSelection(nPage);
 282
 283     event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
 284     GetEventHandler()->ProcessEvent(event);
 285 }
 286
 287 // ----------------------------------------------------------------------------
 288 // wxNotebook pages adding/deleting
 289 // ----------------------------------------------------------------------------
 290
 291 bool wxNotebook::InsertPage(int nPage,
 292                             wxNotebookPage *pPage,
 293                             const wxString& strText,
 294                             bool bSelect,
 295                             int imageId)
 296 {
 297     int nPages = GetPageCount();
 298     wxCHECK_MSG( nPage == nPages || IS_VALID_PAGE(nPage), FALSE,
 299                  _T("invalid notebook page in InsertPage()") );
 300
 301     // modify the data
 302     m_pages.Insert(pPage, nPage);
 303
 304     wxString label;
 305     m_accels.Insert(FindAccelIndex(strText, &label), nPage);
 306     m_titles.Insert(label, nPage);
 307
 308     m_images.Insert(imageId, nPage);
 309
 310     // cache the tab geometry here
 311     wxSize sizeTab = CalcTabSize(nPage);
 312
 313     if ( sizeTab.y > m_heightTab )
 314         m_heightTab = sizeTab.y;
 315
 316     if ( FixedSizeTabs() && sizeTab.x > m_widthMax )
 317         m_widthMax = sizeTab.x;
 318
 319     m_widths.Insert(sizeTab.x, nPage);
 320
 321     // spin button may appear if we didn't have it before - but even if we did,
 322     // its range should change, so update it unconditionally
 323     UpdateSpinBtn();
 324
 325     // if the tab has just appeared, we have to relayout everything, otherwise
 326     // it's enough to just redraw the tabs
 327     if ( nPages == 0 )
 328     {
 329         // always select the first tab to have at least some selection
 330         bSelect = TRUE;
 331
 332         Relayout();
 333     }
 334     else // not the first tab
 335     {
 336         RefreshAllTabs();
 337     }
 338
 339     if ( bSelect )
 340     {
 341         SetSelection(nPage);
 342     }
 343     else // pages added to the notebook are initially hidden
 344     {
 345         pPage->Hide();
 346     }
 347
 348     return TRUE;
 349 }
 350
 351 bool wxNotebook::DeleteAllPages()
 352 {
 353     if ( !wxNotebookBase::DeleteAllPages() )
 354         return FALSE;
 355
 356     // clear the other arrays as well
 357     m_titles.Clear();
 358     m_images.Clear();
 359     m_accels.Clear();
 360     m_widths.Clear();
 361
 362     // it is not valid any longer
 363     m_sel = INVALID_PAGE;
 364
 365     // spin button is not needed any more
 366     UpdateSpinBtn();
 367
 368     Relayout();
 369
 370     return TRUE;
 371 }
 372
 373 wxNotebookPage *wxNotebook::DoRemovePage(int nPage)
 374 {
 375     wxCHECK_MSG( IS_VALID_PAGE(nPage), NULL, _T("invalid notebook page") );
 376
 377     wxNotebookPage *page = m_pages[nPage];
 378     m_pages.RemoveAt(nPage);
 379     m_titles.RemoveAt(nPage);
 380     m_accels.RemoveAt(nPage);
 381     m_widths.RemoveAt(nPage);
 382     m_images.RemoveAt(nPage);
 383
 384     // the spin button might not be needed any more
 385     if ( HasSpinBtn() )
 386     {
 387         UpdateSpinBtn();
 388     }
 389
 390     int count = GetPageCount();
 391     if ( count )
 392     {
 393         if ( m_sel == (size_t)nPage )
 394         {
 395             // avoid sending event to this page which doesn't exist in the
 396             // notebook any more
 397             m_sel = INVALID_PAGE;
 398
 399             SetSelection(nPage == count ? nPage - 1 : nPage);
 400         }
 401         else if ( m_sel > (size_t)nPage )
 402         {
 403             // no need to change selection, just adjust the index
 404             m_sel--;
 405         }
 406     }
 407     else // no more tabs left
 408     {
 409         m_sel = INVALID_PAGE;
 410     }
 411
 412     // have to refresh everything
 413     Relayout();
 414
 415     return page;
 416 }
 417
 418 // ----------------------------------------------------------------------------
 419 // wxNotebook drawing
 420 // ----------------------------------------------------------------------------
 421
 422 void wxNotebook::RefreshCurrent()
 423 {
 424     if ( m_sel != INVALID_PAGE )
 425     {
 426         RefreshTab(m_sel);
 427     }
 428 }
 429
 430 void wxNotebook::RefreshTab(int page, bool forceSelected)
 431 {
 432     wxCHECK_RET( IS_VALID_PAGE(page), _T("invalid notebook page") );
 433
 434     wxRect rect = GetTabRect(page);
 435     if ( forceSelected || ((size_t)page == m_sel) )
 436     {
 437         const wxSize indent = GetRenderer()->GetTabIndent();
 438         rect.Inflate(indent.x, indent.y);
 439     }
 440
 441     RefreshRect(rect);
 442 }
 443
 444 void wxNotebook::RefreshAllTabs()
 445 {
 446     wxRect rect = GetAllTabsRect();
 447     if ( rect.width || rect.height )
 448     {
 449         RefreshRect(rect);
 450     }
 451     //else: we don't have tabs at all
 452 }
 453
 454 void wxNotebook::DoDrawTab(wxDC& dc, const wxRect& rect, size_t n)
 455 {
 456     wxBitmap bmp;
 457     if ( HasImage(n) )
 458     {
 459         int image = m_images[n];
 460
 461 #ifdef __WXMSW__    // FIXME
 462         int w, h;
 463         m_imageList->GetSize(n, w, h);
 464         bmp.Create(w, h);
 465         wxMemoryDC dc;
 466         dc.SelectObject(bmp);
 467         dc.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
 468         m_imageList->Draw(image, dc, 0, 0, wxIMAGELIST_DRAW_NORMAL, TRUE);
 469 #else
 470         bmp = *m_imageList->GetBitmap(image);
 471 #endif
 472     }
 473
 474     int flags = 0;
 475     if ( n == m_sel )
 476     {
 477         flags |= wxCONTROL_SELECTED;
 478
 479         if ( IsFocused() )
 480             flags |= wxCONTROL_FOCUSED;
 481     }
 482
 483     GetRenderer()->DrawTab
 484                    (
 485                      dc,
 486                      rect,
 487                      GetTabOrientation(),
 488                      m_titles[n],
 489                      bmp,
 490                      flags,
 491                      m_accels[n]
 492                    );
 493 }
 494
 495 void wxNotebook::DoDraw(wxControlRenderer *renderer)
 496 {
 497     //wxRect rectUpdate = GetUpdateClientRect(); -- unused
 498
 499     wxDC& dc = renderer->GetDC();
 500     dc.SetFont(GetFont());
 501     dc.SetTextForeground(GetForegroundColour());
 502
 503     // redraw the border - it's simpler to always do it instead of checking
 504     // whether this needs to be done
 505     GetRenderer()->DrawBorder(dc, wxBORDER_RAISED, GetPagePart());
 506
 507     // avoid overwriting the spin button
 508     if ( HasSpinBtn() )
 509     {
 510         wxRect rectTabs = GetAllTabsRect();
 511         wxSize sizeSpinBtn = m_spinbtn->GetSize();
 512
 513         if ( IsVertical() )
 514             rectTabs.height -= sizeSpinBtn.y;
 515         else
 516             rectTabs.width -= sizeSpinBtn.x;
 517
 518         dc.SetClippingRegion(rectTabs);
 519     }
 520
 521     wxRect rect = GetTabsPart();
 522     bool isVertical = IsVertical();
 523
 524     wxRect rectSel;
 525     for ( size_t n = m_firstVisible; n < m_lastVisible; n++ )
 526     {
 527         GetTabSize(n, &rect.width, &rect.height);
 528
 529         if ( n == m_sel )
 530         {
 531             // don't redraw it now as this tab has to be drawn over the other
 532             // ones as it takes more place and spills over to them
 533             rectSel = rect;
 534         }
 535         else // not selected tab
 536         {
 537             // unfortunately we can't do this because the selected tab hangs
 538             // over its neighbours and so we might need to refresh more tabs -
 539             // of course, we could still avoid rereshing some of them with more
 540             // complicated checks, but it doesn't seem too bad to refresh all
 541             // of them, I still don't see flicker, so leaving as is for now
 542
 543             //if ( rectUpdate.Intersects(rect) )
 544             {
 545                 DoDrawTab(dc, rect, n);
 546             }
 547             //else: doesn't need to be refreshed
 548         }
 549
 550         // move the rect to the next tab
 551         if ( isVertical )
 552             rect.y += rect.height;
 553         else
 554             rect.x += rect.width;
 555     }
 556
 557     // now redraw the selected tab
 558     if ( rectSel.width )
 559     {
 560         DoDrawTab(dc, rectSel, m_sel);
 561     }
 562 }
 563
 564 // ----------------------------------------------------------------------------
 565 // wxNotebook geometry
 566 // ----------------------------------------------------------------------------
 567
 568 int wxNotebook::HitTest(const wxPoint& pt) const
 569 {
 570     // first check that it is in this window at all
 571     if ( !GetClientRect().Inside(pt) )
 572     {
 573         return -1;
 574     }
 575
 576     wxRect rectTabs = GetAllTabsRect();
 577
 578     switch ( GetTabOrientation() )
 579     {
 580         default:
 581             wxFAIL_MSG(_T("unknown tab orientation"));
 582             // fall through
 583
 584         case wxTOP:
 585             if ( pt.y > rectTabs.GetBottom() )
 586                 return -1;
 587             break;
 588
 589         case wxBOTTOM:
 590             if ( pt.y < rectTabs.y )
 591                 return -1;
 592             break;
 593
 594         case wxLEFT:
 595             if ( pt.x > rectTabs.GetRight() )
 596                 return -1;
 597             break;
 598
 599         case wxRIGHT:
 600             if ( pt.x < rectTabs.x )
 601                 return -1;
 602             break;
 603     }
 604
 605     for ( size_t n = m_firstVisible; n < m_lastVisible; n++ )
 606     {
 607         GetTabSize(n, &rectTabs.width, &rectTabs.height);
 608
 609         if ( rectTabs.Inside(pt) )
 610             return n;
 611
 612         // move the rectTabs to the next tab
 613         if ( IsVertical() )
 614             rectTabs.y += rectTabs.height;
 615         else
 616             rectTabs.x += rectTabs.width;
 617     }
 618
 619     return -1;
 620 }
 621
 622 bool wxNotebook::IsVertical() const
 623 {
 624     wxDirection dir = GetTabOrientation();
 625
 626     return dir == wxLEFT || dir == wxRIGHT;
 627 }
 628
 629 wxDirection wxNotebook::GetTabOrientation() const
 630 {
 631     long style = GetWindowStyle();
 632     if ( style & wxNB_BOTTOM )
 633         return wxBOTTOM;
 634     else if ( style & wxNB_RIGHT )
 635         return wxRIGHT;
 636     else if ( style & wxNB_LEFT )
 637         return wxLEFT;
 638
 639     // wxNB_TOP == 0 so we don't have to test for it
 640     return wxTOP;
 641 }
 642
 643 wxRect wxNotebook::GetTabRect(int page) const
 644 {
 645     wxRect rect;
 646     wxCHECK_MSG( IS_VALID_PAGE(page), rect, _T("invalid notebook page") );
 647
 648     // calc the size of this tab and of the preceding ones
 649     wxCoord widthThis, widthBefore;
 650     if ( FixedSizeTabs() )
 651     {
 652         widthThis = m_widthMax;
 653         widthBefore = page*m_widthMax;
 654     }
 655     else
 656     {
 657         widthBefore = 0;
 658         for ( int n = 0; n < page; n++ )
 659         {
 660             widthBefore += m_widths[n];
 661         }
 662
 663         widthThis = m_widths[page];
 664     }
 665
 666     rect = GetTabsPart();
 667     if ( IsVertical() )
 668     {
 669         rect.y += widthBefore - m_offset;
 670         rect.height = widthThis;
 671     }
 672     else // horz
 673     {
 674         rect.x += widthBefore - m_offset;
 675         rect.width = widthThis;
 676     }
 677
 678     return rect;
 679 }
 680
 681 wxRect wxNotebook::GetAllTabsRect() const
 682 {
 683     wxRect rect;
 684
 685     if ( GetPageCount() )
 686     {
 687         const wxSize indent = GetRenderer()->GetTabIndent();
 688         wxSize size = GetClientSize();
 689
 690         if ( IsVertical() )
 691         {
 692             rect.width = m_heightTab + indent.x;
 693             rect.x = GetTabOrientation() == wxLEFT ? 0 : size.x - rect.width;
 694             rect.y = 0;
 695             rect.height = size.y;
 696         }
 697         else // horz
 698         {
 699             rect.x = 0;
 700             rect.width = size.x;
 701             rect.height = m_heightTab + indent.y;
 702             rect.y = GetTabOrientation() == wxTOP ? 0 : size.y - rect.height;
 703         }
 704     }
 705     //else: no pages
 706
 707     return rect;
 708 }
 709
 710 wxRect wxNotebook::GetTabsPart() const
 711 {
 712     wxRect rect = GetAllTabsRect();
 713
 714     wxDirection dir = GetTabOrientation();
 715
 716     const wxSize indent = GetRenderer()->GetTabIndent();
 717     if ( IsVertical() )
 718     {
 719         rect.x += indent.y;
 720         rect.y += indent.x;
 721     }
 722     else // horz
 723     {
 724         rect.x += indent.x;
 725         if ( dir == wxTOP )
 726         {
 727             rect.y += indent.y;
 728             rect.height -= indent.y;
 729         }
 730         else // wxBOTTOM
 731         {
 732             rect.height -= indent.y;
 733         }
 734     }
 735
 736     return rect;
 737 }
 738
 739 void wxNotebook::GetTabSize(int page, wxCoord *w, wxCoord *h) const
 740 {
 741     wxCHECK_RET( w && h, _T("NULL pointer in GetTabSize") );
 742
 743     if ( IsVertical() )
 744     {
 745         // width and height have inverted meaning
 746         wxCoord *tmp = w;
 747         w = h;
 748         h = tmp;
 749     }
 750
 751     // height is always fixed
 752     *h = m_heightTab;
 753
 754     // width may also be fixed and be the same for all tabs
 755     *w = GetTabWidth(page);
 756 }
 757
 758 void wxNotebook::SetTabSize(const wxSize& sz)
 759 {
 760     wxCHECK_RET( FixedSizeTabs(), _T("SetTabSize() ignored") );
 761
 762     if ( IsVertical() )
 763     {
 764         m_heightTab = sz.x;
 765         m_widthMax = sz.y;
 766     }
 767     else // horz
 768     {
 769         m_widthMax = sz.x;
 770         m_heightTab = sz.y;
 771     }
 772 }
 773
 774 wxSize wxNotebook::CalcTabSize(int page) const
 775 {
 776     // NB: don't use m_widthMax, m_heightTab or m_widths here because this
 777     //     method is called to calculate them
 778
 779     wxSize size;
 780
 781     wxCHECK_MSG( IS_VALID_PAGE(page), size, _T("invalid notebook page") );
 782
 783     GetTextExtent(m_titles[page], &size.x, &size.y);
 784
 785     if ( HasImage(page) )
 786     {
 787         wxSize sizeImage;
 788         m_imageList->GetSize(m_images[page], sizeImage.x, sizeImage.y);
 789
 790         size.x += sizeImage.x + 5; // FIXME: hard coded margin
 791
 792         if ( sizeImage.y > size.y )
 793             size.y = sizeImage.y;
 794     }
 795
 796     size.x += 2*m_sizePad.x;
 797     size.y += 2*m_sizePad.y;
 798
 799     return size;
 800 }
 801
 802 void wxNotebook::ResizeTab(int page)
 803 {
 804     wxSize sizeTab = CalcTabSize(page);
 805
 806     // we only need full relayout if the page size changes
 807     bool needsRelayout = FALSE;
 808
 809     if ( IsVertical() )
 810     {
 811         // swap coordinates
 812         wxCoord tmp = sizeTab.x;
 813         sizeTab.x = sizeTab.y;
 814         sizeTab.y = tmp;
 815     }
 816
 817     if ( sizeTab.y > m_heightTab )
 818     {
 819         needsRelayout = TRUE;
 820
 821         m_heightTab = sizeTab.y;
 822     }
 823
 824     m_widths[page] = sizeTab.x;
 825
 826     if ( sizeTab.x > m_widthMax )
 827         m_widthMax = sizeTab.x;
 828
 829     // the total of the tabs has changed too
 830     UpdateSpinBtn();
 831
 832     if ( needsRelayout )
 833         Relayout();
 834     else
 835         RefreshAllTabs();
 836 }
 837
 838 void wxNotebook::SetPadding(const wxSize& padding)
 839 {
 840     if ( padding != m_sizePad )
 841     {
 842         m_sizePad = padding;
 843
 844         Relayout();
 845     }
 846 }
 847
 848 void wxNotebook::Relayout()
 849 {
 850     if ( GetPageCount() )
 851     {
 852         RefreshAllTabs();
 853
 854         UpdateSpinBtn();
 855
 856         if ( m_sel != INVALID_PAGE )
 857         {
 858             // resize the currently shown page
 859             wxRect rectPage = GetPageRect();
 860
 861             m_pages[m_sel]->SetSize(rectPage);
 862
 863             // also scroll it into view if needed (note that m_lastVisible
 864             // was updated by the call to UpdateSpinBtn() above, this is why it
 865             // is needed here)
 866             if ( HasSpinBtn() )
 867             {
 868                 if ( m_sel < m_firstVisible )
 869                 {
 870                     // selection is to the left of visible part of tabs
 871                     ScrollTo(m_sel);
 872                 }
 873                 else if ( m_sel > m_lastFullyVisible )
 874                 {
 875                     // selection is to the right of visible part of tabs
 876                     ScrollLastTo(m_sel);
 877                 }
 878             }
 879         }
 880     }
 881     else // we have no pages
 882     {
 883         // just refresh everything
 884         Refresh();
 885     }
 886 }
 887
 888 wxRect wxNotebook::GetPagePart() const
 889 {
 890     wxRect rectPage = GetClientRect();
 891
 892     if ( GetPageCount() )
 893     {
 894         wxRect rectTabs = GetAllTabsRect();
 895         wxDirection dir = GetTabOrientation();
 896         if ( IsVertical() )
 897         {
 898             rectPage.width -= rectTabs.width;
 899             if ( dir == wxLEFT )
 900                 rectPage.x += rectTabs.width;
 901         }
 902         else // horz
 903         {
 904             rectPage.height -= rectTabs.height;
 905             if ( dir == wxTOP )
 906                 rectPage.y += rectTabs.height;
 907         }
 908     }
 909     //else: no pages at all
 910
 911     return rectPage;
 912 }
 913
 914 wxRect wxNotebook::GetPageRect() const
 915 {
 916     wxRect rect = GetPagePart();
 917
 918     // leave space for the border
 919     wxRect rectBorder = GetRenderer()->GetBorderDimensions(wxBORDER_RAISED);
 920
 921     // FIXME: hardcoded +2!
 922     rect.Inflate(-(rectBorder.x + rectBorder.width + 2),
 923                  -(rectBorder.y + rectBorder.height + 2));
 924
 925     return rect;
 926 }
 927
 928 wxSize wxNotebook::GetSizeForPage(const wxSize& size) const
 929 {
 930     wxSize sizeNb = size;
 931     wxRect rect = GetAllTabsRect();
 932     if ( IsVertical() )
 933         sizeNb.x += rect.width;
 934     else
 935         sizeNb.y += rect.height;
 936
 937     return sizeNb;
 938 }
 939
 940 void wxNotebook::SetPageSize(const wxSize& size)
 941 {
 942     SetClientSize(GetSizeForPage(size));
 943 }
 944
 945 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage)
 946 {
 947     return AdjustSize(GetSizeForPage(sizePage));
 948 }
 949
 950 // ----------------------------------------------------------------------------
 951 // wxNotebook spin button
 952 // ----------------------------------------------------------------------------
 953
 954 bool wxNotebook::HasSpinBtn() const
 955 {
 956     return m_spinbtn && m_spinbtn->IsShown();
 957 }
 958
 959 void wxNotebook::CalcLastVisibleTab()
 960 {
 961     bool isVertical = IsVertical();
 962
 963     wxCoord width = GetClientSize().x;
 964
 965     wxRect rect = GetTabsPart();
 966
 967     size_t count = GetPageCount();
 968
 969     wxCoord widthLast = 0;
 970     size_t n;
 971     for ( n = m_firstVisible; n < count; n++ )
 972     {
 973         GetTabSize(n, &rect.width, &rect.height);
 974         if ( rect.GetRight() > width )
 975         {
 976             break;
 977         }
 978
 979         // remember it to use below
 980         widthLast = rect.GetRight();
 981
 982         // move the rect to the next tab
 983         if ( isVertical )
 984             rect.y += rect.height;
 985         else
 986             rect.x += rect.width;
 987     }
 988
 989     if ( n == m_firstVisible )
 990     {
 991         // even the first tab isn't fully visible - but still pretend it is as
 992         // we have to show something
 993         m_lastFullyVisible = m_firstVisible;
 994     }
 995     else // more than one tab visible
 996     {
 997         m_lastFullyVisible = n - 1;
 998
 999         // but is it really fully visible? it shouldn't overlap with the spin
1000         // button if it is present (again, even if the first button does
1001         // overlap with it, we pretend that it doesn't as there is not much
1002         // else we can do)
1003         if ( (m_lastFullyVisible > m_firstVisible) && HasSpinBtn() )
1004         {
1005             // adjust width to be the width before the spin button
1006             wxSize sizeSpinBtn = m_spinbtn->GetSize();
1007             if ( IsVertical() )
1008                 width -= sizeSpinBtn.y;
1009             else
1010                 width -= sizeSpinBtn.x;
1011
1012             if ( widthLast > width )
1013             {
1014                 // the last button overlaps with spin button, so take he
1015                 // previous one
1016                 m_lastFullyVisible--;
1017             }
1018         }
1019     }
1020
1021     if ( n == count )
1022     {
1023         // everything is visible
1024         m_lastVisible = n;
1025     }
1026     else
1027     {
1028         // this tab is still (partially) visible, so m_lastVisible is the
1029         // next tab (remember, this is "exclusive" last)
1030         m_lastVisible = n + 1;
1031
1032     }
1033 }
1034
1035 void wxNotebook::UpdateSpinBtn()
1036 {
1037     // first decide if we need a spin button
1038     bool allTabsShown;
1039
1040     size_t count = (size_t)GetPageCount();
1041     if ( count == 0 )
1042     {
1043         // this case is special, get rid of it immediately: everything is
1044         // visible and we don't need any spin buttons
1045         allTabsShown = TRUE;
1046
1047         // have to reset them manually as we don't call CalcLastVisibleTab()
1048         m_firstVisible =
1049         m_lastVisible =
1050         m_lastFullyVisible = 0;
1051     }
1052     else
1053     {
1054         CalcLastVisibleTab();
1055
1056         // if all tabs after the first visible one are shown, it doesn't yet
1057         // mean that all tabs are shown - so we go backwards until we arrive to
1058         // the beginning (then all tabs are indeed shown) or find a tab such
1059         // that not all tabs after it are shown
1060         while ( (m_lastFullyVisible == count - 1) && (m_firstVisible > 0) )
1061         {
1062             // this is equivalent to ScrollTo(m_firstVisible - 1) but more
1063             // efficient
1064             m_offset -= GetTabWidth(m_firstVisible--);
1065
1066             // reclaculate after m_firstVisible change
1067             CalcLastVisibleTab();
1068         }
1069
1070         allTabsShown = m_lastFullyVisible == count - 1;
1071     }
1072
1073     if ( !allTabsShown )
1074     {
1075         if ( !m_spinbtn )
1076         {
1077             // create it once only
1078             m_spinbtn = new wxNotebookSpinBtn(this);
1079
1080             // set the correct value to keep it in sync
1081             m_spinbtn->SetValue(m_sel);
1082         }
1083
1084         // position it correctly
1085         PositionSpinBtn();
1086
1087         // and show it
1088         m_spinbtn->Show();
1089
1090         // also set/update the range
1091         m_spinbtn->SetRange(0, count - 1);
1092
1093         // update m_lastFullyVisible once again as it might have changed
1094         // because the spin button appeared
1095         //
1096         // FIXME: might do it more efficiently
1097         CalcLastVisibleTab();
1098     }
1099     else // all tabs are visible, we don't need spin button
1100     {
1101         if ( m_spinbtn )
1102         {
1103             m_spinbtn->Hide();
1104         }
1105     }
1106 }
1107
1108 void wxNotebook::PositionSpinBtn()
1109 {
1110     if ( !m_spinbtn )
1111         return;
1112
1113     wxCoord wBtn, hBtn;
1114     m_spinbtn->GetSize(&wBtn, &hBtn);
1115
1116     wxRect rectTabs = GetAllTabsRect();
1117
1118     wxCoord x, y;
1119     switch ( GetTabOrientation() )
1120     {
1121         default:
1122             wxFAIL_MSG(_T("unknown tab orientation"));
1123             // fall through
1124
1125         case wxTOP:
1126             x = rectTabs.GetRight() - wBtn;
1127             y = rectTabs.GetBottom() - hBtn;
1128             break;
1129
1130         case wxBOTTOM:
1131             x = rectTabs.GetRight() - wBtn;
1132             y = rectTabs.GetTop();
1133             break;
1134
1135         case wxLEFT:
1136             x = rectTabs.GetRight() - wBtn;
1137             y = rectTabs.GetBottom() - hBtn;
1138             break;
1139
1140         case wxRIGHT:
1141             x = rectTabs.GetLeft();
1142             y = rectTabs.GetBottom() - hBtn;
1143             break;
1144     }
1145
1146     m_spinbtn->Move(x, y);
1147 }
1148
1149 // ----------------------------------------------------------------------------
1150 // wxNotebook scrolling
1151 // ----------------------------------------------------------------------------
1152
1153 void wxNotebook::ScrollTo(int page)
1154 {
1155     wxCHECK_RET( IS_VALID_PAGE(page), _T("invalid notebook page") );
1156
1157     // set the first visible tab and offset (easy)
1158     m_firstVisible = (size_t)page;
1159     m_offset = 0;
1160     for ( size_t n = 0; n < m_firstVisible; n++ )
1161     {
1162         m_offset += GetTabWidth(n);
1163     }
1164
1165     // find the last visible tab too
1166     CalcLastVisibleTab();
1167
1168     RefreshAllTabs();
1169 }
1170
1171 void wxNotebook::ScrollLastTo(int page)
1172 {
1173     wxCHECK_RET( IS_VALID_PAGE(page), _T("invalid notebook page") );
1174
1175     // go backwards until we find the first tab which can be made visible
1176     // without hiding the given one
1177     wxSize size = GetClientSize();
1178     wxCoord widthAll = IsVertical() ? size.y : size.x,
1179             widthTabs = GetTabWidth(page);
1180
1181     // the total width is less than the width of the window if we have the spin
1182     // button
1183     if ( HasSpinBtn() )
1184     {
1185         wxSize sizeSpinBtn = m_spinbtn->GetSize();
1186         if ( IsVertical() )
1187             widthAll -= sizeSpinBtn.y;
1188         else
1189             widthAll -= sizeSpinBtn.x;
1190     }
1191
1192     m_firstVisible = page;
1193     while ( (m_firstVisible > 0) && (widthTabs <= widthAll) )
1194     {
1195         widthTabs += GetTabWidth(--m_firstVisible);
1196     }
1197
1198     if ( widthTabs > widthAll )
1199     {
1200         // take one step back (that it is forward) if we can
1201         if ( m_firstVisible < (size_t)GetPageCount() - 1 )
1202             m_firstVisible++;
1203     }
1204
1205     // go to it
1206     ScrollTo(m_firstVisible);
1207
1208     // consitency check: the page we were asked to show should be shown
1209     wxASSERT_MSG( (size_t)page < m_lastVisible, _T("bug in ScrollLastTo") );
1210 }
1211
1212 // ----------------------------------------------------------------------------
1213 // wxNotebook sizing/moving
1214 // ----------------------------------------------------------------------------
1215
1216 wxSize wxNotebook::DoGetBestClientSize() const
1217 {
1218     // calculate the max page size
1219     wxSize size(0, 0);
1220
1221     size_t count = GetPageCount();
1222     if ( count )
1223     {
1224         for ( size_t n = 0; n < count; n++ )
1225         {
1226             wxSize sizePage = m_pages[n]->GetSize();
1227
1228             if ( size.x < sizePage.x )
1229                 size.x = sizePage.x;
1230             if ( size.y < sizePage.y )
1231                 size.y = sizePage.y;
1232         }
1233     }
1234     else // no pages
1235     {
1236         // use some arbitrary default size
1237         size.x =
1238         size.y = 100;
1239     }
1240
1241     return GetSizeForPage(size);
1242 }
1243
1244 void wxNotebook::DoMoveWindow(int x, int y, int width, int height)
1245 {
1246     wxControl::DoMoveWindow(x, y, width, height);
1247
1248     // move the spin ctrl too (NOP if it doesn't exist)
1249     PositionSpinBtn();
1250 }
1251
1252 void wxNotebook::DoSetSize(int x, int y,
1253                            int width, int height,
1254                            int sizeFlags)
1255 {
1256     wxControl::DoSetSize(x, y, width, height, sizeFlags);
1257
1258     Relayout();
1259 }
1260
1261 // ----------------------------------------------------------------------------
1262 // wxNotebook input processing
1263 // ----------------------------------------------------------------------------
1264
1265 bool wxNotebook::PerformAction(const wxControlAction& action,
1266                                long numArg,
1267                                const wxString& strArg)
1268 {
1269     if ( action == wxACTION_NOTEBOOK_NEXT )
1270         ChangePage(GetNextPage(TRUE));
1271     else if ( action == wxACTION_NOTEBOOK_PREV )
1272         ChangePage(GetNextPage(FALSE));
1273     else if ( action == wxACTION_NOTEBOOK_GOTO )
1274         ChangePage((int)numArg);
1275     else
1276         return wxControl::PerformAction(action, numArg, strArg);
1277
1278     return TRUE;
1279 }
1280
1281 // ----------------------------------------------------------------------------
1282 // wxStdNotebookInputHandler
1283 // ----------------------------------------------------------------------------
1284
1285 wxStdNotebookInputHandler::wxStdNotebookInputHandler(wxInputHandler *inphand)
1286                          : wxStdInputHandler(inphand)
1287 {
1288 }
1289
1290 bool wxStdNotebookInputHandler::HandleKey(wxInputConsumer *consumer,
1291                                           const wxKeyEvent& event,
1292                                           bool pressed)
1293 {
1294     // ignore the key releases
1295     if ( pressed )
1296     {
1297         wxNotebook *notebook = wxStaticCast(consumer->GetInputWindow(), wxNotebook);
1298
1299         int page = 0;
1300         wxControlAction action;
1301         switch ( event.GetKeyCode() )
1302         {
1303             case WXK_UP:
1304                 if ( notebook->IsVertical() )
1305                     action = wxACTION_NOTEBOOK_PREV;
1306                 break;
1307
1308             case WXK_LEFT:
1309                 if ( !notebook->IsVertical() )
1310                     action = wxACTION_NOTEBOOK_PREV;
1311                 break;
1312
1313             case WXK_DOWN:
1314                 if ( notebook->IsVertical() )
1315                     action = wxACTION_NOTEBOOK_NEXT;
1316                 break;
1317
1318             case WXK_RIGHT:
1319                 if ( !notebook->IsVertical() )
1320                     action = wxACTION_NOTEBOOK_NEXT;
1321                 break;
1322
1323             case WXK_HOME:
1324                 action = wxACTION_NOTEBOOK_GOTO;
1325                 // page = 0; -- already has this value
1326                 break;
1327
1328             case WXK_END:
1329                 action = wxACTION_NOTEBOOK_GOTO;
1330                 page = notebook->GetPageCount() - 1;
1331                 break;
1332         }
1333
1334         if ( !!action )
1335         {
1336             return consumer->PerformAction(action, page);
1337         }
1338     }
1339
1340     return wxStdInputHandler::HandleKey(consumer, event, pressed);
1341 }
1342
1343 bool wxStdNotebookInputHandler::HandleMouse(wxInputConsumer *consumer,
1344                                             const wxMouseEvent& event)
1345 {
1346     if ( event.ButtonDown(1) )
1347     {
1348         wxNotebook *notebook = wxStaticCast(consumer->GetInputWindow(), wxNotebook);
1349         int page = notebook->HitTest(event.GetPosition());
1350         if ( page != -1 )
1351         {
1352             consumer->PerformAction(wxACTION_NOTEBOOK_GOTO, page);
1353
1354             return FALSE;
1355         }
1356     }
1357
1358     return wxStdInputHandler::HandleMouse(consumer, event);
1359 }
1360
1361 bool wxStdNotebookInputHandler::HandleMouseMove(wxInputConsumer *consumer,
1362                                                 const wxMouseEvent& event)
1363 {
1364     return wxStdInputHandler::HandleMouseMove(consumer, event);
1365 }
1366
1367 bool wxStdNotebookInputHandler::HandleFocus(wxInputConsumer *consumer,
1368                                             const wxFocusEvent& event)
1369 {
1370     HandleFocusChange(consumer);
1371
1372     return FALSE;
1373 }
1374
1375 bool wxStdNotebookInputHandler::HandleActivation(wxInputConsumer *consumer,
1376                                                  bool WXUNUSED(activated))
1377 {
1378     // we react to the focus change in the same way as to the [de]activation
1379     HandleFocusChange(consumer);
1380
1381     return FALSE;
1382 }
1383
1384 void wxStdNotebookInputHandler::HandleFocusChange(wxInputConsumer *consumer)
1385 {
1386     wxNotebook *notebook = wxStaticCast(consumer->GetInputWindow(), wxNotebook);
1387     notebook->RefreshCurrent();
1388 }
1389
1390 #endif // wxUSE_NOTEBOOK
1391