src/gtk1/notebook.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  11 #pragma implementation "notebook.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #include "wx/notebook.h"
  18
  19 #if wxUSE_NOTEBOOK
  20
  21 #include "wx/panel.h"
  22 #include "wx/utils.h"
  23 #include "wx/imaglist.h"
  24 #include "wx/intl.h"
  25 #include "wx/log.h"
  26 #include "wx/bitmap.h"
  27 #include "wx/fontutil.h"
  28
  29 #include "wx/gtk/private.h"
  30 #include "wx/gtk/win_gtk.h"
  31
  32 #include <gdk/gdkkeysyms.h>
  33
  34 #include "wx/msgdlg.h"
  35
  36 // ----------------------------------------------------------------------------
  37 // events
  38 // ----------------------------------------------------------------------------
  39
  40 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
  41 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
  42
  43 //-----------------------------------------------------------------------------
  44 // idle system
  45 //-----------------------------------------------------------------------------
  46
  47 extern void wxapp_install_idle_handler();
  48 extern bool g_isIdle;
  49
  50 //-----------------------------------------------------------------------------
  51 // data
  52 //-----------------------------------------------------------------------------
  53
  54 extern bool g_blockEventsOnDrag;
  55
  56 //-----------------------------------------------------------------------------
  57 // wxGtkNotebookPage
  58 //-----------------------------------------------------------------------------
  59
  60 // VZ: this is rather ugly as we keep the pages themselves in an array (it
  61 //     allows us to have quite a few functions implemented in the base class)
  62 //     but the page data is kept in a separate list, so we must maintain them
  63 //     in sync manually... of course, the list had been there before the base
  64 //     class which explains it but it still would be nice to do something
  65 //     about this one day
  66
  67 class wxGtkNotebookPage: public wxObject
  68 {
  69 public:
  70     wxGtkNotebookPage()
  71     {
  72         m_image = -1;
  73         m_page = (GtkNotebookPage *) NULL;
  74         m_box = (GtkWidget *) NULL;
  75         m_labelStyle = (GtkStyle*) NULL;
  76     }
  77
  78     ~wxGtkNotebookPage()
  79     {
  80         if (m_labelStyle)
  81             gtk_style_unref( m_labelStyle );
  82     }
  83
  84     bool SetFont(const wxFont& font);
  85
  86     wxString           m_text;
  87     int                m_image;
  88     GtkNotebookPage   *m_page;
  89     GtkLabel          *m_label;
  90     GtkWidget         *m_box;     // in which the label and image are packed
  91     GtkStyle          *m_labelStyle;
  92 };
  93
  94
  95 bool wxGtkNotebookPage::SetFont(const wxFont& font)
  96 {
  97     if (!m_label)
  98                 return false;
  99
 100     if (m_labelStyle)
 101     {
 102         GtkStyle *remake = gtk_style_copy( m_labelStyle );
 103
 104 #ifndef __WXGTK20__
 105         remake->klass = m_labelStyle->klass;
 106 #endif
 107
 108         gtk_style_unref( m_labelStyle );
 109         m_labelStyle = remake;
 110     }
 111     else
 112     {
 113         GtkStyle *def = gtk_rc_get_style( GTK_WIDGET(m_label) );
 114
 115         if (!def)
 116             def = gtk_widget_get_default_style();
 117
 118         m_labelStyle = gtk_style_copy( def );
 119
 120         // FIXME: no more klass in 2.0
 121 #ifndef __WXGTK20__
 122         m_labelStyle->klass = def->klass;
 123 #endif
 124     }
 125
 126 #ifdef __WXGTK20__
 127         pango_font_description_free( m_labelStyle->font_desc );
 128         m_labelStyle->font_desc = pango_font_description_copy( font.GetNativeFontInfo()->description );
 129 #else
 130         gdk_font_unref( m_labelStyle->font );
 131         m_labelStyle->font = gdk_font_ref( font.GetInternalFont( 1.0 ) );
 132 #endif
 133
 134     gtk_widget_set_style( GTK_WIDGET(m_label), m_labelStyle );
 135
 136         return true;
 137 }
 138
 139
 140 #include "wx/listimpl.cpp"
 141 WX_DEFINE_LIST(wxGtkNotebookPagesList);
 142
 143
 144 //-----------------------------------------------------------------------------
 145 // "switch_page"
 146 //-----------------------------------------------------------------------------
 147
 148 static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget),
 149                                               GtkNotebookPage *WXUNUSED(page),
 150                                               gint page,
 151                                               wxNotebook *notebook )
 152 {
 153     // are you trying to call SetSelection() from a notebook event handler?
 154     // you shouldn't!
 155     wxCHECK_RET( !notebook->m_inSwitchPage,
 156                  _T("gtk_notebook_page_change_callback reentered") );
 157
 158     notebook->m_inSwitchPage = TRUE;
 159     if (g_isIdle)
 160         wxapp_install_idle_handler();
 161
 162     int old = notebook->GetSelection();
 163
 164     wxNotebookEvent eventChanging( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING,
 165                                    notebook->GetId(), page, old );
 166     eventChanging.SetEventObject( notebook );
 167
 168     if ( (notebook->GetEventHandler()->ProcessEvent(eventChanging)) &&
 169          !eventChanging.IsAllowed() )
 170     {
 171         /* program doesn't allow the page change */
 172         gtk_signal_emit_stop_by_name( GTK_OBJECT(notebook->m_widget),
 173                                       "switch_page" );
 174     }
 175     else // change allowed
 176     {
 177         // make wxNotebook::GetSelection() return the correct (i.e. consistent
 178         // with wxNotebookEvent::GetSelection()) value even though the page is
 179         // not really changed in GTK+
 180         notebook->m_selection = page;
 181
 182         wxNotebookEvent eventChanged( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
 183                                       notebook->GetId(), page, old );
 184         eventChanged.SetEventObject( notebook );
 185         notebook->GetEventHandler()->ProcessEvent( eventChanged );
 186     }
 187
 188     notebook->m_inSwitchPage = FALSE;
 189 }
 190
 191 //-----------------------------------------------------------------------------
 192 // "size_allocate"
 193 //-----------------------------------------------------------------------------
 194
 195 static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win )
 196 {
 197     if (g_isIdle)
 198         wxapp_install_idle_handler();
 199
 200     if ((win->m_x == alloc->x) &&
 201         (win->m_y == alloc->y) &&
 202         (win->m_width == alloc->width) &&
 203         (win->m_height == alloc->height))
 204     {
 205         return;
 206     }
 207
 208     win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
 209
 210     /* GTK 1.2 up to version 1.2.5 is broken so that we have to call allocate
 211        here in order to make repositioning after resizing to take effect. */
 212     if ((gtk_major_version == 1) &&
 213         (gtk_minor_version == 2) &&
 214         (gtk_micro_version < 6) &&
 215         (win->m_wxwindow) &&
 216         (GTK_WIDGET_REALIZED(win->m_wxwindow)))
 217     {
 218         gtk_widget_size_allocate( win->m_wxwindow, alloc );
 219     }
 220 }
 221
 222 //-----------------------------------------------------------------------------
 223 // "realize" from m_widget
 224 //-----------------------------------------------------------------------------
 225
 226 static gint
 227 gtk_notebook_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
 228 {
 229     if (g_isIdle)
 230         wxapp_install_idle_handler();
 231
 232     /* GTK 1.2 up to version 1.2.5 is broken so that we have to call a queue_resize
 233        here in order to make repositioning before showing to take effect. */
 234     gtk_widget_queue_resize( win->m_widget );
 235
 236     return FALSE;
 237 }
 238
 239 //-----------------------------------------------------------------------------
 240 // "key_press_event"
 241 //-----------------------------------------------------------------------------
 242
 243 static gint gtk_notebook_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxNotebook *win )
 244 {
 245     if (g_isIdle)
 246         wxapp_install_idle_handler();
 247
 248     if (!win->m_hasVMT) return FALSE;
 249     if (g_blockEventsOnDrag) return FALSE;
 250
 251     /* win is a control: tab can be propagated up */
 252     if ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab))
 253     {
 254         int sel = win->GetSelection();
 255         if (sel == -1)
 256             return TRUE;
 257         wxGtkNotebookPage *nb_page = win->GetNotebookPage(sel);
 258         wxCHECK_MSG( nb_page, FALSE, _T("invalid selection in wxNotebook") );
 259
 260         wxNavigationKeyEvent event;
 261         event.SetEventObject( win );
 262         /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
 263         event.SetDirection( (gdk_event->keyval == GDK_Tab) );
 264         /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
 265         event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
 266         event.SetCurrentFocus( win );
 267
 268         wxNotebookPage *client = win->GetPage(sel);
 269         if ( !client->GetEventHandler()->ProcessEvent( event ) )
 270         {
 271              client->SetFocus();
 272         }
 273
 274         gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
 275         return TRUE;
 276     }
 277
 278     return FALSE;
 279 }
 280
 281 //-----------------------------------------------------------------------------
 282 // InsertChild callback for wxNotebook
 283 //-----------------------------------------------------------------------------
 284
 285 static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
 286 {
 287     // Hack alert! We manually set the child window
 288     // parent field so that GTK can query the
 289     // notebook's style and font. Without that, GetBestSize could return
 290     // incorrect size, see bug #901694 for details
 291     // (http://sourceforge.net/tracker/?func=detail&aid=901694&group_id=9863&atid=109863)
 292     child->m_widget->parent = parent->m_widget;
 293 }
 294
 295 //-----------------------------------------------------------------------------
 296 // wxNotebook
 297 //-----------------------------------------------------------------------------
 298
 299 IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl)
 300
 301 BEGIN_EVENT_TABLE(wxNotebook, wxControl)
 302     EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
 303 END_EVENT_TABLE()
 304
 305 void wxNotebook::Init()
 306 {
 307     m_padding = 0;
 308     m_inSwitchPage = FALSE;
 309
 310     m_imageList = (wxImageList *) NULL;
 311     m_selection = -1;
 312     m_themeEnabled = TRUE;
 313 }
 314
 315 wxNotebook::wxNotebook()
 316 {
 317     Init();
 318 }
 319
 320 wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
 321       const wxPoint& pos, const wxSize& size,
 322       long style, const wxString& name )
 323 {
 324     Init();
 325     Create( parent, id, pos, size, style, name );
 326 }
 327
 328 wxNotebook::~wxNotebook()
 329 {
 330     DeleteAllPages();
 331 }
 332
 333 bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
 334                         const wxPoint& pos, const wxSize& size,
 335                         long style, const wxString& name )
 336 {
 337     m_needParent = TRUE;
 338     m_acceptsFocus = TRUE;
 339     m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook;
 340
 341     if (!PreCreation( parent, pos, size ) ||
 342         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 343     {
 344         wxFAIL_MSG( wxT("wxNoteBook creation failed") );
 345         return FALSE;
 346     }
 347
 348
 349     m_widget = gtk_notebook_new();
 350
 351     gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
 352
 353     gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
 354       GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
 355
 356     m_parent->DoAddChild( this );
 357
 358     if (m_windowStyle & wxNB_RIGHT)
 359         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT );
 360     if (m_windowStyle & wxNB_LEFT)
 361         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT );
 362     if (m_windowStyle & wxNB_BOTTOM)
 363         gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM );
 364
 365     gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
 366       GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );
 367
 368     PostCreation(size);
 369
 370     SetFont( parent->GetFont() );
 371
 372     gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
 373                             GTK_SIGNAL_FUNC(gtk_notebook_realized_callback), (gpointer) this );
 374
 375     return TRUE;
 376 }
 377
 378 int wxNotebook::GetSelection() const
 379 {
 380     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
 381
 382     if ( m_selection == -1 )
 383     {
 384         GList *nb_pages = GTK_NOTEBOOK(m_widget)->children;
 385
 386         if (g_list_length(nb_pages) != 0)
 387         {
 388             GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
 389
 390             gpointer cur = notebook->cur_page;
 391             if ( cur != NULL )
 392             {
 393                 wxConstCast(this, wxNotebook)->m_selection =
 394                     g_list_index( nb_pages, cur );
 395             }
 396         }
 397     }
 398
 399     return m_selection;
 400 }
 401
 402 wxString wxNotebook::GetPageText( size_t page ) const
 403 {
 404     wxCHECK_MSG( m_widget != NULL, wxT(""), wxT("invalid notebook") );
 405
 406     wxGtkNotebookPage* nb_page = GetNotebookPage(page);
 407     if (nb_page)
 408         return nb_page->m_text;
 409     else
 410         return wxT("");
 411 }
 412
 413 int wxNotebook::GetPageImage( size_t page ) const
 414 {
 415     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
 416
 417     wxGtkNotebookPage* nb_page = GetNotebookPage(page);
 418     if (nb_page)
 419         return nb_page->m_image;
 420     else
 421         return -1;
 422 }
 423
 424 wxGtkNotebookPage* wxNotebook::GetNotebookPage( int page ) const
 425 {
 426     wxCHECK_MSG( m_widget != NULL, (wxGtkNotebookPage*) NULL, wxT("invalid notebook") );
 427
 428     wxCHECK_MSG( page < (int)m_pagesData.GetCount(), (wxGtkNotebookPage*) NULL, wxT("invalid notebook index") );
 429
 430     return m_pagesData.Item(page)->GetData();
 431 }
 432
 433 int wxNotebook::SetSelection( size_t page )
 434 {
 435     wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
 436
 437     wxCHECK_MSG( page < m_pagesData.GetCount(), -1, wxT("invalid notebook index") );
 438
 439     int selOld = GetSelection();
 440
 441     // cache the selection
 442     m_selection = page;
 443     gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page );
 444
 445     wxNotebookPage *client = GetPage(page);
 446     if ( client )
 447         client->SetFocus();
 448
 449     return selOld;
 450 }
 451
 452 bool wxNotebook::SetPageText( size_t page, const wxString &text )
 453 {
 454     wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") );
 455
 456     wxGtkNotebookPage* nb_page = GetNotebookPage(page);
 457
 458     wxCHECK_MSG( nb_page, FALSE, wxT("SetPageText: invalid page index") );
 459
 460     nb_page->m_text = text;
 461
 462     gtk_label_set( nb_page->m_label, wxGTK_CONV( nb_page->m_text ) );
 463
 464     return TRUE;
 465 }
 466
 467 bool wxNotebook::SetPageImage( size_t page, int image )
 468 {
 469     /* HvdH 28-12-98: now it works, but it's a bit of a kludge */
 470
 471     wxGtkNotebookPage* nb_page = GetNotebookPage(page);
 472
 473     if (!nb_page) return FALSE;
 474
 475     /* Optimization posibility: return immediately if image unchanged.
 476      * Not enabled because it may break existing (stupid) code that
 477      * manipulates the imagelist to cycle images */
 478
 479     /* if (image == nb_page->m_image) return TRUE; */
 480
 481     /* For different cases:
 482        1) no image -> no image
 483        2) image -> no image
 484        3) no image -> image
 485        4) image -> image */
 486
 487     if (image == -1 && nb_page->m_image == -1)
 488         return TRUE; /* Case 1): Nothing to do. */
 489
 490     GtkWidget *pixmapwid = (GtkWidget*) NULL;
 491
 492     if (nb_page->m_image != -1)
 493     {
 494         /* Case 2) or 4). There is already an image in the gtkhbox. Let's find it */
 495
 496         GList *child = gtk_container_children(GTK_CONTAINER(nb_page->m_box));
 497         while (child)
 498         {
 499             if (GTK_IS_PIXMAP(child->data))
 500             {
 501                 pixmapwid = GTK_WIDGET(child->data);
 502                 break;
 503             }
 504             child = child->next;
 505         }
 506
 507         /* We should have the pixmap widget now */
 508         wxASSERT(pixmapwid != NULL);
 509
 510         if (image == -1)
 511         {
 512             /* If there's no new widget, just remove the old from the box */
 513             gtk_container_remove(GTK_CONTAINER(nb_page->m_box), pixmapwid);
 514             nb_page->m_image = -1;
 515
 516             return TRUE; /* Case 2) */
 517         }
 518     }
 519
 520     /* Only cases 3) and 4) left */
 521     wxASSERT( m_imageList != NULL ); /* Just in case */
 522
 523     /* Construct the new pixmap */
 524     const wxBitmap *bmp = m_imageList->GetBitmap(image);
 525     GdkPixmap *pixmap = bmp->GetPixmap();
 526     GdkBitmap *mask = (GdkBitmap*) NULL;
 527     if ( bmp->GetMask() )
 528     {
 529         mask = bmp->GetMask()->GetBitmap();
 530     }
 531
 532     if (pixmapwid == NULL)
 533     {
 534         /* Case 3) No old pixmap. Create a new one and prepend it to the hbox */
 535         pixmapwid = gtk_pixmap_new (pixmap, mask );
 536
 537         /* CHECKME: Are these pack flags okay? */
 538         gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding);
 539         gtk_widget_show(pixmapwid);
 540     }
 541     else
 542     {
 543         /* Case 4) Simply replace the pixmap */
 544         gtk_pixmap_set(GTK_PIXMAP(pixmapwid), pixmap, mask);
 545     }
 546
 547     nb_page->m_image = image;
 548
 549     return TRUE;
 550 }
 551
 552 void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
 553 {
 554     wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") );
 555 }
 556
 557 void wxNotebook::SetPadding( const wxSize &padding )
 558 {
 559     wxCHECK_RET( m_widget != NULL, wxT("invalid notebook") );
 560
 561     m_padding = padding.GetWidth();
 562
 563     int i;
 564     for (i=0; i<int(GetPageCount()); i++)
 565     {
 566         wxGtkNotebookPage* nb_page = GetNotebookPage(i);
 567         wxASSERT(nb_page != NULL);
 568
 569         if (nb_page->m_image != -1)
 570         {
 571             // gtk_box_set_child_packing sets padding on BOTH sides
 572             // icon provides left padding, label provides center and right
 573             int image = nb_page->m_image;
 574             SetPageImage(i,-1);
 575             SetPageImage(i,image);
 576         }
 577         wxASSERT(nb_page->m_label);
 578         gtk_box_set_child_packing(GTK_BOX(nb_page->m_box),
 579                                   GTK_WIDGET(nb_page->m_label),
 580                                   FALSE, FALSE, m_padding, GTK_PACK_END);
 581     }
 582 }
 583
 584 void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz))
 585 {
 586     wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") );
 587 }
 588
 589 bool wxNotebook::DeleteAllPages()
 590 {
 591     wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") );
 592
 593     while (m_pagesData.GetCount() > 0)
 594         DeletePage( m_pagesData.GetCount()-1 );
 595
 596     wxASSERT_MSG( GetPageCount() == 0, _T("all pages must have been deleted") );
 597
 598     return wxNotebookBase::DeleteAllPages();
 599 }
 600
 601 bool wxNotebook::DeletePage( size_t page )
 602 {
 603     if ( m_selection == (int)m_pagesData.GetCount() - 1 )
 604     {
 605         // the index will become invalid after the page is deleted
 606         m_selection = -1;
 607     }
 608
 609     // it will call our DoRemovePage() to do the real work
 610     return wxNotebookBase::DeletePage(page);
 611 }
 612
 613 wxNotebookPage *wxNotebook::DoRemovePage( size_t page )
 614 {
 615     wxNotebookPage *client = wxNotebookBase::DoRemovePage(page);
 616     if ( !client )
 617         return NULL;
 618
 619     gtk_widget_ref( client->m_widget );
 620     gtk_widget_unrealize( client->m_widget );
 621     gtk_widget_unparent( client->m_widget );
 622
 623     // gtk_notebook_remove_page() sends "switch_page" signal with some strange
 624     // new page index (when deleting selected page 0, new page is 1 although,
 625     // clearly, the selection should stay 0), so suppress this
 626     gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
 627       GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this );
 628
 629     gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page );
 630
 631     gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
 632       GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
 633
 634     wxGtkNotebookPage* p = GetNotebookPage(page);
 635     m_pagesData.DeleteObject(p);
 636     delete p;
 637
 638     return client;
 639 }
 640
 641 bool wxNotebook::InsertPage( size_t position,
 642                              wxNotebookPage* win,
 643                              const wxString& text,
 644                              bool select,
 645                              int imageId )
 646 {
 647     wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") );
 648
 649     wxCHECK_MSG( win->GetParent() == this, FALSE,
 650                wxT("Can't add a page whose parent is not the notebook!") );
 651
 652     wxCHECK_MSG( position <= GetPageCount(), FALSE,
 653                  _T("invalid page index in wxNotebookPage::InsertPage()") );
 654
 655     // Hack alert part II! See above in InsertChildInNotebook
 656     // callback why this has to be done.
 657     win->m_widget->parent = NULL;
 658
 659     // don't receive switch page during addition
 660     gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
 661       GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this );
 662
 663     if (m_themeEnabled)
 664         win->SetThemeEnabled(TRUE);
 665
 666     GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
 667
 668     wxGtkNotebookPage *nb_page = new wxGtkNotebookPage();
 669
 670     if ( position == GetPageCount() )
 671         m_pagesData.Append( nb_page );
 672     else
 673         m_pagesData.Insert( m_pagesData.Item( position ), nb_page );
 674
 675     m_pages.Insert(win, position);
 676
 677     nb_page->m_box = gtk_hbox_new( FALSE, 1 );
 678     gtk_container_border_width( GTK_CONTAINER(nb_page->m_box), 2 );
 679
 680     gtk_signal_connect( GTK_OBJECT(win->m_widget), "size_allocate",
 681       GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)win );
 682
 683 #ifndef __VMS
 684    // On VMS position is unsigned and thus always positive
 685    if (position < 0)
 686         gtk_notebook_append_page( notebook, win->m_widget, nb_page->m_box );
 687     else
 688 #endif
 689      gtk_notebook_insert_page( notebook, win->m_widget, nb_page->m_box, position );
 690
 691     nb_page->m_page = (GtkNotebookPage*) g_list_last(notebook->children)->data;
 692
 693     /* set the label image */
 694     nb_page->m_image = imageId;
 695
 696     if (imageId != -1)
 697     {
 698         wxASSERT( m_imageList != NULL );
 699
 700         const wxBitmap *bmp = m_imageList->GetBitmap(imageId);
 701         GdkPixmap *pixmap = bmp->GetPixmap();
 702         GdkBitmap *mask = (GdkBitmap*) NULL;
 703         if ( bmp->GetMask() )
 704         {
 705             mask = bmp->GetMask()->GetBitmap();
 706         }
 707
 708         GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask );
 709
 710         gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding);
 711
 712         gtk_widget_show(pixmapwid);
 713     }
 714
 715     /* set the label text */
 716
 717     nb_page->m_text = text;
 718     if (nb_page->m_text.IsEmpty()) nb_page->m_text = wxT("");
 719
 720     nb_page->m_label = GTK_LABEL( gtk_label_new(wxGTK_CONV(nb_page->m_text)) );
 721         nb_page->SetFont(GetFont());
 722     gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding );
 723
 724     /* show the label */
 725     gtk_widget_show( GTK_WIDGET(nb_page->m_label) );
 726     if (select && (m_pagesData.GetCount() > 1))
 727     {
 728 #ifndef __VMS
 729    // On VMS position is unsigned and thus always positive
 730         if (position < 0)
 731             SetSelection( GetPageCount()-1 );
 732         else
 733 #endif
 734             SetSelection( position );
 735     }
 736
 737     gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
 738       GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
 739
 740     return TRUE;
 741 }
 742
 743 // helper for HitTest(): check if the point lies inside the given widget which
 744 // is the child of the notebook whose position and border size are passed as
 745 // parameters
 746 static bool
 747 IsPointInsideWidget(const wxPoint& pt, GtkWidget *w,
 748                     gint x, gint y, gint border = 0)
 749 {
 750     return
 751         (pt.x >= w->allocation.x - x - border) &&
 752         (pt.x <= w->allocation.x - x + border + w->allocation.width) &&
 753         (pt.y >= w->allocation.y - y - border) &&
 754         (pt.y <= w->allocation.y - y + border + w->allocation.height);
 755 }
 756
 757 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 758 {
 759     const gint x = m_widget->allocation.x;
 760     const gint y = m_widget->allocation.y;
 761
 762     const size_t count = GetPageCount();
 763     for ( size_t i = 0; i < count; i++ )
 764     {
 765         wxGtkNotebookPage* nb_page = GetNotebookPage(i);
 766         GtkWidget *box = nb_page->m_box;
 767
 768         // VZ: don't know how to find the border width in GTK+ 1.2
 769 #ifdef __WXGTK20__
 770         const gint border = gtk_container_get_border_width(GTK_CONTAINER(box));
 771 #else // !GTK+ 2.x
 772         const gint border = 0;
 773 #endif
 774         if ( IsPointInsideWidget(pt, box, x, y, border) )
 775         {
 776             // ok, we're inside this tab -- now find out where, if needed
 777             if ( flags )
 778             {
 779                 GtkWidget *pixmap = NULL;
 780
 781                 GList *children = gtk_container_children(GTK_CONTAINER(box));
 782                 for ( GList *child = children; child; child = child->next )
 783                 {
 784                     if ( GTK_IS_PIXMAP(child->data) )
 785                     {
 786                         pixmap = GTK_WIDGET(child->data);
 787                         break;
 788                     }
 789                 }
 790
 791                 if ( children )
 792                     g_list_free(children);
 793
 794                 if ( pixmap && IsPointInsideWidget(pt, pixmap, x, y) )
 795                 {
 796                     *flags = wxNB_HITTEST_ONICON;
 797                 }
 798                 else if ( IsPointInsideWidget(pt, GTK_WIDGET(nb_page->m_label), x, y) )
 799                 {
 800                     *flags = wxNB_HITTEST_ONLABEL;
 801                 }
 802                 else
 803                 {
 804                     *flags = wxNB_HITTEST_ONITEM;
 805                 }
 806             }
 807
 808             return i;
 809         }
 810     }
 811
 812     if ( flags )
 813         *flags = wxNB_HITTEST_NOWHERE;
 814
 815     return wxNOT_FOUND;
 816 }
 817
 818 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 819 {
 820     if (event.IsWindowChange())
 821         AdvanceSelection( event.GetDirection() );
 822     else
 823         event.Skip();
 824 }
 825
 826 #if wxUSE_CONSTRAINTS
 827
 828 // override these 2 functions to do nothing: everything is done in OnSize
 829 void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
 830 {
 831     // don't set the sizes of the pages - their correct size is not yet known
 832     wxControl::SetConstraintSizes(FALSE);
 833 }
 834
 835 bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
 836 {
 837     return TRUE;
 838 }
 839
 840 #endif
 841
 842 void wxNotebook::ApplyWidgetStyle()
 843 {
 844     // TODO, font for labels etc
 845
 846     SetWidgetStyle();
 847     gtk_widget_set_style( m_widget, m_widgetStyle );
 848 }
 849
 850 bool wxNotebook::IsOwnGtkWindow( GdkWindow *window )
 851 {
 852     return ((m_widget->window == window) ||
 853             (NOTEBOOK_PANEL(m_widget) == window));
 854 }
 855
 856 bool  wxNotebook::SetFont(const wxFont& font)
 857 {
 858         bool rc=wxNotebookBase::SetFont(font);
 859
 860         if (rc)
 861         {
 862                 size_t i;
 863                 for (i=0 ; i < m_pagesData.GetCount() ; i++)
 864                         GetNotebookPage(i)->SetFont(font);
 865         }
 866         return rc;
 867 }
 868
 869 // static
 870 wxVisualAttributes
 871 wxNotebook::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 872 {
 873     return GetDefaultAttributesFromGTKWidget(gtk_notebook_new);
 874 }
 875
 876 //-----------------------------------------------------------------------------
 877 // wxNotebookEvent
 878 //-----------------------------------------------------------------------------
 879
 880 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
 881
 882 #endif