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