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