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