]>
Commit | Line | Data |
---|---|---|
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 | ||
28 | #include "wx/gtk/private.h" | |
29 | #include "wx/gtk/win_gtk.h" | |
30 | ||
31 | #include <gdk/gdkkeysyms.h> | |
32 | ||
33 | // ---------------------------------------------------------------------------- | |
34 | // events | |
35 | // ---------------------------------------------------------------------------- | |
36 | ||
37 | DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED) | |
38 | DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING) | |
39 | ||
40 | //----------------------------------------------------------------------------- | |
41 | // idle system | |
42 | //----------------------------------------------------------------------------- | |
43 | ||
44 | extern void wxapp_install_idle_handler(); | |
45 | extern bool g_isIdle; | |
46 | ||
47 | //----------------------------------------------------------------------------- | |
48 | // data | |
49 | //----------------------------------------------------------------------------- | |
50 | ||
51 | extern bool g_blockEventsOnDrag; | |
52 | ||
53 | //----------------------------------------------------------------------------- | |
54 | // wxGtkNotebookPage | |
55 | //----------------------------------------------------------------------------- | |
56 | ||
57 | // VZ: this is rather ugly as we keep the pages themselves in an array (it | |
58 | // allows us to have quite a few functions implemented in the base class) | |
59 | // but the page data is kept in a separate list, so we must maintain them | |
60 | // in sync manually... of course, the list had been there before the base | |
61 | // class which explains it but it still would be nice to do something | |
62 | // about this one day | |
63 | ||
64 | class wxGtkNotebookPage: public wxObject | |
65 | { | |
66 | public: | |
67 | wxGtkNotebookPage() | |
68 | { | |
69 | m_image = -1; | |
70 | m_page = (GtkNotebookPage *) NULL; | |
71 | m_box = (GtkWidget *) NULL; | |
72 | } | |
73 | ||
74 | wxString m_text; | |
75 | int m_image; | |
76 | GtkNotebookPage *m_page; | |
77 | GtkLabel *m_label; | |
78 | GtkWidget *m_box; // in which the label and image are packed | |
79 | }; | |
80 | ||
81 | #include "wx/listimpl.cpp" | |
82 | WX_DEFINE_LIST(wxGtkNotebookPagesList); | |
83 | ||
84 | //----------------------------------------------------------------------------- | |
85 | // "switch_page" | |
86 | //----------------------------------------------------------------------------- | |
87 | ||
88 | static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget), | |
89 | GtkNotebookPage *WXUNUSED(page), | |
90 | gint page, | |
91 | wxNotebook *notebook ) | |
92 | { | |
93 | // are you trying to call SetSelection() from a notebook event handler? | |
94 | // you shouldn't! | |
95 | wxCHECK_RET( !notebook->m_inSwitchPage, | |
96 | _T("gtk_notebook_page_change_callback reentered") ); | |
97 | ||
98 | notebook->m_inSwitchPage = TRUE; | |
99 | if (g_isIdle) | |
100 | wxapp_install_idle_handler(); | |
101 | ||
102 | int old = notebook->GetSelection(); | |
103 | ||
104 | wxNotebookEvent eventChanging( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, | |
105 | notebook->GetId(), page, old ); | |
106 | eventChanging.SetEventObject( notebook ); | |
107 | ||
108 | if ( (notebook->GetEventHandler()->ProcessEvent(eventChanging)) && | |
109 | !eventChanging.IsAllowed() ) | |
110 | { | |
111 | /* program doesn't allow the page change */ | |
112 | gtk_signal_emit_stop_by_name( GTK_OBJECT(notebook->m_widget), | |
113 | "switch_page" ); | |
114 | } | |
115 | else // change allowed | |
116 | { | |
117 | // make wxNotebook::GetSelection() return the correct (i.e. consistent | |
118 | // with wxNotebookEvent::GetSelection()) value even though the page is | |
119 | // not really changed in GTK+ | |
120 | notebook->m_selection = page; | |
121 | ||
122 | wxNotebookEvent eventChanged( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, | |
123 | notebook->GetId(), page, old ); | |
124 | eventChanged.SetEventObject( notebook ); | |
125 | notebook->GetEventHandler()->ProcessEvent( eventChanged ); | |
126 | } | |
127 | ||
128 | notebook->m_inSwitchPage = FALSE; | |
129 | } | |
130 | ||
131 | //----------------------------------------------------------------------------- | |
132 | // "size_allocate" | |
133 | //----------------------------------------------------------------------------- | |
134 | ||
135 | static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win ) | |
136 | { | |
137 | if (g_isIdle) | |
138 | wxapp_install_idle_handler(); | |
139 | ||
140 | if ((win->m_x == alloc->x) && | |
141 | (win->m_y == alloc->y) && | |
142 | (win->m_width == alloc->width) && | |
143 | (win->m_height == alloc->height)) | |
144 | { | |
145 | return; | |
146 | } | |
147 | ||
148 | win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height ); | |
149 | ||
150 | /* GTK 1.2 up to version 1.2.5 is broken so that we have to call allocate | |
151 | here in order to make repositioning after resizing to take effect. */ | |
152 | if ((gtk_major_version == 1) && | |
153 | (gtk_minor_version == 2) && | |
154 | (gtk_micro_version < 6) && | |
155 | (win->m_wxwindow) && | |
156 | (GTK_WIDGET_REALIZED(win->m_wxwindow))) | |
157 | { | |
158 | gtk_widget_size_allocate( win->m_wxwindow, alloc ); | |
159 | } | |
160 | } | |
161 | ||
162 | //----------------------------------------------------------------------------- | |
163 | // "realize" from m_widget | |
164 | //----------------------------------------------------------------------------- | |
165 | ||
166 | static gint | |
167 | gtk_notebook_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win ) | |
168 | { | |
169 | if (g_isIdle) | |
170 | wxapp_install_idle_handler(); | |
171 | ||
172 | /* GTK 1.2 up to version 1.2.5 is broken so that we have to call a queue_resize | |
173 | here in order to make repositioning before showing to take effect. */ | |
174 | gtk_widget_queue_resize( win->m_widget ); | |
175 | ||
176 | return FALSE; | |
177 | } | |
178 | ||
179 | //----------------------------------------------------------------------------- | |
180 | // "key_press_event" | |
181 | //----------------------------------------------------------------------------- | |
182 | ||
183 | static gint gtk_notebook_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxNotebook *win ) | |
184 | { | |
185 | if (g_isIdle) | |
186 | wxapp_install_idle_handler(); | |
187 | ||
188 | if (!win->m_hasVMT) return FALSE; | |
189 | if (g_blockEventsOnDrag) return FALSE; | |
190 | ||
191 | /* win is a control: tab can be propagated up */ | |
192 | if ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) | |
193 | { | |
194 | int sel = win->GetSelection(); | |
195 | if (sel == -1) | |
196 | return TRUE; | |
197 | wxGtkNotebookPage *nb_page = win->GetNotebookPage(sel); | |
198 | wxCHECK_MSG( nb_page, FALSE, _T("invalid selection in wxNotebook") ); | |
199 | ||
200 | wxNavigationKeyEvent event; | |
201 | event.SetEventObject( win ); | |
202 | /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */ | |
203 | event.SetDirection( (gdk_event->keyval == GDK_Tab) ); | |
204 | /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */ | |
205 | event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) ); | |
206 | event.SetCurrentFocus( win ); | |
207 | ||
208 | wxNotebookPage *client = win->GetPage(sel); | |
209 | if ( !client->GetEventHandler()->ProcessEvent( event ) ) | |
210 | { | |
211 | client->SetFocus(); | |
212 | } | |
213 | ||
214 | gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" ); | |
215 | return TRUE; | |
216 | } | |
217 | ||
218 | return FALSE; | |
219 | } | |
220 | ||
221 | //----------------------------------------------------------------------------- | |
222 | // InsertChild callback for wxNotebook | |
223 | //----------------------------------------------------------------------------- | |
224 | ||
225 | static void wxInsertChildInNotebook( wxNotebook* WXUNUSED(parent), wxWindow* WXUNUSED(child) ) | |
226 | { | |
227 | /* we don't do anything here but pray */ | |
228 | } | |
229 | ||
230 | //----------------------------------------------------------------------------- | |
231 | // wxNotebook | |
232 | //----------------------------------------------------------------------------- | |
233 | ||
234 | IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl) | |
235 | ||
236 | BEGIN_EVENT_TABLE(wxNotebook, wxControl) | |
237 | EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey) | |
238 | END_EVENT_TABLE() | |
239 | ||
240 | void wxNotebook::Init() | |
241 | { | |
242 | m_padding = 0; | |
243 | m_inSwitchPage = FALSE; | |
244 | ||
245 | m_imageList = (wxImageList *) NULL; | |
246 | m_selection = -1; | |
247 | m_themeEnabled = TRUE; | |
248 | } | |
249 | ||
250 | wxNotebook::wxNotebook() | |
251 | { | |
252 | Init(); | |
253 | } | |
254 | ||
255 | wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id, | |
256 | const wxPoint& pos, const wxSize& size, | |
257 | long style, const wxString& name ) | |
258 | { | |
259 | Init(); | |
260 | Create( parent, id, pos, size, style, name ); | |
261 | } | |
262 | ||
263 | wxNotebook::~wxNotebook() | |
264 | { | |
265 | /* don't generate change page events any more */ | |
266 | gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget), | |
267 | GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this ); | |
268 | ||
269 | DeleteAllPages(); | |
270 | } | |
271 | ||
272 | bool wxNotebook::Create(wxWindow *parent, wxWindowID id, | |
273 | const wxPoint& pos, const wxSize& size, | |
274 | long style, const wxString& name ) | |
275 | { | |
276 | m_needParent = TRUE; | |
277 | m_acceptsFocus = TRUE; | |
278 | m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook; | |
279 | ||
280 | if (!PreCreation( parent, pos, size ) || | |
281 | !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) | |
282 | { | |
283 | wxFAIL_MSG( wxT("wxNoteBook creation failed") ); | |
284 | return FALSE; | |
285 | } | |
286 | ||
287 | ||
288 | m_widget = gtk_notebook_new(); | |
289 | ||
290 | gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 ); | |
291 | ||
292 | gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page", | |
293 | GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this ); | |
294 | ||
295 | m_parent->DoAddChild( this ); | |
296 | ||
297 | if (m_windowStyle & wxNB_RIGHT) | |
298 | gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT ); | |
299 | if (m_windowStyle & wxNB_LEFT) | |
300 | gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT ); | |
301 | if (m_windowStyle & wxNB_BOTTOM) | |
302 | gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_BOTTOM ); | |
303 | ||
304 | gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event", | |
305 | GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this ); | |
306 | ||
307 | PostCreation(); | |
308 | ||
309 | SetFont( parent->GetFont() ); | |
310 | ||
311 | gtk_signal_connect( GTK_OBJECT(m_widget), "realize", | |
312 | GTK_SIGNAL_FUNC(gtk_notebook_realized_callback), (gpointer) this ); | |
313 | ||
314 | Show( TRUE ); | |
315 | ||
316 | return TRUE; | |
317 | } | |
318 | ||
319 | int wxNotebook::GetSelection() const | |
320 | { | |
321 | wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") ); | |
322 | ||
323 | if ( m_selection == -1 ) | |
324 | { | |
325 | GList *nb_pages = GTK_NOTEBOOK(m_widget)->children; | |
326 | ||
327 | if (g_list_length(nb_pages) != 0) | |
328 | { | |
329 | GtkNotebook *notebook = GTK_NOTEBOOK(m_widget); | |
330 | ||
331 | gpointer cur = notebook->cur_page; | |
332 | if ( cur != NULL ) | |
333 | { | |
334 | wxConstCast(this, wxNotebook)->m_selection = | |
335 | g_list_index( nb_pages, cur ); | |
336 | } | |
337 | } | |
338 | } | |
339 | ||
340 | return m_selection; | |
341 | } | |
342 | ||
343 | wxString wxNotebook::GetPageText( int page ) const | |
344 | { | |
345 | wxCHECK_MSG( m_widget != NULL, wxT(""), wxT("invalid notebook") ); | |
346 | ||
347 | wxGtkNotebookPage* nb_page = GetNotebookPage(page); | |
348 | if (nb_page) | |
349 | return nb_page->m_text; | |
350 | else | |
351 | return wxT(""); | |
352 | } | |
353 | ||
354 | int wxNotebook::GetPageImage( int page ) const | |
355 | { | |
356 | wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") ); | |
357 | ||
358 | wxGtkNotebookPage* nb_page = GetNotebookPage(page); | |
359 | if (nb_page) | |
360 | return nb_page->m_image; | |
361 | else | |
362 | return -1; | |
363 | } | |
364 | ||
365 | wxGtkNotebookPage* wxNotebook::GetNotebookPage( int page ) const | |
366 | { | |
367 | wxCHECK_MSG( m_widget != NULL, (wxGtkNotebookPage*) NULL, wxT("invalid notebook") ); | |
368 | ||
369 | wxCHECK_MSG( page < (int)m_pagesData.GetCount(), (wxGtkNotebookPage*) NULL, wxT("invalid notebook index") ); | |
370 | ||
371 | return m_pagesData.Item(page)->GetData(); | |
372 | } | |
373 | ||
374 | int wxNotebook::SetSelection( int page ) | |
375 | { | |
376 | wxCHECK_MSG( m_widget != NULL, -1, wxT("invalid notebook") ); | |
377 | ||
378 | wxCHECK_MSG( page >= 0 && page < (int)m_pagesData.GetCount(), -1, wxT("invalid notebook index") ); | |
379 | ||
380 | int selOld = GetSelection(); | |
381 | ||
382 | // cache the selection | |
383 | m_selection = page; | |
384 | gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page ); | |
385 | ||
386 | wxNotebookPage *client = GetPage(page); | |
387 | if ( client ) | |
388 | client->SetFocus(); | |
389 | ||
390 | return selOld; | |
391 | } | |
392 | ||
393 | bool wxNotebook::SetPageText( int page, const wxString &text ) | |
394 | { | |
395 | wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") ); | |
396 | ||
397 | wxGtkNotebookPage* nb_page = GetNotebookPage(page); | |
398 | ||
399 | wxCHECK_MSG( nb_page, FALSE, wxT("SetPageText: invalid page index") ); | |
400 | ||
401 | nb_page->m_text = text; | |
402 | ||
403 | gtk_label_set( nb_page->m_label, wxGTK_CONV( nb_page->m_text ) ); | |
404 | ||
405 | return TRUE; | |
406 | } | |
407 | ||
408 | bool wxNotebook::SetPageImage( int page, int image ) | |
409 | { | |
410 | /* HvdH 28-12-98: now it works, but it's a bit of a kludge */ | |
411 | ||
412 | wxGtkNotebookPage* nb_page = GetNotebookPage(page); | |
413 | ||
414 | if (!nb_page) return FALSE; | |
415 | ||
416 | /* Optimization posibility: return immediately if image unchanged. | |
417 | * Not enabled because it may break existing (stupid) code that | |
418 | * manipulates the imagelist to cycle images */ | |
419 | ||
420 | /* if (image == nb_page->m_image) return TRUE; */ | |
421 | ||
422 | /* For different cases: | |
423 | 1) no image -> no image | |
424 | 2) image -> no image | |
425 | 3) no image -> image | |
426 | 4) image -> image */ | |
427 | ||
428 | if (image == -1 && nb_page->m_image == -1) | |
429 | return TRUE; /* Case 1): Nothing to do. */ | |
430 | ||
431 | GtkWidget *pixmapwid = (GtkWidget*) NULL; | |
432 | ||
433 | if (nb_page->m_image != -1) | |
434 | { | |
435 | /* Case 2) or 4). There is already an image in the gtkhbox. Let's find it */ | |
436 | ||
437 | GList *child = gtk_container_children(GTK_CONTAINER(nb_page->m_box)); | |
438 | while (child) | |
439 | { | |
440 | if (GTK_IS_PIXMAP(child->data)) | |
441 | { | |
442 | pixmapwid = GTK_WIDGET(child->data); | |
443 | break; | |
444 | } | |
445 | child = child->next; | |
446 | } | |
447 | ||
448 | /* We should have the pixmap widget now */ | |
449 | wxASSERT(pixmapwid != NULL); | |
450 | ||
451 | if (image == -1) | |
452 | { | |
453 | /* If there's no new widget, just remove the old from the box */ | |
454 | gtk_container_remove(GTK_CONTAINER(nb_page->m_box), pixmapwid); | |
455 | nb_page->m_image = -1; | |
456 | ||
457 | return TRUE; /* Case 2) */ | |
458 | } | |
459 | } | |
460 | ||
461 | /* Only cases 3) and 4) left */ | |
462 | wxASSERT( m_imageList != NULL ); /* Just in case */ | |
463 | ||
464 | /* Construct the new pixmap */ | |
465 | const wxBitmap *bmp = m_imageList->GetBitmap(image); | |
466 | GdkPixmap *pixmap = bmp->GetPixmap(); | |
467 | GdkBitmap *mask = (GdkBitmap*) NULL; | |
468 | if ( bmp->GetMask() ) | |
469 | { | |
470 | mask = bmp->GetMask()->GetBitmap(); | |
471 | } | |
472 | ||
473 | if (pixmapwid == NULL) | |
474 | { | |
475 | /* Case 3) No old pixmap. Create a new one and prepend it to the hbox */ | |
476 | pixmapwid = gtk_pixmap_new (pixmap, mask ); | |
477 | ||
478 | /* CHECKME: Are these pack flags okay? */ | |
479 | gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding); | |
480 | gtk_widget_show(pixmapwid); | |
481 | } | |
482 | else | |
483 | { | |
484 | /* Case 4) Simply replace the pixmap */ | |
485 | gtk_pixmap_set(GTK_PIXMAP(pixmapwid), pixmap, mask); | |
486 | } | |
487 | ||
488 | nb_page->m_image = image; | |
489 | ||
490 | return TRUE; | |
491 | } | |
492 | ||
493 | void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) ) | |
494 | { | |
495 | wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") ); | |
496 | } | |
497 | ||
498 | void wxNotebook::SetPadding( const wxSize &padding ) | |
499 | { | |
500 | wxCHECK_RET( m_widget != NULL, wxT("invalid notebook") ); | |
501 | ||
502 | m_padding = padding.GetWidth(); | |
503 | ||
504 | int i; | |
505 | for (i=0; i<int(GetPageCount()); i++) | |
506 | { | |
507 | wxGtkNotebookPage* nb_page = GetNotebookPage(i); | |
508 | wxASSERT(nb_page != NULL); | |
509 | ||
510 | if (nb_page->m_image != -1) | |
511 | { | |
512 | // gtk_box_set_child_packing sets padding on BOTH sides | |
513 | // icon provides left padding, label provides center and right | |
514 | int image = nb_page->m_image; | |
515 | SetPageImage(i,-1); | |
516 | SetPageImage(i,image); | |
517 | } | |
518 | wxASSERT(nb_page->m_label); | |
519 | gtk_box_set_child_packing(GTK_BOX(nb_page->m_box), | |
520 | GTK_WIDGET(nb_page->m_label), | |
521 | FALSE, FALSE, m_padding, GTK_PACK_END); | |
522 | } | |
523 | } | |
524 | ||
525 | void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz)) | |
526 | { | |
527 | wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") ); | |
528 | } | |
529 | ||
530 | bool wxNotebook::DeleteAllPages() | |
531 | { | |
532 | wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") ); | |
533 | ||
534 | while (m_pagesData.GetCount() > 0) | |
535 | DeletePage( m_pagesData.GetCount()-1 ); | |
536 | ||
537 | wxASSERT_MSG( GetPageCount() == 0, _T("all pages must have been deleted") ); | |
538 | ||
539 | return wxNotebookBase::DeleteAllPages(); | |
540 | } | |
541 | ||
542 | bool wxNotebook::DeletePage( int page ) | |
543 | { | |
544 | // GTK sets GtkNotebook.cur_page to NULL before sending the switch page | |
545 | // event so we have to store the selection internally | |
546 | if ( m_selection == -1 ) | |
547 | { | |
548 | m_selection = GetSelection(); | |
549 | if ( m_selection == (int)m_pagesData.GetCount() - 1 ) | |
550 | { | |
551 | // the index will become invalid after the page is deleted | |
552 | m_selection = -1; | |
553 | } | |
554 | } | |
555 | ||
556 | // it will call our DoRemovePage() to do the real work | |
557 | return wxNotebookBase::DeletePage(page); | |
558 | } | |
559 | ||
560 | wxNotebookPage *wxNotebook::DoRemovePage( int page ) | |
561 | { | |
562 | wxNotebookPage *client = wxNotebookBase::DoRemovePage(page); | |
563 | if ( !client ) | |
564 | return NULL; | |
565 | ||
566 | gtk_widget_ref( client->m_widget ); | |
567 | gtk_widget_unrealize( client->m_widget ); | |
568 | gtk_widget_unparent( client->m_widget ); | |
569 | ||
570 | gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page ); | |
571 | ||
572 | wxGtkNotebookPage* p = GetNotebookPage(page); | |
573 | m_pagesData.DeleteObject(p); | |
574 | delete p; | |
575 | ||
576 | return client; | |
577 | } | |
578 | ||
579 | bool wxNotebook::InsertPage( int position, | |
580 | wxNotebookPage* win, | |
581 | const wxString& text, | |
582 | bool select, | |
583 | int imageId ) | |
584 | { | |
585 | wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") ); | |
586 | ||
587 | wxCHECK_MSG( win->GetParent() == this, FALSE, | |
588 | wxT("Can't add a page whose parent is not the notebook!") ); | |
589 | ||
590 | wxCHECK_MSG( position >= 0 && position <= GetPageCount(), FALSE, | |
591 | _T("invalid page index in wxNotebookPage::InsertPage()") ); | |
592 | ||
593 | /* don't receive switch page during addition */ | |
594 | gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget), | |
595 | GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this ); | |
596 | ||
597 | if (m_themeEnabled) | |
598 | win->SetThemeEnabled(TRUE); | |
599 | ||
600 | GtkNotebook *notebook = GTK_NOTEBOOK(m_widget); | |
601 | ||
602 | wxGtkNotebookPage *nb_page = new wxGtkNotebookPage(); | |
603 | ||
604 | if ( position == GetPageCount() ) | |
605 | m_pagesData.Append( nb_page ); | |
606 | else | |
607 | m_pagesData.Insert( m_pagesData.Item( position ), nb_page ); | |
608 | ||
609 | m_pages.Insert(win, position); | |
610 | ||
611 | nb_page->m_box = gtk_hbox_new( FALSE, 1 ); | |
612 | gtk_container_border_width( GTK_CONTAINER(nb_page->m_box), 2 ); | |
613 | ||
614 | gtk_signal_connect( GTK_OBJECT(win->m_widget), "size_allocate", | |
615 | GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)win ); | |
616 | ||
617 | if (position < 0) | |
618 | gtk_notebook_append_page( notebook, win->m_widget, nb_page->m_box ); | |
619 | else | |
620 | gtk_notebook_insert_page( notebook, win->m_widget, nb_page->m_box, position ); | |
621 | ||
622 | nb_page->m_page = (GtkNotebookPage*) g_list_last(notebook->children)->data; | |
623 | ||
624 | /* set the label image */ | |
625 | nb_page->m_image = imageId; | |
626 | ||
627 | if (imageId != -1) | |
628 | { | |
629 | wxASSERT( m_imageList != NULL ); | |
630 | ||
631 | const wxBitmap *bmp = m_imageList->GetBitmap(imageId); | |
632 | GdkPixmap *pixmap = bmp->GetPixmap(); | |
633 | GdkBitmap *mask = (GdkBitmap*) NULL; | |
634 | if ( bmp->GetMask() ) | |
635 | { | |
636 | mask = bmp->GetMask()->GetBitmap(); | |
637 | } | |
638 | ||
639 | GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask ); | |
640 | ||
641 | gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding); | |
642 | ||
643 | gtk_widget_show(pixmapwid); | |
644 | } | |
645 | ||
646 | /* set the label text */ | |
647 | nb_page->m_text = text; | |
648 | if (nb_page->m_text.IsEmpty()) nb_page->m_text = wxT(""); | |
649 | ||
650 | nb_page->m_label = GTK_LABEL( gtk_label_new(nb_page->m_text.mbc_str()) ); | |
651 | gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding ); | |
652 | ||
653 | /* show the label */ | |
654 | gtk_widget_show( GTK_WIDGET(nb_page->m_label) ); | |
655 | if (select && (m_pagesData.GetCount() > 1)) | |
656 | { | |
657 | if (position < 0) | |
658 | SetSelection( GetPageCount()-1 ); | |
659 | else | |
660 | SetSelection( position ); | |
661 | } | |
662 | ||
663 | gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page", | |
664 | GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this ); | |
665 | ||
666 | return TRUE; | |
667 | } | |
668 | ||
669 | void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event) | |
670 | { | |
671 | if (event.IsWindowChange()) | |
672 | AdvanceSelection( event.GetDirection() ); | |
673 | else | |
674 | event.Skip(); | |
675 | } | |
676 | ||
677 | #if wxUSE_CONSTRAINTS | |
678 | ||
679 | // override these 2 functions to do nothing: everything is done in OnSize | |
680 | void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) ) | |
681 | { | |
682 | // don't set the sizes of the pages - their correct size is not yet known | |
683 | wxControl::SetConstraintSizes(FALSE); | |
684 | } | |
685 | ||
686 | bool wxNotebook::DoPhase( int WXUNUSED(nPhase) ) | |
687 | { | |
688 | return TRUE; | |
689 | } | |
690 | ||
691 | #endif | |
692 | ||
693 | void wxNotebook::ApplyWidgetStyle() | |
694 | { | |
695 | // TODO, font for labels etc | |
696 | ||
697 | SetWidgetStyle(); | |
698 | gtk_widget_set_style( m_widget, m_widgetStyle ); | |
699 | } | |
700 | ||
701 | bool wxNotebook::IsOwnGtkWindow( GdkWindow *window ) | |
702 | { | |
703 | return ((m_widget->window == window) || | |
704 | (NOTEBOOK_PANEL(m_widget) == window)); | |
705 | } | |
706 | ||
707 | //----------------------------------------------------------------------------- | |
708 | // wxNotebookEvent | |
709 | //----------------------------------------------------------------------------- | |
710 | ||
711 | IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent) | |
712 | ||
713 | #endif |