src/generic/notebook.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/notebook.cpp
   3 // Purpose:     generic implementation of wxNotebook
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __VMS
  21 #pragma message disable unscomzer
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28 #pragma hdrstop
  29 #endif
  30
  31 #ifndef __WXPALMOS__
  32
  33 #include  "wx/string.h"
  34 #include  "wx/log.h"
  35 #include  "wx/settings.h"
  36 #include  "wx/generic/imaglist.h"
  37 #include  "wx/notebook.h"
  38 #include  "wx/dcclient.h"
  39 #include  "wx/generic/tabg.h"
  40
  41 // ----------------------------------------------------------------------------
  42 // macros
  43 // ----------------------------------------------------------------------------
  44
  45 // check that the page index is valid
  46 #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())
  47
  48 // ----------------------------------------------------------------------------
  49 // event table
  50 // ----------------------------------------------------------------------------
  51
  52 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
  53 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
  54
  55 BEGIN_EVENT_TABLE(wxNotebook, wxControl)
  56     EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, wxNotebook::OnSelChange)
  57     EVT_SIZE(wxNotebook::OnSize)
  58     EVT_PAINT(wxNotebook::OnPaint)
  59     EVT_MOUSE_EVENTS(wxNotebook::OnMouseEvent)
  60     EVT_SET_FOCUS(wxNotebook::OnSetFocus)
  61     EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
  62 END_EVENT_TABLE()
  63
  64 IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
  65 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
  66
  67 // ============================================================================
  68 // implementation
  69 // ============================================================================
  70
  71 // ============================================================================
  72 // Private class
  73 // ============================================================================
  74
  75 // This reuses wxTabView to draw the tabs.
  76 class WXDLLEXPORT wxNotebookTabView: public wxTabView
  77 {
  78 DECLARE_DYNAMIC_CLASS(wxNotebookTabView)
  79 public:
  80   wxNotebookTabView(wxNotebook* notebook, long style = wxTAB_STYLE_DRAW_BOX | wxTAB_STYLE_COLOUR_INTERIOR);
  81   ~wxNotebookTabView(void);
  82
  83   // Called when a tab is activated
  84   virtual void OnTabActivate(int activateId, int deactivateId);
  85   // Allows vetoing
  86   virtual bool OnTabPreActivate(int activateId, int deactivateId);
  87
  88 protected:
  89    wxNotebook*      m_notebook;
  90 };
  91
  92 // ----------------------------------------------------------------------------
  93 // wxNotebook construction
  94 // ----------------------------------------------------------------------------
  95
  96 // common part of all ctors
  97 void wxNotebook::Init()
  98 {
  99     m_tabView = (wxNotebookTabView*) NULL;
 100     m_nSelection = -1;
 101 }
 102
 103 // default for dynamic class
 104 wxNotebook::wxNotebook()
 105 {
 106     Init();
 107 }
 108
 109 // the same arguments as for wxControl
 110 wxNotebook::wxNotebook(wxWindow *parent,
 111                        wxWindowID id,
 112                        const wxPoint& pos,
 113                        const wxSize& size,
 114                        long style,
 115                        const wxString& name)
 116 {
 117     Init();
 118
 119     Create(parent, id, pos, size, style, name);
 120 }
 121
 122 // Create() function
 123 bool wxNotebook::Create(wxWindow *parent,
 124                         wxWindowID id,
 125                         const wxPoint& pos,
 126                         const wxSize& size,
 127                         long style,
 128                         const wxString& name)
 129 {
 130     // base init
 131     SetName(name);
 132
 133     m_windowId = id == wxID_ANY ? NewControlId() : id;
 134
 135     if (!wxControl::Create(parent, id, pos, size, style|wxNO_BORDER, wxDefaultValidator, name))
 136         return false;
 137
 138     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
 139
 140     SetTabView(new wxNotebookTabView(this));
 141
 142     return true;
 143 }
 144
 145 // dtor
 146 wxNotebook::~wxNotebook()
 147 {
 148     delete m_tabView;
 149 }
 150
 151 // ----------------------------------------------------------------------------
 152 // wxNotebook accessors
 153 // ----------------------------------------------------------------------------
 154 int wxNotebook::GetRowCount() const
 155 {
 156     // TODO
 157     return 0;
 158 }
 159
 160 int wxNotebook::SetSelection(size_t nPage)
 161 {
 162     wxASSERT( IS_VALID_PAGE(nPage) );
 163
 164     wxNotebookPage* pPage = GetPage(nPage);
 165
 166     m_tabView->SetTabSelection((int) (long) pPage);
 167
 168     // TODO
 169     return 0;
 170 }
 171
 172 #if 0
 173 void wxNotebook::AdvanceSelection(bool bForward)
 174 {
 175     int nSel = GetSelection();
 176     int nMax = GetPageCount() - 1;
 177     if ( bForward )
 178         SetSelection(nSel == nMax ? 0 : nSel + 1);
 179     else
 180         SetSelection(nSel == 0 ? nMax : nSel - 1);
 181 }
 182 #endif
 183
 184 bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
 185 {
 186     wxASSERT( IS_VALID_PAGE(nPage) );
 187
 188     wxNotebookPage* page = GetPage(nPage);
 189     if (page)
 190     {
 191         m_tabView->SetTabText((int) (long) page, strText);
 192         Refresh();
 193         return true;
 194     }
 195
 196     return false;
 197 }
 198
 199 wxString wxNotebook::GetPageText(size_t nPage) const
 200 {
 201     wxASSERT( IS_VALID_PAGE(nPage) );
 202
 203     wxNotebookPage* page = ((wxNotebook*)this)->GetPage(nPage);
 204     if (page)
 205         return m_tabView->GetTabText((int) (long) page);
 206     else
 207         return wxEmptyString;
 208 }
 209
 210 int wxNotebook::GetPageImage(size_t nPage) const
 211 {
 212     wxASSERT( IS_VALID_PAGE(nPage) );
 213
 214     // TODO
 215     return 0;
 216 }
 217
 218 bool wxNotebook::SetPageImage(size_t nPage, int WXUNUSED(nImage))
 219 {
 220     wxASSERT( IS_VALID_PAGE(nPage) );
 221
 222     // TODO
 223     return false;
 224 }
 225
 226 // set the size (the same for all pages)
 227 void wxNotebook::SetPageSize(const wxSize& WXUNUSED(size))
 228 {
 229     // TODO
 230 }
 231
 232 // set the padding between tabs (in pixels)
 233 void wxNotebook::SetPadding(const wxSize& WXUNUSED(padding))
 234 {
 235     // TODO
 236 }
 237
 238 // set the size of the tabs for wxNB_FIXEDWIDTH controls
 239 void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz))
 240 {
 241     // TODO
 242 }
 243
 244 // ----------------------------------------------------------------------------
 245 // wxNotebook operations
 246 // ----------------------------------------------------------------------------
 247
 248 // remove one page from the notebook and delete it
 249 bool wxNotebook::DeletePage(size_t nPage)
 250 {
 251     wxCHECK( IS_VALID_PAGE(nPage), false );
 252
 253     if (m_nSelection != -1)
 254     {
 255         m_pages[m_nSelection]->Show(false);
 256         m_pages[m_nSelection]->Lower();
 257     }
 258
 259     wxNotebookPage* pPage = GetPage(nPage);
 260
 261     m_tabView->RemoveTab((int) (long) pPage);
 262
 263     m_pages.Remove(pPage);
 264     delete pPage;
 265
 266     if (m_pages.GetCount() == 0)
 267     {
 268       m_nSelection = -1;
 269       m_tabView->SetTabSelection(-1, false);
 270     }
 271     else if (m_nSelection > -1)
 272     {
 273       m_nSelection = -1;
 274
 275       m_tabView->SetTabSelection((int) (long) GetPage(0), false);
 276
 277       if (m_nSelection != 0)
 278         ChangePage(-1, 0);
 279     }
 280
 281     RefreshLayout(false);
 282
 283     return true;
 284 }
 285
 286 bool wxNotebook::DeletePage(wxNotebookPage* page)
 287 {
 288     int pagePos = FindPagePosition(page);
 289     if (pagePos > -1)
 290         return DeletePage(pagePos);
 291     else
 292         return false;
 293 }
 294
 295 bool wxNotebook::RemovePage(size_t nPage)
 296 {
 297     return DoRemovePage(nPage) != NULL;
 298 }
 299
 300 // remove one page from the notebook
 301 wxWindow* wxNotebook::DoRemovePage(size_t nPage)
 302 {
 303     wxCHECK( IS_VALID_PAGE(nPage), NULL );
 304
 305     m_pages[nPage]->Show(false);
 306     //    m_pages[nPage]->Lower();
 307
 308     wxNotebookPage* pPage = GetPage(nPage);
 309
 310     m_tabView->RemoveTab((int) (long) pPage);
 311
 312     m_pages.Remove(pPage);
 313
 314     if (m_pages.GetCount() == 0)
 315     {
 316       m_nSelection = -1;
 317       m_tabView->SetTabSelection(-1, true);
 318     }
 319     else if (m_nSelection > -1)
 320     {
 321       // Only change the selection if the page we
 322       // deleted was the selection.
 323       if (nPage == (size_t)m_nSelection)
 324       {
 325          m_nSelection = -1;
 326          // Select the first tab. Generates a ChangePage.
 327          m_tabView->SetTabSelection(0, true);
 328       }
 329       else
 330       {
 331         // We must adjust which tab we think is selected.
 332         // If greater than the page we deleted, it must be moved down
 333         // a notch.
 334         if (size_t(m_nSelection) > nPage)
 335           m_nSelection -- ;
 336       }
 337     }
 338
 339     RefreshLayout(false);
 340
 341     return pPage;
 342 }
 343
 344 bool wxNotebook::RemovePage(wxNotebookPage* page)
 345 {
 346     int pagePos = FindPagePosition(page);
 347     if (pagePos > -1)
 348         return RemovePage(pagePos);
 349     else
 350         return false;
 351 }
 352
 353 // Find the position of the wxNotebookPage, -1 if not found.
 354 int wxNotebook::FindPagePosition(wxNotebookPage* page) const
 355 {
 356     size_t nPageCount = GetPageCount();
 357     size_t nPage;
 358     for ( nPage = 0; nPage < nPageCount; nPage++ )
 359         if (m_pages[nPage] == page)
 360             return nPage;
 361     return -1;
 362 }
 363
 364 // remove all pages
 365 bool wxNotebook::DeleteAllPages()
 366 {
 367     m_tabView->ClearTabs(true);
 368
 369     size_t nPageCount = GetPageCount();
 370     size_t nPage;
 371     for ( nPage = 0; nPage < nPageCount; nPage++ )
 372         delete m_pages[nPage];
 373
 374     m_pages.Clear();
 375
 376     return true;
 377 }
 378
 379 // same as AddPage() but does it at given position
 380 bool wxNotebook::InsertPage(size_t nPage,
 381                             wxNotebookPage *pPage,
 382                             const wxString& strText,
 383                             bool bSelect,
 384                             int WXUNUSED(imageId))
 385 {
 386     wxASSERT( pPage != NULL );
 387     wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false );
 388
 389     m_tabView->AddTab((int) (long) pPage, strText);
 390
 391     if (!bSelect)
 392       pPage->Show(false);
 393
 394     // save the pointer to the page
 395     m_pages.Insert(pPage, nPage);
 396
 397     if (bSelect)
 398     {
 399         // This will cause ChangePage to be called, via OnSelPage
 400
 401         m_tabView->SetTabSelection((int) (long) pPage, true);
 402     }
 403
 404     // some page must be selected: either this one or the first one if there is
 405     // still no selection
 406     if ( m_nSelection == -1 )
 407       ChangePage(-1, 0);
 408
 409     RefreshLayout(false);
 410
 411     return true;
 412 }
 413
 414 // ----------------------------------------------------------------------------
 415 // wxNotebook callbacks
 416 // ----------------------------------------------------------------------------
 417
 418 // @@@ OnSize() is used for setting the font when it's called for the first
 419 //     time because doing it in ::Create() doesn't work (for unknown reasons)
 420 void wxNotebook::OnSize(wxSizeEvent& event)
 421 {
 422     static bool s_bFirstTime = true;
 423     if ( s_bFirstTime ) {
 424         // TODO: any first-time-size processing.
 425         s_bFirstTime = false;
 426     }
 427
 428     RefreshLayout();
 429
 430     // Processing continues to next OnSize
 431     event.Skip();
 432 }
 433
 434 // This was supposed to cure the non-display of the notebook
 435 // until the user resizes the window.
 436 // What's going on?
 437 void wxNotebook::OnInternalIdle()
 438 {
 439     wxWindow::OnInternalIdle();
 440
 441 #if 0
 442     static bool s_bFirstTime = true;
 443     if ( s_bFirstTime ) {
 444       /*
 445       wxSize sz(GetSize());
 446       sz.x ++;
 447       SetSize(sz);
 448       sz.x --;
 449       SetSize(sz);
 450       */
 451
 452       /*
 453       wxSize sz(GetSize());
 454       wxSizeEvent sizeEvent(sz, GetId());
 455       sizeEvent.SetEventObject(this);
 456       GetEventHandler()->ProcessEvent(sizeEvent);
 457       Refresh();
 458       */
 459       s_bFirstTime = false;
 460     }
 461 #endif
 462 }
 463
 464 // Implementation: calculate the layout of the view rect
 465 // and resize the children if required
 466 bool wxNotebook::RefreshLayout(bool force)
 467 {
 468     if (m_tabView)
 469     {
 470         wxRect oldRect = m_tabView->GetViewRect();
 471
 472         int cw, ch;
 473         GetClientSize(& cw, & ch);
 474
 475         int tabHeight = m_tabView->GetTotalTabHeight();
 476         wxRect rect;
 477         rect.x = 4;
 478         rect.y = tabHeight + 4;
 479         rect.width = cw - 8;
 480         rect.height = ch - 4 - rect.y ;
 481
 482         m_tabView->SetViewRect(rect);
 483
 484         m_tabView->LayoutTabs();
 485
 486         // Need to do it a 2nd time to get the tab height with
 487         // the new view width, since changing the view width changes the
 488         // tab layout.
 489         tabHeight = m_tabView->GetTotalTabHeight();
 490         rect.x = 4;
 491         rect.y = tabHeight + 4;
 492         rect.width = cw - 8;
 493         rect.height = ch - 4 - rect.y ;
 494
 495         m_tabView->SetViewRect(rect);
 496
 497         m_tabView->LayoutTabs();
 498
 499         if (!force && (rect == oldRect))
 500           return false;
 501
 502         // fit the notebook page to the tab control's display area
 503
 504         size_t nCount = m_pages.Count();
 505         for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
 506             wxNotebookPage *pPage = m_pages[nPage];
 507             wxRect clientRect = GetAvailableClientSize();
 508             if (pPage->IsShown())
 509             {
 510                 pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
 511                 if ( pPage->GetAutoLayout() )
 512                    pPage->Layout();
 513             }
 514         }
 515         Refresh();
 516     }
 517     return true;
 518 }
 519
 520 void wxNotebook::OnSelChange(wxNotebookEvent& event)
 521 {
 522     // is it our tab control?
 523     if ( event.GetEventObject() == this )
 524     {
 525         if (event.GetSelection() != m_nSelection)
 526           ChangePage(event.GetOldSelection(), event.GetSelection());
 527     }
 528
 529     // we want to give others a chance to process this message as well
 530     event.Skip();
 531 }
 532
 533 void wxNotebook::OnSetFocus(wxFocusEvent& event)
 534 {
 535     // set focus to the currently selected page if any
 536     if ( m_nSelection != -1 )
 537         m_pages[m_nSelection]->SetFocus();
 538
 539     event.Skip();
 540 }
 541
 542 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 543 {
 544     if ( event.IsWindowChange() ) {
 545         // change pages
 546         AdvanceSelection(event.GetDirection());
 547     }
 548     else {
 549         // pass to the parent
 550         if ( GetParent() ) {
 551             event.SetCurrentFocus(this);
 552             GetParent()->ProcessEvent(event);
 553         }
 554     }
 555 }
 556
 557 // ----------------------------------------------------------------------------
 558 // wxNotebook base class virtuals
 559 // ----------------------------------------------------------------------------
 560
 561 // override these 2 functions to do nothing: everything is done in OnSize
 562
 563 void wxNotebook::SetConstraintSizes(bool /* recurse */)
 564 {
 565     // don't set the sizes of the pages - their correct size is not yet known
 566     wxControl::SetConstraintSizes(false);
 567 }
 568
 569 bool wxNotebook::DoPhase(int /* nPhase */)
 570 {
 571     return true;
 572 }
 573
 574 void wxNotebook::Command(wxCommandEvent& WXUNUSED(event))
 575 {
 576     wxFAIL_MSG(wxT("wxNotebook::Command not implemented"));
 577 }
 578
 579 // ----------------------------------------------------------------------------
 580 // wxNotebook helper functions
 581 // ----------------------------------------------------------------------------
 582
 583 // hide the currently active panel and show the new one
 584 void wxNotebook::ChangePage(int nOldSel, int nSel)
 585 {
 586   //  cout << "ChangePage: " << nOldSel << ", " << nSel << "\n";
 587     wxASSERT( nOldSel != nSel ); // impossible
 588
 589     if ( nOldSel != -1 ) {
 590         m_pages[nOldSel]->Show(false);
 591         m_pages[nOldSel]->Lower();
 592     }
 593
 594     wxNotebookPage *pPage = m_pages[nSel];
 595
 596     wxRect clientRect = GetAvailableClientSize();
 597     pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
 598
 599     Refresh();
 600
 601     pPage->Show(true);
 602     pPage->Raise();
 603     pPage->SetFocus();
 604
 605     m_nSelection = nSel;
 606 }
 607
 608 void wxNotebook::OnMouseEvent(wxMouseEvent& event)
 609 {
 610   if (m_tabView)
 611     m_tabView->OnEvent(event);
 612 }
 613
 614 void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event) )
 615 {
 616     wxPaintDC dc(this);
 617     if (m_tabView)
 618         m_tabView->Draw(dc);
 619 }
 620
 621 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
 622 {
 623     // MBN: since the total tab height is really a function of the
 624     // width, this should really call
 625     // GetTotalTabHeightPretendingWidthIs(), but the current
 626     // implementation will suffice, provided the wxNotebook has been
 627     // created with a sensible initial width.
 628     return wxSize( sizePage.x + 12,
 629                    sizePage.y + m_tabView->GetTotalTabHeight() + 6 + 4 );
 630 }
 631
 632 wxRect wxNotebook::GetAvailableClientSize()
 633 {
 634     int cw, ch;
 635     GetClientSize(& cw, & ch);
 636
 637     int tabHeight = m_tabView->GetTotalTabHeight();
 638
 639     // TODO: these margins should be configurable.
 640     wxRect rect;
 641     rect.x = 6;
 642     rect.y = tabHeight + 6;
 643     rect.width = cw - 12;
 644     rect.height = ch - 4 - rect.y ;
 645
 646     return rect;
 647 }
 648
 649 /*
 650  * wxNotebookTabView
 651  */
 652
 653 IMPLEMENT_CLASS(wxNotebookTabView, wxTabView)
 654
 655 wxNotebookTabView::wxNotebookTabView(wxNotebook *notebook, long style): wxTabView(style)
 656 {
 657   m_notebook = notebook;
 658
 659   m_notebook->SetTabView(this);
 660
 661   SetWindow(m_notebook);
 662 }
 663
 664 wxNotebookTabView::~wxNotebookTabView(void)
 665 {
 666 }
 667
 668 // Called when a tab is activated
 669 void wxNotebookTabView::OnTabActivate(int activateId, int deactivateId)
 670 {
 671   if (!m_notebook)
 672     return;
 673
 674   wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_notebook->GetId());
 675
 676   // Translate from wxTabView's ids (which aren't position-dependent)
 677   // to wxNotebook's (which are).
 678   wxNotebookPage* pActive = (wxNotebookPage*) activateId;
 679   wxNotebookPage* pDeactive = (wxNotebookPage*) deactivateId;
 680
 681   int activatePos = m_notebook->FindPagePosition(pActive);
 682   int deactivatePos = m_notebook->FindPagePosition(pDeactive);
 683
 684   event.SetEventObject(m_notebook);
 685   event.SetSelection(activatePos);
 686   event.SetOldSelection(deactivatePos);
 687   m_notebook->GetEventHandler()->ProcessEvent(event);
 688 }
 689
 690 // Allows Vetoing
 691 bool wxNotebookTabView::OnTabPreActivate(int activateId, int deactivateId)
 692 {
 693   bool retval = true;
 694
 695   if (m_notebook)
 696   {
 697     wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_notebook->GetId());
 698
 699     // Translate from wxTabView's ids (which aren't position-dependent)
 700     // to wxNotebook's (which are).
 701     wxNotebookPage* pActive = (wxNotebookPage*) activateId;
 702     wxNotebookPage* pDeactive = (wxNotebookPage*) deactivateId;
 703
 704     int activatePos = m_notebook->FindPagePosition(pActive);
 705     int deactivatePos = m_notebook->FindPagePosition(pDeactive);
 706
 707     event.SetEventObject(m_notebook);
 708     event.SetSelection(activatePos);
 709     event.SetOldSelection(deactivatePos);
 710     if (m_notebook->GetEventHandler()->ProcessEvent(event))
 711     {
 712       retval = event.IsAllowed();
 713     }
 714   }
 715   return retval;
 716 }
 717
 718 #endif // __WXPALMOS__