]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/notebook.cpp
fixed variable shadowing icc warnings
[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 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #include "wx/notebook.h"
14
15 #if wxUSE_NOTEBOOK
16
17 #include "wx/panel.h"
18 #include "wx/utils.h"
19 #include "wx/imaglist.h"
20 #include "wx/intl.h"
21 #include "wx/log.h"
22 #include "wx/bitmap.h"
23 #include "wx/fontutil.h"
24
25 #include "wx/gtk/private.h"
26 #include "wx/gtk/win_gtk.h"
27
28 #include <gdk/gdkkeysyms.h>
29
30 #include "wx/msgdlg.h"
31
32 // ----------------------------------------------------------------------------
33 // events
34 // ----------------------------------------------------------------------------
35
36 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
37 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
38
39 //-----------------------------------------------------------------------------
40 // idle system
41 //-----------------------------------------------------------------------------
42
43 extern void wxapp_install_idle_handler();
44 extern bool g_isIdle;
45
46 //-----------------------------------------------------------------------------
47 // data
48 //-----------------------------------------------------------------------------
49
50 extern bool g_blockEventsOnDrag;
51
52 //-----------------------------------------------------------------------------
53 // wxGtkNotebookPage
54 //-----------------------------------------------------------------------------
55
56 // VZ: this is rather ugly as we keep the pages themselves in an array (it
57 // allows us to have quite a few functions implemented in the base class)
58 // but the page data is kept in a separate list, so we must maintain them
59 // in sync manually... of course, the list had been there before the base
60 // class which explains it but it still would be nice to do something
61 // about this one day
62
63 class wxGtkNotebookPage: public wxObject
64 {
65 public:
66 wxGtkNotebookPage()
67 {
68 m_image = -1;
69 m_page = (GtkNotebookPage *) NULL;
70 m_box = (GtkWidget *) NULL;
71 }
72
73 wxString m_text;
74 int m_image;
75 GtkNotebookPage *m_page;
76 GtkLabel *m_label;
77 GtkWidget *m_box; // in which the label and image are packed
78 };
79
80
81 #include "wx/listimpl.cpp"
82 WX_DEFINE_LIST(wxGtkNotebookPagesList)
83
84
85 //-----------------------------------------------------------------------------
86 // "switch_page"
87 //-----------------------------------------------------------------------------
88
89 extern "C" {
90 static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget),
91 GtkNotebookPage *WXUNUSED(page),
92 gint page,
93 wxNotebook *notebook )
94 {
95 // are you trying to call SetSelection() from a notebook event handler?
96 // you shouldn't!
97 wxCHECK_RET( !notebook->m_inSwitchPage,
98 _T("gtk_notebook_page_change_callback reentered") );
99
100 notebook->m_inSwitchPage = TRUE;
101 if (g_isIdle)
102 wxapp_install_idle_handler();
103
104 int old = notebook->GetSelection();
105
106 wxNotebookEvent eventChanging( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING,
107 notebook->GetId(), page, old );
108 eventChanging.SetEventObject( notebook );
109
110 if ( (notebook->GetEventHandler()->ProcessEvent(eventChanging)) &&
111 !eventChanging.IsAllowed() )
112 {
113 /* program doesn't allow the page change */
114 gtk_signal_emit_stop_by_name( GTK_OBJECT(notebook->m_widget),
115 "switch_page" );
116 }
117 else // change allowed
118 {
119 // make wxNotebook::GetSelection() return the correct (i.e. consistent
120 // with wxNotebookEvent::GetSelection()) value even though the page is
121 // not really changed in GTK+
122 notebook->m_selection = page;
123
124 wxNotebookEvent eventChanged( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
125 notebook->GetId(), page, old );
126 eventChanged.SetEventObject( notebook );
127 notebook->GetEventHandler()->ProcessEvent( eventChanged );
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, _T("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->GetEventHandler()->ProcessEvent( 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,wxControl)
284
285 BEGIN_EVENT_TABLE(wxNotebook, wxControl)
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 = (wxImageList *) 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 (!PreCreation( parent, pos, size ) ||
326 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
327 {
328 wxFAIL_MSG( wxT("wxNoteBook creation failed") );
329 return FALSE;
330 }
331
332
333 m_widget = gtk_notebook_new();
334
335 gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
336
337 gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
338 GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
339
340 m_parent->DoAddChild( this );
341
342 if (m_windowStyle & wxNB_RIGHT)
343 gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT );
344 if (m_windowStyle & wxNB_LEFT)
345 gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT );
346 if (m_windowStyle & wxNB_BOTTOM)
347 gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM );
348
349 gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
350 GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );
351
352 PostCreation(size);
353
354 gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
355 GTK_SIGNAL_FUNC(gtk_notebook_realized_callback), (gpointer) this );
356
357 return TRUE;
358 }
359
360 int wxNotebook::GetSelection() const
361 {
362 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
363
364 if ( m_selection == -1 )
365 {
366 GList *nb_pages = GTK_NOTEBOOK(m_widget)->children;
367
368 if (g_list_length(nb_pages) != 0)
369 {
370 GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
371
372 gpointer cur = notebook->cur_page;
373 if ( cur != NULL )
374 {
375 wxConstCast(this, wxNotebook)->m_selection =
376 g_list_index( nb_pages, cur );
377 }
378 }
379 }
380
381 return m_selection;
382 }
383
384 wxString wxNotebook::GetPageText( size_t page ) const
385 {
386 wxCHECK_MSG( m_widget != NULL, wxT(""), wxT("invalid notebook") );
387
388 wxGtkNotebookPage* nb_page = GetNotebookPage(page);
389 if (nb_page)
390 return nb_page->m_text;
391 else
392 return wxT("");
393 }
394
395 int wxNotebook::GetPageImage( size_t page ) const
396 {
397 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
398
399 wxGtkNotebookPage* nb_page = GetNotebookPage(page);
400 if (nb_page)
401 return nb_page->m_image;
402 else
403 return -1;
404 }
405
406 wxGtkNotebookPage* wxNotebook::GetNotebookPage( int page ) const
407 {
408 wxCHECK_MSG( m_widget != NULL, (wxGtkNotebookPage*) NULL, wxT("invalid notebook") );
409
410 wxCHECK_MSG( page < (int)m_pagesData.GetCount(), (wxGtkNotebookPage*) NULL, wxT("invalid notebook index") );
411
412 return m_pagesData.Item(page)->GetData();
413 }
414
415 int wxNotebook::SetSelection( size_t page )
416 {
417 wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") );
418
419 wxCHECK_MSG( page < m_pagesData.GetCount(), -1, wxT("invalid notebook index") );
420
421 int selOld = GetSelection();
422
423 // cache the selection
424 m_selection = page;
425 gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page );
426
427 wxNotebookPage *client = GetPage(page);
428 if ( client )
429 client->SetFocus();
430
431 return selOld;
432 }
433
434 bool wxNotebook::SetPageText( size_t page, const wxString &text )
435 {
436 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") );
437
438 wxGtkNotebookPage* nb_page = GetNotebookPage(page);
439
440 wxCHECK_MSG( nb_page, FALSE, wxT("SetPageText: invalid page index") );
441
442 nb_page->m_text = text;
443
444 gtk_label_set( nb_page->m_label, wxGTK_CONV( nb_page->m_text ) );
445
446 return TRUE;
447 }
448
449 bool wxNotebook::SetPageImage( size_t page, int image )
450 {
451 /* HvdH 28-12-98: now it works, but it's a bit of a kludge */
452
453 wxGtkNotebookPage* nb_page = GetNotebookPage(page);
454
455 if (!nb_page) return FALSE;
456
457 /* Optimization posibility: return immediately if image unchanged.
458 * Not enabled because it may break existing (stupid) code that
459 * manipulates the imagelist to cycle images */
460
461 /* if (image == nb_page->m_image) return TRUE; */
462
463 /* For different cases:
464 1) no image -> no image
465 2) image -> no image
466 3) no image -> image
467 4) image -> image */
468
469 if (image == -1 && nb_page->m_image == -1)
470 return TRUE; /* Case 1): Nothing to do. */
471
472 GtkWidget *pixmapwid = (GtkWidget*) NULL;
473
474 if (nb_page->m_image != -1)
475 {
476 /* Case 2) or 4). There is already an image in the gtkhbox. Let's find it */
477
478 GList *child = gtk_container_children(GTK_CONTAINER(nb_page->m_box));
479 while (child)
480 {
481 if (GTK_IS_PIXMAP(child->data))
482 {
483 pixmapwid = GTK_WIDGET(child->data);
484 break;
485 }
486 child = child->next;
487 }
488
489 /* We should have the pixmap widget now */
490 wxASSERT(pixmapwid != NULL);
491
492 if (image == -1)
493 {
494 /* If there's no new widget, just remove the old from the box */
495 gtk_container_remove(GTK_CONTAINER(nb_page->m_box), pixmapwid);
496 nb_page->m_image = -1;
497
498 return TRUE; /* Case 2) */
499 }
500 }
501
502 /* Only cases 3) and 4) left */
503 wxASSERT( m_imageList != NULL ); /* Just in case */
504
505 /* Construct the new pixmap */
506 const wxBitmap *bmp = m_imageList->GetBitmapPtr(image);
507 GdkPixmap *pixmap = bmp->GetPixmap();
508 GdkBitmap *mask = (GdkBitmap*) NULL;
509 if ( bmp->GetMask() )
510 {
511 mask = bmp->GetMask()->GetBitmap();
512 }
513
514 if (pixmapwid == NULL)
515 {
516 /* Case 3) No old pixmap. Create a new one and prepend it to the hbox */
517 pixmapwid = gtk_pixmap_new (pixmap, mask );
518
519 /* CHECKME: Are these pack flags okay? */
520 gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding);
521 gtk_widget_show(pixmapwid);
522 }
523 else
524 {
525 /* Case 4) Simply replace the pixmap */
526 gtk_pixmap_set(GTK_PIXMAP(pixmapwid), pixmap, mask);
527 }
528
529 nb_page->m_image = image;
530
531 return TRUE;
532 }
533
534 void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
535 {
536 wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") );
537 }
538
539 void wxNotebook::SetPadding( const wxSize &padding )
540 {
541 wxCHECK_RET( m_widget != NULL, wxT("invalid notebook") );
542
543 m_padding = padding.GetWidth();
544
545 int i;
546 for (i=0; i<int(GetPageCount()); i++)
547 {
548 wxGtkNotebookPage* nb_page = GetNotebookPage(i);
549 wxASSERT(nb_page != NULL);
550
551 if (nb_page->m_image != -1)
552 {
553 // gtk_box_set_child_packing sets padding on BOTH sides
554 // icon provides left padding, label provides center and right
555 int image = nb_page->m_image;
556 SetPageImage(i,-1);
557 SetPageImage(i,image);
558 }
559 wxASSERT(nb_page->m_label);
560 gtk_box_set_child_packing(GTK_BOX(nb_page->m_box),
561 GTK_WIDGET(nb_page->m_label),
562 FALSE, FALSE, m_padding, GTK_PACK_END);
563 }
564 }
565
566 void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz))
567 {
568 wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") );
569 }
570
571 bool wxNotebook::DeleteAllPages()
572 {
573 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") );
574
575 while (m_pagesData.GetCount() > 0)
576 DeletePage( m_pagesData.GetCount()-1 );
577
578 wxASSERT_MSG( GetPageCount() == 0, _T("all pages must have been deleted") );
579
580 InvalidateBestSize();
581 return wxNotebookBase::DeleteAllPages();
582 }
583
584 wxNotebookPage *wxNotebook::DoRemovePage( size_t page )
585 {
586 if ( m_selection != -1 && (size_t)m_selection >= page )
587 {
588 // the index will become invalid after the page is deleted
589 m_selection = -1;
590 }
591
592 wxNotebookPage *client = wxNotebookBase::DoRemovePage(page);
593 if ( !client )
594 return NULL;
595
596 gtk_widget_ref( client->m_widget );
597 gtk_widget_unrealize( client->m_widget );
598 gtk_widget_unparent( client->m_widget );
599
600 // gtk_notebook_remove_page() sends "switch_page" signal with some strange
601 // new page index (when deleting selected page 0, new page is 1 although,
602 // clearly, the selection should stay 0), so suppress this
603 gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
604 GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this );
605
606 gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page );
607
608 gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
609 GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
610
611 wxGtkNotebookPage* p = GetNotebookPage(page);
612 m_pagesData.DeleteObject(p);
613 delete p;
614
615 return client;
616 }
617
618 bool wxNotebook::InsertPage( size_t position,
619 wxNotebookPage* win,
620 const wxString& text,
621 bool select,
622 int imageId )
623 {
624 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") );
625
626 wxCHECK_MSG( win->GetParent() == this, FALSE,
627 wxT("Can't add a page whose parent is not the notebook!") );
628
629 wxCHECK_MSG( position <= GetPageCount(), FALSE,
630 _T("invalid page index in wxNotebookPage::InsertPage()") );
631
632 // Hack Alert! (Part II): See above in wxInsertChildInNotebook callback
633 // why this has to be done. NOTE: using gtk_widget_unparent here does not
634 // work as it seems to undo too much and will cause errors in the
635 // gtk_notebook_insert_page below, so instead just clear the parent by
636 // hand here.
637 win->m_widget->parent = NULL;
638
639 // don't receive switch page during addition
640 gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
641 GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this );
642
643 if (m_themeEnabled)
644 win->SetThemeEnabled(TRUE);
645
646 GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
647
648 wxGtkNotebookPage *nb_page = new wxGtkNotebookPage();
649
650 if ( position == GetPageCount() )
651 m_pagesData.Append( nb_page );
652 else
653 m_pagesData.Insert( position, nb_page );
654
655 m_pages.Insert(win, position);
656
657 nb_page->m_box = gtk_hbox_new( FALSE, 1 );
658 gtk_container_border_width( GTK_CONTAINER(nb_page->m_box), 2 );
659
660 gtk_signal_connect( GTK_OBJECT(win->m_widget), "size_allocate",
661 GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)win );
662
663 gtk_notebook_insert_page( notebook, win->m_widget, nb_page->m_box, position );
664
665 nb_page->m_page = (GtkNotebookPage*) g_list_last(notebook->children)->data;
666
667 /* set the label image */
668 nb_page->m_image = imageId;
669
670 if (imageId != -1)
671 {
672 wxASSERT( m_imageList != NULL );
673
674 const wxBitmap *bmp = m_imageList->GetBitmapPtr(imageId);
675 GdkPixmap *pixmap = bmp->GetPixmap();
676 GdkBitmap *mask = (GdkBitmap*) NULL;
677 if ( bmp->GetMask() )
678 {
679 mask = bmp->GetMask()->GetBitmap();
680 }
681
682 GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask );
683
684 gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding);
685
686 gtk_widget_show(pixmapwid);
687 }
688
689 /* set the label text */
690
691 nb_page->m_text = text;
692 if (nb_page->m_text.IsEmpty()) nb_page->m_text = wxT("");
693
694 nb_page->m_label = GTK_LABEL( gtk_label_new(wxGTK_CONV(nb_page->m_text)) );
695 gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding );
696
697 /* apply current style */
698 GtkRcStyle *style = CreateWidgetStyle();
699 if ( style )
700 {
701 gtk_widget_modify_style(GTK_WIDGET(nb_page->m_label), style);
702 gtk_rc_style_unref(style);
703 }
704
705 /* show the label */
706 gtk_widget_show( GTK_WIDGET(nb_page->m_label) );
707 if (select && (m_pagesData.GetCount() > 1))
708 {
709 SetSelection( position );
710 }
711
712 gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
713 GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
714
715 InvalidateBestSize();
716 return TRUE;
717 }
718
719 // helper for HitTest(): check if the point lies inside the given widget which
720 // is the child of the notebook whose position and border size are passed as
721 // parameters
722 static bool
723 IsPointInsideWidget(const wxPoint& pt, GtkWidget *w,
724 gint x, gint y, gint border = 0)
725 {
726 return
727 (pt.x >= w->allocation.x - x - border) &&
728 (pt.x <= w->allocation.x - x + border + w->allocation.width) &&
729 (pt.y >= w->allocation.y - y - border) &&
730 (pt.y <= w->allocation.y - y + border + w->allocation.height);
731 }
732
733 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
734 {
735 const gint x = m_widget->allocation.x;
736 const gint y = m_widget->allocation.y;
737
738 const size_t count = GetPageCount();
739 for ( size_t i = 0; i < count; i++ )
740 {
741 wxGtkNotebookPage* nb_page = GetNotebookPage(i);
742 GtkWidget *box = nb_page->m_box;
743
744 // VZ: don't know how to find the border width in GTK+ 1.2
745 #ifdef __WXGTK20__
746 const gint border = gtk_container_get_border_width(GTK_CONTAINER(box));
747 #else // !GTK+ 2.x
748 const gint border = 0;
749 #endif
750 if ( IsPointInsideWidget(pt, box, x, y, border) )
751 {
752 // ok, we're inside this tab -- now find out where, if needed
753 if ( flags )
754 {
755 GtkWidget *pixmap = NULL;
756
757 GList *children = gtk_container_children(GTK_CONTAINER(box));
758 for ( GList *child = children; child; child = child->next )
759 {
760 if ( GTK_IS_PIXMAP(child->data) )
761 {
762 pixmap = GTK_WIDGET(child->data);
763 break;
764 }
765 }
766
767 if ( children )
768 g_list_free(children);
769
770 if ( pixmap && IsPointInsideWidget(pt, pixmap, x, y) )
771 {
772 *flags = wxNB_HITTEST_ONICON;
773 }
774 else if ( IsPointInsideWidget(pt, GTK_WIDGET(nb_page->m_label), x, y) )
775 {
776 *flags = wxNB_HITTEST_ONLABEL;
777 }
778 else
779 {
780 *flags = wxNB_HITTEST_ONITEM;
781 }
782 }
783
784 return i;
785 }
786 }
787
788 if ( flags )
789 *flags = wxNB_HITTEST_NOWHERE;
790
791 return wxNOT_FOUND;
792 }
793
794 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
795 {
796 if (event.IsWindowChange())
797 AdvanceSelection( event.GetDirection() );
798 else
799 event.Skip();
800 }
801
802 #if wxUSE_CONSTRAINTS
803
804 // override these 2 functions to do nothing: everything is done in OnSize
805 void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
806 {
807 // don't set the sizes of the pages - their correct size is not yet known
808 wxControl::SetConstraintSizes(FALSE);
809 }
810
811 bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
812 {
813 return TRUE;
814 }
815
816 #endif
817
818 void wxNotebook::DoApplyWidgetStyle(GtkRcStyle *style)
819 {
820 gtk_widget_modify_style(m_widget, style);
821 size_t cnt = m_pagesData.GetCount();
822 for (size_t i = 0; i < cnt; i++)
823 gtk_widget_modify_style(GTK_WIDGET(GetNotebookPage(i)->m_label), style);
824 }
825
826 bool wxNotebook::IsOwnGtkWindow( GdkWindow *window )
827 {
828 return ((m_widget->window == window) ||
829 (NOTEBOOK_PANEL(m_widget) == window));
830 }
831
832 // static
833 wxVisualAttributes
834 wxNotebook::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
835 {
836 return GetDefaultAttributesFromGTKWidget(gtk_notebook_new);
837 }
838
839 //-----------------------------------------------------------------------------
840 // wxNotebookEvent
841 //-----------------------------------------------------------------------------
842
843 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
844
845 #endif