src/gtk/notebook.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/notebook.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling, Vadim Zeitlin
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if wxUSE_NOTEBOOK
  14
  15 #include "wx/notebook.h"
  16
  17 #ifndef WX_PRECOMP
  18     #include "wx/intl.h"
  19     #include "wx/log.h"
  20     #include "wx/utils.h"
  21     #include "wx/msgdlg.h"
  22     #include "wx/bitmap.h"
  23 #endif
  24
  25 #include "wx/imaglist.h"
  26 #include "wx/fontutil.h"
  27
  28 #include "wx/gtk/private.h"
  29
  30 //-----------------------------------------------------------------------------
  31 // wxGtkNotebookPage
  32 //-----------------------------------------------------------------------------
  33
  34 // VZ: this is rather ugly as we keep the pages themselves in an array (it
  35 //     allows us to have quite a few functions implemented in the base class)
  36 //     but the page data is kept in a separate list, so we must maintain them
  37 //     in sync manually... of course, the list had been there before the base
  38 //     class which explains it but it still would be nice to do something
  39 //     about this one day
  40
  41 class wxGtkNotebookPage: public wxObject
  42 {
  43 public:
  44     GtkWidget* m_box;
  45     GtkWidget* m_label;
  46     GtkWidget* m_image;
  47     int m_imageIndex;
  48 };
  49
  50
  51 #include "wx/listimpl.cpp"
  52 WX_DEFINE_LIST(wxGtkNotebookPagesList)
  53
  54 extern "C" {
  55 static void event_after(GtkNotebook*, GdkEvent*, wxNotebook*);
  56 }
  57
  58 //-----------------------------------------------------------------------------
  59 // "switch_page"
  60 //-----------------------------------------------------------------------------
  61
  62 extern "C" {
  63 static void
  64 switch_page_after(GtkWidget* widget, GtkNotebookPage*, guint, wxNotebook* win)
  65 {
  66     g_signal_handlers_block_by_func(widget, (void*)switch_page_after, win);
  67     win->SendPageChangedEvent(win->m_oldSelection);
  68 }
  69 }
  70
  71 extern "C" {
  72 static void
  73 switch_page(GtkNotebook* widget, GtkNotebookPage*, int page, wxNotebook* win)
  74 {
  75     win->m_oldSelection = gtk_notebook_get_current_page(widget);
  76
  77     if (win->SendPageChangingEvent(page))
  78         // allow change, unblock handler for changed event
  79         g_signal_handlers_unblock_by_func(widget, (void*)switch_page_after, win);
  80     else
  81         // change vetoed, unblock handler to set selection back
  82         g_signal_handlers_unblock_by_func(widget, (void*)event_after, win);
  83 }
  84 }
  85
  86 //-----------------------------------------------------------------------------
  87 // "event_after" from m_widget
  88 //-----------------------------------------------------------------------------
  89
  90 extern "C" {
  91 static void event_after(GtkNotebook* widget, GdkEvent*, wxNotebook* win)
  92 {
  93     g_signal_handlers_block_by_func(widget, (void*)event_after, win);
  94     g_signal_handlers_block_by_func(widget, (void*)switch_page, win);
  95
  96     // restore previous selection
  97     gtk_notebook_set_current_page(widget, win->m_oldSelection);
  98
  99     g_signal_handlers_unblock_by_func(widget, (void*)switch_page, win);
 100 }
 101 }
 102
 103 //-----------------------------------------------------------------------------
 104 // InsertChild callback for wxNotebook
 105 //-----------------------------------------------------------------------------
 106
 107 void wxNotebook::AddChildGTK(wxWindowGTK* child)
 108 {
 109     // Hack Alert! (Part I): This sets the notebook as the parent of the child
 110     // widget, and takes care of some details such as updating the state and
 111     // style of the child to reflect its new location.  We do this early
 112     // because without it GetBestSize (which is used to set the initial size
 113     // of controls if an explicit size is not given) will often report
 114     // incorrect sizes since the widget's style context is not fully known.
 115     // See bug #901694 for details
 116     // (http://sourceforge.net/tracker/?func=detail&aid=901694&group_id=9863&atid=109863)
 117     gtk_widget_set_parent(child->m_widget, m_widget);
 118
 119     // NOTE: This should be considered a temporary workaround until we can
 120     // work out the details and implement delaying the setting of the initial
 121     // size of widgets until the size is really needed.
 122 }
 123
 124 //-----------------------------------------------------------------------------
 125 // wxNotebook
 126 //-----------------------------------------------------------------------------
 127
 128 IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxBookCtrlBase)
 129
 130 BEGIN_EVENT_TABLE(wxNotebook, wxBookCtrlBase)
 131     EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
 132 END_EVENT_TABLE()
 133
 134 void wxNotebook::Init()
 135 {
 136     m_padding = 0;
 137     m_oldSelection = -1;
 138     m_themeEnabled = true;
 139 }
 140
 141 wxNotebook::wxNotebook()
 142 {
 143     Init();
 144 }
 145
 146 wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
 147       const wxPoint& pos, const wxSize& size,
 148       long style, const wxString& name )
 149 {
 150     Init();
 151     Create( parent, id, pos, size, style, name );
 152 }
 153
 154 wxNotebook::~wxNotebook()
 155 {
 156     DeleteAllPages();
 157 }
 158
 159 bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
 160                         const wxPoint& pos, const wxSize& size,
 161                         long style, const wxString& name )
 162 {
 163     if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
 164         style |= wxBK_TOP;
 165
 166     if (!PreCreation( parent, pos, size ) ||
 167         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 168     {
 169         wxFAIL_MSG( wxT("wxNoteBook creation failed") );
 170         return false;
 171     }
 172
 173
 174     m_widget = gtk_notebook_new();
 175     g_object_ref(m_widget);
 176
 177     gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
 178
 179     g_signal_connect (m_widget, "switch_page",
 180                       G_CALLBACK(switch_page), this);
 181
 182     g_signal_connect_after (m_widget, "switch_page",
 183                       G_CALLBACK(switch_page_after), this);
 184     g_signal_handlers_block_by_func(m_widget, (void*)switch_page_after, this);
 185
 186     g_signal_connect(m_widget, "event_after", G_CALLBACK(event_after), this);
 187     g_signal_handlers_block_by_func(m_widget, (void*)event_after, this);
 188
 189     m_parent->DoAddChild( this );
 190
 191     if (m_windowStyle & wxBK_RIGHT)
 192         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT );
 193     if (m_windowStyle & wxBK_LEFT)
 194         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT );
 195     if (m_windowStyle & wxBK_BOTTOM)
 196         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM );
 197
 198     PostCreation(size);
 199
 200     return true;
 201 }
 202
 203 int wxNotebook::GetSelection() const
 204 {
 205     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
 206
 207     return gtk_notebook_get_current_page( GTK_NOTEBOOK(m_widget) );
 208 }
 209
 210 wxString wxNotebook::GetPageText( size_t page ) const
 211 {
 212     wxCHECK_MSG(page < GetPageCount(), wxEmptyString, "invalid notebook index");
 213
 214     GtkLabel* label = GTK_LABEL(GetNotebookPage(page)->m_label);
 215     return wxGTK_CONV_BACK(gtk_label_get_text(label));
 216 }
 217
 218 int wxNotebook::GetPageImage( size_t page ) const
 219 {
 220     wxCHECK_MSG(page < GetPageCount(), -1, "invalid notebook index");
 221
 222     return GetNotebookPage(page)->m_imageIndex;
 223 }
 224
 225 wxGtkNotebookPage* wxNotebook::GetNotebookPage( int page ) const
 226 {
 227     return m_pagesData.Item(page)->GetData();
 228 }
 229
 230 int wxNotebook::DoSetSelection( size_t page, int flags )
 231 {
 232     wxCHECK_MSG(page < GetPageCount(), -1, "invalid notebook index");
 233
 234     int selOld = GetSelection();
 235
 236     if ( !(flags & SetSelection_SendEvent) )
 237     {
 238         g_signal_handlers_block_by_func(m_widget, (void*)switch_page, this);
 239     }
 240
 241     gtk_notebook_set_current_page( GTK_NOTEBOOK(m_widget), page );
 242
 243     if ( !(flags & SetSelection_SendEvent) )
 244     {
 245         g_signal_handlers_unblock_by_func(m_widget, (void*)switch_page, this);
 246     }
 247
 248     wxNotebookPage *client = GetPage(page);
 249     if ( client )
 250         client->SetFocus();
 251
 252     return selOld;
 253 }
 254
 255 bool wxNotebook::SetPageText( size_t page, const wxString &text )
 256 {
 257     wxCHECK_MSG(page < GetPageCount(), false, "invalid notebook index");
 258
 259     GtkLabel* label = GTK_LABEL(GetNotebookPage(page)->m_label);
 260     gtk_label_set_text(label, wxGTK_CONV(text));
 261
 262     return true;
 263 }
 264
 265 bool wxNotebook::SetPageImage( size_t page, int image )
 266 {
 267     wxCHECK_MSG(page < GetPageCount(), false, "invalid notebook index");
 268
 269     wxGtkNotebookPage* pageData = GetNotebookPage(page);
 270     if (image >= 0)
 271     {
 272         wxCHECK_MSG(m_imageList, false, "invalid notebook imagelist");
 273         const wxBitmap* bitmap = m_imageList->GetBitmapPtr(image);
 274         if (bitmap == NULL)
 275             return false;
 276         if (pageData->m_image)
 277         {
 278             gtk_image_set_from_pixbuf(
 279                 GTK_IMAGE(pageData->m_image), bitmap->GetPixbuf());
 280         }
 281         else
 282         {
 283             pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf());
 284             gtk_widget_show(pageData->m_image);
 285             gtk_box_pack_start(GTK_BOX(pageData->m_box),
 286                 pageData->m_image, false, false, m_padding);
 287         }
 288     }
 289     else if (pageData->m_image)
 290     {
 291         gtk_widget_destroy(pageData->m_image);
 292         pageData->m_image = NULL;
 293     }
 294     pageData->m_imageIndex = image;
 295
 296     return true;
 297 }
 298
 299 void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
 300 {
 301     wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") );
 302 }
 303
 304 void wxNotebook::SetPadding( const wxSize &padding )
 305 {
 306     wxCHECK_RET( m_widget != NULL, wxT("invalid notebook") );
 307
 308     m_padding = padding.GetWidth();
 309
 310     for (size_t i = GetPageCount(); i--;)
 311     {
 312         wxGtkNotebookPage* pageData = GetNotebookPage(i);
 313         if (pageData->m_image)
 314         {
 315             gtk_box_set_child_packing(GTK_BOX(pageData->m_box),
 316                 pageData->m_image, false, false, m_padding, GTK_PACK_START);
 317         }
 318         gtk_box_set_child_packing(GTK_BOX(pageData->m_box),
 319             pageData->m_label, false, false, m_padding, GTK_PACK_END);
 320     }
 321 }
 322
 323 void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz))
 324 {
 325     wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") );
 326 }
 327
 328 bool wxNotebook::DeleteAllPages()
 329 {
 330     for (size_t i = GetPageCount(); i--;)
 331         DeletePage(i);
 332
 333     return wxNotebookBase::DeleteAllPages();
 334 }
 335
 336 wxNotebookPage *wxNotebook::DoRemovePage( size_t page )
 337 {
 338     // We cannot remove the page yet, as GTK sends the "switch_page"
 339     // signal before it has removed the notebook-page from its
 340     // corresponding list. Thus, if we were to remove the page from
 341     // m_pages at this point, the two lists of pages would be out
 342     // of sync during the PAGE_CHANGING/PAGE_CHANGED events.
 343     wxNotebookPage *client = GetPage(page);
 344     if ( !client )
 345         return NULL;
 346
 347     gtk_widget_unrealize( client->m_widget );
 348
 349     // we don't need to unparent the client->m_widget; GTK+ will do
 350     // that for us (and will throw a warning if we do it!)
 351     gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page );
 352
 353     // It's safe to remove the page now.
 354     wxASSERT_MSG(GetPage(page) == client, wxT("pages changed during delete"));
 355     wxNotebookBase::DoRemovePage(page);
 356
 357     wxGtkNotebookPage* p = GetNotebookPage(page);
 358     m_pagesData.DeleteObject(p);
 359     delete p;
 360
 361     return client;
 362 }
 363
 364 bool wxNotebook::InsertPage( size_t position,
 365                              wxNotebookPage* win,
 366                              const wxString& text,
 367                              bool select,
 368                              int imageId )
 369 {
 370     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") );
 371
 372     wxCHECK_MSG( win->GetParent() == this, false,
 373                wxT("Can't add a page whose parent is not the notebook!") );
 374
 375     wxCHECK_MSG( position <= GetPageCount(), false,
 376                  _T("invalid page index in wxNotebookPage::InsertPage()") );
 377
 378     // Hack Alert! (Part II): See above in wxNotebook::AddChildGTK
 379     // why this has to be done.
 380     gtk_widget_unparent(win->m_widget);
 381
 382     if (m_themeEnabled)
 383         win->SetThemeEnabled(true);
 384
 385     GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
 386
 387     wxGtkNotebookPage* pageData = new wxGtkNotebookPage;
 388
 389     m_pages.Insert(win, position);
 390     m_pagesData.Insert(position, pageData);
 391
 392     // set the label image and text
 393     // this must be done before adding the page, as GetPageText
 394     // and GetPageImage will otherwise return wrong values in
 395     // the page-changed event that results from inserting the
 396     // first page.
 397     pageData->m_imageIndex = imageId;
 398
 399     pageData->m_box = gtk_hbox_new(false, 1);
 400     gtk_container_set_border_width(GTK_CONTAINER(pageData->m_box), 2);
 401
 402     pageData->m_image = NULL;
 403     if (imageId != -1)
 404     {
 405         if (m_imageList)
 406         {
 407             const wxBitmap* bitmap = m_imageList->GetBitmapPtr(imageId);
 408             pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf());
 409             gtk_box_pack_start(GTK_BOX(pageData->m_box),
 410                 pageData->m_image, false, false, m_padding);
 411         }
 412         else
 413             wxFAIL_MSG("invalid notebook imagelist");
 414     }
 415
 416     /* set the label text */
 417     pageData->m_label = gtk_label_new(wxGTK_CONV(wxStripMenuCodes(text)));
 418     gtk_box_pack_end(GTK_BOX(pageData->m_box),
 419         pageData->m_label, false, false, m_padding);
 420
 421     gtk_widget_show_all(pageData->m_box);
 422     gtk_notebook_insert_page(notebook, win->m_widget, pageData->m_box, position);
 423
 424     /* apply current style */
 425     GtkRcStyle *style = CreateWidgetStyle();
 426     if ( style )
 427     {
 428         gtk_widget_modify_style(pageData->m_label, style);
 429         gtk_rc_style_unref(style);
 430     }
 431
 432     if (select && GetPageCount() > 1)
 433     {
 434         SetSelection( position );
 435     }
 436
 437     InvalidateBestSize();
 438     return true;
 439 }
 440
 441 // helper for HitTest(): check if the point lies inside the given widget which
 442 // is the child of the notebook whose position and border size are passed as
 443 // parameters
 444 static bool
 445 IsPointInsideWidget(const wxPoint& pt, GtkWidget *w,
 446                     gint x, gint y, gint border = 0)
 447 {
 448     return
 449         (pt.x >= w->allocation.x - x - border) &&
 450         (pt.x <= w->allocation.x - x + border + w->allocation.width) &&
 451         (pt.y >= w->allocation.y - y - border) &&
 452         (pt.y <= w->allocation.y - y + border + w->allocation.height);
 453 }
 454
 455 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 456 {
 457     const gint x = m_widget->allocation.x;
 458     const gint y = m_widget->allocation.y;
 459
 460     const size_t count = GetPageCount();
 461     size_t i = 0;
 462
 463     GtkNotebook * notebook = GTK_NOTEBOOK(m_widget);
 464     if (gtk_notebook_get_scrollable(notebook))
 465         i = g_list_position( notebook->children, notebook->first_tab );
 466
 467     for ( ; i < count; i++ )
 468     {
 469         wxGtkNotebookPage* pageData = GetNotebookPage(i);
 470         GtkWidget* box = pageData->m_box;
 471
 472         const gint border = gtk_container_get_border_width(GTK_CONTAINER(box));
 473
 474         if ( IsPointInsideWidget(pt, box, x, y, border) )
 475         {
 476             // ok, we're inside this tab -- now find out where, if needed
 477             if ( flags )
 478             {
 479                 if (pageData->m_image && IsPointInsideWidget(pt, pageData->m_image, x, y))
 480                 {
 481                     *flags = wxBK_HITTEST_ONICON;
 482                 }
 483                 else if (IsPointInsideWidget(pt, pageData->m_label, x, y))
 484                 {
 485                     *flags = wxBK_HITTEST_ONLABEL;
 486                 }
 487                 else
 488                 {
 489                     *flags = wxBK_HITTEST_ONITEM;
 490                 }
 491             }
 492
 493             return i;
 494         }
 495     }
 496
 497     if ( flags )
 498     {
 499         *flags = wxBK_HITTEST_NOWHERE;
 500         wxWindowBase * page = GetCurrentPage();
 501         if ( page )
 502         {
 503             // rect origin is in notebook's parent coordinates
 504             wxRect rect = page->GetRect();
 505
 506             // adjust it to the notebook's coordinates
 507             wxPoint pos = GetPosition();
 508             rect.x -= pos.x;
 509             rect.y -= pos.y;
 510             if ( rect.Contains( pt ) )
 511                 *flags |= wxBK_HITTEST_ONPAGE;
 512         }
 513     }
 514
 515     return wxNOT_FOUND;
 516 }
 517
 518 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 519 {
 520     if (event.IsWindowChange())
 521         AdvanceSelection( event.GetDirection() );
 522     else
 523         event.Skip();
 524 }
 525
 526 #if wxUSE_CONSTRAINTS
 527
 528 // override these 2 functions to do nothing: everything is done in OnSize
 529 void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
 530 {
 531     // don't set the sizes of the pages - their correct size is not yet known
 532     wxControl::SetConstraintSizes(false);
 533 }
 534
 535 bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
 536 {
 537     return true;
 538 }
 539
 540 #endif
 541
 542 void wxNotebook::DoApplyWidgetStyle(GtkRcStyle *style)
 543 {
 544     gtk_widget_modify_style(m_widget, style);
 545     for (size_t i = GetPageCount(); i--;)
 546         gtk_widget_modify_style(GetNotebookPage(i)->m_label, style);
 547 }
 548
 549 GdkWindow *wxNotebook::GTKGetWindow(wxArrayGdkWindows& windows) const
 550 {
 551     windows.push_back(m_widget->window);
 552     windows.push_back(GTK_NOTEBOOK(m_widget)->event_window);
 553
 554     return NULL;
 555 }
 556
 557 // static
 558 wxVisualAttributes
 559 wxNotebook::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 560 {
 561     return GetDefaultAttributesFromGTKWidget(gtk_notebook_new);
 562 }
 563
 564 #endif