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 static void wxInsertChildInNotebook(wxWindow* parent, wxWindow* 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, parent->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     m_insertCallback = wxInsertChildInNotebook;
 164
 165     if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
 166         style |= wxBK_TOP;
 167
 168     if (!PreCreation( parent, pos, size ) ||
 169         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 170     {
 171         wxFAIL_MSG( wxT("wxNoteBook creation failed") );
 172         return false;
 173     }
 174
 175
 176     m_widget = gtk_notebook_new();
 177
 178     gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
 179
 180     g_signal_connect (m_widget, "switch_page",
 181                       G_CALLBACK(switch_page), this);
 182
 183     g_signal_connect_after (m_widget, "switch_page",
 184                       G_CALLBACK(switch_page_after), this);
 185     g_signal_handlers_block_by_func(m_widget, (void*)switch_page_after, this);
 186
 187     g_signal_connect(m_widget, "event_after", G_CALLBACK(event_after), this);
 188     g_signal_handlers_block_by_func(m_widget, (void*)event_after, this);
 189
 190     m_parent->DoAddChild( this );
 191
 192     if (m_windowStyle & wxBK_RIGHT)
 193         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT );
 194     if (m_windowStyle & wxBK_LEFT)
 195         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT );
 196     if (m_windowStyle & wxBK_BOTTOM)
 197         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM );
 198
 199     PostCreation(size);
 200
 201     return true;
 202 }
 203
 204 int wxNotebook::GetSelection() const
 205 {
 206     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
 207
 208     return gtk_notebook_get_current_page( GTK_NOTEBOOK(m_widget) );
 209 }
 210
 211 wxString wxNotebook::GetPageText( size_t page ) const
 212 {
 213     wxCHECK_MSG(page < GetPageCount(), wxEmptyString, "invalid notebook index");
 214
 215     GtkLabel* label = GTK_LABEL(GetNotebookPage(page)->m_label);
 216     return wxGTK_CONV_BACK(gtk_label_get_text(label));
 217 }
 218
 219 int wxNotebook::GetPageImage( size_t page ) const
 220 {
 221     wxCHECK_MSG(page < GetPageCount(), -1, "invalid notebook index");
 222
 223     return GetNotebookPage(page)->m_imageIndex;
 224 }
 225
 226 wxGtkNotebookPage* wxNotebook::GetNotebookPage( int page ) const
 227 {
 228     return m_pagesData.Item(page)->GetData();
 229 }
 230
 231 int wxNotebook::DoSetSelection( size_t page, int flags )
 232 {
 233     wxCHECK_MSG(page < GetPageCount(), -1, "invalid notebook index");
 234
 235     int selOld = GetSelection();
 236
 237     if ( !(flags & SetSelection_SendEvent) )
 238     {
 239         g_signal_handlers_block_by_func(m_widget, (void*)switch_page, this);
 240     }
 241
 242     gtk_notebook_set_current_page( GTK_NOTEBOOK(m_widget), page );
 243
 244     if ( !(flags & SetSelection_SendEvent) )
 245     {
 246         g_signal_handlers_unblock_by_func(m_widget, (void*)switch_page, this);
 247     }
 248
 249     wxNotebookPage *client = GetPage(page);
 250     if ( client )
 251         client->SetFocus();
 252
 253     return selOld;
 254 }
 255
 256 bool wxNotebook::SetPageText( size_t page, const wxString &text )
 257 {
 258     wxCHECK_MSG(page < GetPageCount(), false, "invalid notebook index");
 259
 260     GtkLabel* label = GTK_LABEL(GetNotebookPage(page)->m_label);
 261     gtk_label_set_text(label, wxGTK_CONV(text));
 262
 263     return true;
 264 }
 265
 266 bool wxNotebook::SetPageImage( size_t page, int image )
 267 {
 268     wxCHECK_MSG(page < GetPageCount(), false, "invalid notebook index");
 269
 270     wxGtkNotebookPage* pageData = GetNotebookPage(page);
 271     if (image >= 0)
 272     {
 273         wxCHECK_MSG(m_imageList, false, "invalid notebook imagelist");
 274         const wxBitmap* bitmap = m_imageList->GetBitmapPtr(image);
 275         if (bitmap == NULL)
 276             return false;
 277         if (pageData->m_image)
 278         {
 279             gtk_image_set_from_pixbuf(
 280                 GTK_IMAGE(pageData->m_image), bitmap->GetPixbuf());
 281         }
 282         else
 283         {
 284             pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf());
 285             gtk_widget_show(pageData->m_image);
 286             gtk_box_pack_start(GTK_BOX(pageData->m_box),
 287                 pageData->m_image, false, false, m_padding);
 288         }
 289     }
 290     else if (pageData->m_image)
 291     {
 292         gtk_widget_destroy(pageData->m_image);
 293         pageData->m_image = NULL;
 294     }
 295     pageData->m_imageIndex = image;
 296
 297     return true;
 298 }
 299
 300 void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
 301 {
 302     wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") );
 303 }
 304
 305 void wxNotebook::SetPadding( const wxSize &padding )
 306 {
 307     wxCHECK_RET( m_widget != NULL, wxT("invalid notebook") );
 308
 309     m_padding = padding.GetWidth();
 310
 311     for (size_t i = GetPageCount(); i--;)
 312     {
 313         wxGtkNotebookPage* pageData = GetNotebookPage(i);
 314         if (pageData->m_image)
 315         {
 316             gtk_box_set_child_packing(GTK_BOX(pageData->m_box),
 317                 pageData->m_image, false, false, m_padding, GTK_PACK_START);
 318         }
 319         gtk_box_set_child_packing(GTK_BOX(pageData->m_box),
 320             pageData->m_label, false, false, m_padding, GTK_PACK_END);
 321     }
 322 }
 323
 324 void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz))
 325 {
 326     wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") );
 327 }
 328
 329 bool wxNotebook::DeleteAllPages()
 330 {
 331     for (size_t i = GetPageCount(); i--;)
 332         DeletePage(i);
 333
 334     return wxNotebookBase::DeleteAllPages();
 335 }
 336
 337 wxNotebookPage *wxNotebook::DoRemovePage( size_t page )
 338 {
 339     // We cannot remove the page yet, as GTK sends the "switch_page"
 340     // signal before it has removed the notebook-page from its
 341     // corresponding list. Thus, if we were to remove the page from
 342     // m_pages at this point, the two lists of pages would be out
 343     // of sync during the PAGE_CHANGING/PAGE_CHANGED events.
 344     wxNotebookPage *client = GetPage(page);
 345     if ( !client )
 346         return NULL;
 347
 348     gtk_widget_ref( client->m_widget );
 349     gtk_widget_unrealize( client->m_widget );
 350
 351     // we don't need to unparent the client->m_widget; GTK+ will do
 352     // that for us (and will throw a warning if we do it!)
 353     gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page );
 354
 355     // It's safe to remove the page now.
 356     wxASSERT_MSG(GetPage(page) == client, wxT("pages changed during delete"));
 357     wxNotebookBase::DoRemovePage(page);
 358
 359     wxGtkNotebookPage* p = GetNotebookPage(page);
 360     m_pagesData.DeleteObject(p);
 361     delete p;
 362
 363     return client;
 364 }
 365
 366 bool wxNotebook::InsertPage( size_t position,
 367                              wxNotebookPage* win,
 368                              const wxString& text,
 369                              bool select,
 370                              int imageId )
 371 {
 372     wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") );
 373
 374     wxCHECK_MSG( win->GetParent() == this, false,
 375                wxT("Can't add a page whose parent is not the notebook!") );
 376
 377     wxCHECK_MSG( position <= GetPageCount(), false,
 378                  _T("invalid page index in wxNotebookPage::InsertPage()") );
 379
 380     // Hack Alert! (Part II): See above in wxInsertChildInNotebook callback
 381     // why this has to be done.  NOTE: using gtk_widget_unparent here does not
 382     // work as it seems to undo too much and will cause errors in the
 383     // gtk_notebook_insert_page below, so instead just clear the parent by
 384     // hand here.
 385     win->m_widget->parent = NULL;
 386
 387     if (m_themeEnabled)
 388         win->SetThemeEnabled(true);
 389
 390     GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
 391
 392     wxGtkNotebookPage* pageData = new wxGtkNotebookPage;
 393
 394     m_pages.Insert(win, position);
 395     m_pagesData.Insert(position, pageData);
 396
 397     // set the label image and text
 398     // this must be done before adding the page, as GetPageText
 399     // and GetPageImage will otherwise return wrong values in
 400     // the page-changed event that results from inserting the
 401     // first page.
 402     pageData->m_imageIndex = imageId;
 403
 404     pageData->m_box = gtk_hbox_new(false, 1);
 405     gtk_container_set_border_width(GTK_CONTAINER(pageData->m_box), 2);
 406
 407     pageData->m_image = NULL;
 408     if (imageId != -1)
 409     {
 410         if (m_imageList)
 411         {
 412             const wxBitmap* bitmap = m_imageList->GetBitmapPtr(imageId);
 413             pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf());
 414             gtk_box_pack_start(GTK_BOX(pageData->m_box),
 415                 pageData->m_image, false, false, m_padding);
 416         }
 417         else
 418             wxFAIL_MSG("invalid notebook imagelist");
 419     }
 420
 421     /* set the label text */
 422     pageData->m_label = gtk_label_new(wxGTK_CONV(wxStripMenuCodes(text)));
 423     gtk_box_pack_end(GTK_BOX(pageData->m_box),
 424         pageData->m_label, false, false, m_padding);
 425
 426     gtk_widget_show_all(pageData->m_box);
 427     gtk_notebook_insert_page(notebook, win->m_widget, pageData->m_box, position);
 428
 429     /* apply current style */
 430     GtkRcStyle *style = CreateWidgetStyle();
 431     if ( style )
 432     {
 433         gtk_widget_modify_style(pageData->m_label, style);
 434         gtk_rc_style_unref(style);
 435     }
 436
 437     if (select && GetPageCount() > 1)
 438     {
 439         SetSelection( position );
 440     }
 441
 442     InvalidateBestSize();
 443     return true;
 444 }
 445
 446 // helper for HitTest(): check if the point lies inside the given widget which
 447 // is the child of the notebook whose position and border size are passed as
 448 // parameters
 449 static bool
 450 IsPointInsideWidget(const wxPoint& pt, GtkWidget *w,
 451                     gint x, gint y, gint border = 0)
 452 {
 453     return
 454         (pt.x >= w->allocation.x - x - border) &&
 455         (pt.x <= w->allocation.x - x + border + w->allocation.width) &&
 456         (pt.y >= w->allocation.y - y - border) &&
 457         (pt.y <= w->allocation.y - y + border + w->allocation.height);
 458 }
 459
 460 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 461 {
 462     const gint x = m_widget->allocation.x;
 463     const gint y = m_widget->allocation.y;
 464
 465     const size_t count = GetPageCount();
 466     size_t i = 0;
 467
 468     GtkNotebook * notebook = GTK_NOTEBOOK(m_widget);
 469     if (gtk_notebook_get_scrollable(notebook))
 470         i = g_list_position( notebook->children, notebook->first_tab );
 471
 472     for ( ; i < count; i++ )
 473     {
 474         wxGtkNotebookPage* pageData = GetNotebookPage(i);
 475         GtkWidget* box = pageData->m_box;
 476
 477         const gint border = gtk_container_get_border_width(GTK_CONTAINER(box));
 478
 479         if ( IsPointInsideWidget(pt, box, x, y, border) )
 480         {
 481             // ok, we're inside this tab -- now find out where, if needed
 482             if ( flags )
 483             {
 484                 if (pageData->m_image && IsPointInsideWidget(pt, pageData->m_image, x, y))
 485                 {
 486                     *flags = wxBK_HITTEST_ONICON;
 487                 }
 488                 else if (IsPointInsideWidget(pt, pageData->m_label, x, y))
 489                 {
 490                     *flags = wxBK_HITTEST_ONLABEL;
 491                 }
 492                 else
 493                 {
 494                     *flags = wxBK_HITTEST_ONITEM;
 495                 }
 496             }
 497
 498             return i;
 499         }
 500     }
 501
 502     if ( flags )
 503     {
 504         *flags = wxBK_HITTEST_NOWHERE;
 505         wxWindowBase * page = GetCurrentPage();
 506         if ( page )
 507         {
 508             // rect origin is in notebook's parent coordinates
 509             wxRect rect = page->GetRect();
 510
 511             // adjust it to the notebook's coordinates
 512             wxPoint pos = GetPosition();
 513             rect.x -= pos.x;
 514             rect.y -= pos.y;
 515             if ( rect.Contains( pt ) )
 516                 *flags |= wxBK_HITTEST_ONPAGE;
 517         }
 518     }
 519
 520     return wxNOT_FOUND;
 521 }
 522
 523 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 524 {
 525     if (event.IsWindowChange())
 526         AdvanceSelection( event.GetDirection() );
 527     else
 528         event.Skip();
 529 }
 530
 531 #if wxUSE_CONSTRAINTS
 532
 533 // override these 2 functions to do nothing: everything is done in OnSize
 534 void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
 535 {
 536     // don't set the sizes of the pages - their correct size is not yet known
 537     wxControl::SetConstraintSizes(false);
 538 }
 539
 540 bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
 541 {
 542     return true;
 543 }
 544
 545 #endif
 546
 547 void wxNotebook::DoApplyWidgetStyle(GtkRcStyle *style)
 548 {
 549     gtk_widget_modify_style(m_widget, style);
 550     for (size_t i = GetPageCount(); i--;)
 551         gtk_widget_modify_style(GetNotebookPage(i)->m_label, style);
 552 }
 553
 554 GdkWindow *wxNotebook::GTKGetWindow(wxArrayGdkWindows& windows) const
 555 {
 556     windows.push_back(m_widget->window);
 557     windows.push_back(GTK_NOTEBOOK(m_widget)->event_window);
 558
 559     return NULL;
 560 }
 561
 562 // static
 563 wxVisualAttributes
 564 wxNotebook::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 565 {
 566     return GetDefaultAttributesFromGTKWidget(gtk_notebook_new);
 567 }
 568
 569 #endif