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