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