]>
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 | // 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/gtk1/private.h" | |
26 | #include "wx/gtk1/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 & wxBK_RIGHT) | |
343 | gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_RIGHT ); | |
344 | if (m_windowStyle & wxBK_LEFT) | |
345 | gtk_notebook_set_tab_pos( GTK_NOTEBOOK(m_widget), GTK_POS_LEFT ); | |
346 | if (m_windowStyle & wxBK_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 | size_t i = 0; | |
740 | ||
741 | // MR: Code to fix HitTest index return when tabs are scrolled. | |
742 | // No idea if it would work for GTK1 | |
743 | #if 0 | |
744 | GtkNotebook * notebook = GTK_NOTEBOOK(m_widget); | |
745 | if (gtk_notebook_get_scrollable(notebook)); | |
746 | i = g_list_position( notebook->children, notebook->first_tab ); | |
747 | #endif | |
748 | ||
749 | for ( ; i < count; i++ ) | |
750 | { | |
751 | wxGtkNotebookPage* nb_page = GetNotebookPage(i); | |
752 | GtkWidget *box = nb_page->m_box; | |
753 | ||
754 | // VZ: don't know how to find the border width in GTK+ 1.2 | |
755 | const gint border = 0; | |
756 | if ( IsPointInsideWidget(pt, box, x, y, border) ) | |
757 | { | |
758 | // ok, we're inside this tab -- now find out where, if needed | |
759 | if ( flags ) | |
760 | { | |
761 | GtkWidget *pixmap = NULL; | |
762 | ||
763 | GList *children = gtk_container_children(GTK_CONTAINER(box)); | |
764 | for ( GList *child = children; child; child = child->next ) | |
765 | { | |
766 | if ( GTK_IS_PIXMAP(child->data) ) | |
767 | { | |
768 | pixmap = GTK_WIDGET(child->data); | |
769 | break; | |
770 | } | |
771 | } | |
772 | ||
773 | if ( children ) | |
774 | g_list_free(children); | |
775 | ||
776 | if ( pixmap && IsPointInsideWidget(pt, pixmap, x, y) ) | |
777 | { | |
778 | *flags = wxNB_HITTEST_ONICON; | |
779 | } | |
780 | else if ( IsPointInsideWidget(pt, GTK_WIDGET(nb_page->m_label), x, y) ) | |
781 | { | |
782 | *flags = wxNB_HITTEST_ONLABEL; | |
783 | } | |
784 | else | |
785 | { | |
786 | *flags = wxNB_HITTEST_ONITEM; | |
787 | } | |
788 | } | |
789 | ||
790 | return i; | |
791 | } | |
792 | } | |
793 | ||
794 | if ( flags ) | |
795 | *flags = wxNB_HITTEST_NOWHERE; | |
796 | ||
797 | return wxNOT_FOUND; | |
798 | } | |
799 | ||
800 | void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event) | |
801 | { | |
802 | if (event.IsWindowChange()) | |
803 | AdvanceSelection( event.GetDirection() ); | |
804 | else | |
805 | event.Skip(); | |
806 | } | |
807 | ||
808 | #if wxUSE_CONSTRAINTS | |
809 | ||
810 | // override these 2 functions to do nothing: everything is done in OnSize | |
811 | void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) ) | |
812 | { | |
813 | // don't set the sizes of the pages - their correct size is not yet known | |
814 | wxControl::SetConstraintSizes(FALSE); | |
815 | } | |
816 | ||
817 | bool wxNotebook::DoPhase( int WXUNUSED(nPhase) ) | |
818 | { | |
819 | return TRUE; | |
820 | } | |
821 | ||
822 | #endif | |
823 | ||
824 | void wxNotebook::DoApplyWidgetStyle(GtkRcStyle *style) | |
825 | { | |
826 | gtk_widget_modify_style(m_widget, style); | |
827 | size_t cnt = m_pagesData.GetCount(); | |
828 | for (size_t i = 0; i < cnt; i++) | |
829 | gtk_widget_modify_style(GTK_WIDGET(GetNotebookPage(i)->m_label), style); | |
830 | } | |
831 | ||
832 | bool wxNotebook::IsOwnGtkWindow( GdkWindow *window ) | |
833 | { | |
834 | return ((m_widget->window == window) || | |
835 | (NOTEBOOK_PANEL(m_widget) == window)); | |
836 | } | |
837 | ||
838 | // static | |
839 | wxVisualAttributes | |
840 | wxNotebook::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) | |
841 | { | |
842 | return GetDefaultAttributesFromGTKWidget(gtk_notebook_new); | |
843 | } | |
844 | ||
845 | //----------------------------------------------------------------------------- | |
846 | // wxNotebookEvent | |
847 | //----------------------------------------------------------------------------- | |
848 | ||
849 | IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent) | |
850 | ||
851 | #endif |