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(m_imageList, false, "invalid notebook imagelist");
 281         const wxBitmap* bitmap = m_imageList->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     gtk_widget_unrealize( client->m_widget );
 356
 357     // we don't need to unparent the client->m_widget; GTK+ will do
 358     // that for us (and will throw a warning if we do it!)
 359     gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page );
 360
 361     // It's safe to remove the page now.
 362     wxASSERT_MSG(GetPage(page) == client, wxT("pages changed during delete"));
 363     wxNotebookBase::DoRemovePage(page);
 364
 365     wxGtkNotebookPage* p = GetNotebookPage(page);
 366     m_pagesData.DeleteObject(p);
 367     delete p;
 368
 369     return client;
 370 }
 371
 372 bool wxNotebook::InsertPage( size_t position,
 373                              wxNotebookPage* win,
 374                              const wxString& text,
 375                              bool select,
 376                              int imageId )
 377 {
 378     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") );
 379
 380     wxCHECK_MSG( win->GetParent() == this, false,
 381                wxT("Can't add a page whose parent is not the notebook!") );
 382
 383     wxCHECK_MSG( position <= GetPageCount(), false,
 384                  wxT("invalid page index in wxNotebookPage::InsertPage()") );
 385
 386     // Hack Alert! (Part II): See above in wxNotebook::AddChildGTK
 387     // why this has to be done.
 388     gtk_widget_unparent(win->m_widget);
 389
 390     if (m_themeEnabled)
 391         win->SetThemeEnabled(true);
 392
 393     GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
 394
 395     wxGtkNotebookPage* pageData = new wxGtkNotebookPage;
 396
 397     m_pages.Insert(win, position);
 398     m_pagesData.Insert(position, pageData);
 399
 400     // set the label image and text
 401     // this must be done before adding the page, as GetPageText
 402     // and GetPageImage will otherwise return wrong values in
 403     // the page-changed event that results from inserting the
 404     // first page.
 405     pageData->m_imageIndex = imageId;
 406
 407     pageData->m_box = gtk_hbox_new(false, 1);
 408     gtk_container_set_border_width(GTK_CONTAINER(pageData->m_box), 2);
 409
 410     pageData->m_image = NULL;
 411     if (imageId != -1)
 412     {
 413         if (m_imageList)
 414         {
 415             const wxBitmap* bitmap = m_imageList->GetBitmapPtr(imageId);
 416             pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf());
 417             gtk_box_pack_start(GTK_BOX(pageData->m_box),
 418                 pageData->m_image, false, false, m_padding);
 419         }
 420         else
 421             wxFAIL_MSG("invalid notebook imagelist");
 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         gtk_rc_style_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     return
 457         (pt.x >= w->allocation.x - x - border) &&
 458         (pt.x <= w->allocation.x - x + border + w->allocation.width) &&
 459         (pt.y >= w->allocation.y - y - border) &&
 460         (pt.y <= w->allocation.y - y + border + w->allocation.height);
 461 }
 462
 463 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 464 {
 465     const gint x = m_widget->allocation.x;
 466     const gint y = m_widget->allocation.y;
 467
 468     const size_t count = GetPageCount();
 469     size_t i = 0;
 470
 471     GtkNotebook * notebook = GTK_NOTEBOOK(m_widget);
 472     if (gtk_notebook_get_scrollable(notebook))
 473         i = g_list_position( notebook->children, notebook->first_tab );
 474
 475     for ( ; i < count; i++ )
 476     {
 477         wxGtkNotebookPage* pageData = GetNotebookPage(i);
 478         GtkWidget* box = pageData->m_box;
 479
 480         const gint border = gtk_container_get_border_width(GTK_CONTAINER(box));
 481
 482         if ( IsPointInsideWidget(pt, box, x, y, border) )
 483         {
 484             // ok, we're inside this tab -- now find out where, if needed
 485             if ( flags )
 486             {
 487                 if (pageData->m_image && IsPointInsideWidget(pt, pageData->m_image, x, y))
 488                 {
 489                     *flags = wxBK_HITTEST_ONICON;
 490                 }
 491                 else if (IsPointInsideWidget(pt, pageData->m_label, x, y))
 492                 {
 493                     *flags = wxBK_HITTEST_ONLABEL;
 494                 }
 495                 else
 496                 {
 497                     *flags = wxBK_HITTEST_ONITEM;
 498                 }
 499             }
 500
 501             return i;
 502         }
 503     }
 504
 505     if ( flags )
 506     {
 507         *flags = wxBK_HITTEST_NOWHERE;
 508         wxWindowBase * page = GetCurrentPage();
 509         if ( page )
 510         {
 511             // rect origin is in notebook's parent coordinates
 512             wxRect rect = page->GetRect();
 513
 514             // adjust it to the notebook's coordinates
 515             wxPoint pos = GetPosition();
 516             rect.x -= pos.x;
 517             rect.y -= pos.y;
 518             if ( rect.Contains( pt ) )
 519                 *flags |= wxBK_HITTEST_ONPAGE;
 520         }
 521     }
 522
 523     return wxNOT_FOUND;
 524 }
 525
 526 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 527 {
 528     if (event.IsWindowChange())
 529         AdvanceSelection( event.GetDirection() );
 530     else
 531         event.Skip();
 532 }
 533
 534 #if wxUSE_CONSTRAINTS
 535
 536 // override these 2 functions to do nothing: everything is done in OnSize
 537 void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
 538 {
 539     // don't set the sizes of the pages - their correct size is not yet known
 540     wxControl::SetConstraintSizes(false);
 541 }
 542
 543 bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
 544 {
 545     return true;
 546 }
 547
 548 #endif
 549
 550 void wxNotebook::DoApplyWidgetStyle(GtkRcStyle *style)
 551 {
 552     gtk_widget_modify_style(m_widget, style);
 553     for (size_t i = GetPageCount(); i--;)
 554         gtk_widget_modify_style(GetNotebookPage(i)->m_label, style);
 555 }
 556
 557 GdkWindow *wxNotebook::GTKGetWindow(wxArrayGdkWindows& windows) const
 558 {
 559     windows.push_back(m_widget->window);
 560     windows.push_back(GTK_NOTEBOOK(m_widget)->event_window);
 561
 562     return NULL;
 563 }
 564
 565 // static
 566 wxVisualAttributes
 567 wxNotebook::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 568 {
 569     return GetDefaultAttributesFromGTKWidget(gtk_notebook_new);
 570 }
 571
 572 #endif