]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/notebook.cpp
updated i18n sample, french translations are now in the "fr" subdirectory.
[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 #ifdef __GNUG__
11 #pragma implementation "notebook.h"
12 #endif
13
14 #include "wx/notebook.h"
15 #include "wx/panel.h"
16 #include "wx/utils.h"
17 #include "wx/imaglist.h"
18 #include "wx/intl.h"
19 #include "wx/log.h"
20
21 #include "gdk/gdk.h"
22 #include "gtk/gtk.h"
23 #include "wx/gtk/win_gtk.h"
24 #include "gdk/gdkkeysyms.h"
25
26 //-----------------------------------------------------------------------------
27 // data
28 //-----------------------------------------------------------------------------
29
30 extern bool g_blockEventsOnDrag;
31
32 //-----------------------------------------------------------------------------
33 // wxNotebookPage
34 //-----------------------------------------------------------------------------
35
36 class wxNotebookPage: public wxObject
37 {
38 public:
39 wxNotebookPage()
40 {
41 m_id = -1;
42 m_text = "";
43 m_image = -1;
44 m_page = (GtkNotebookPage *) NULL;
45 m_client = (wxWindow *) NULL;
46 m_parent = (GtkNotebook *) NULL;
47 m_box = (GtkWidget *) NULL;
48 m_added = FALSE;
49 }
50
51 /*
52 mark page as "added' to the notebook, return FALSE if the page was
53 already added
54 */
55
56 bool Add()
57 {
58 if ( WasAdded() )
59 return FALSE;
60
61 m_added = TRUE;
62 return TRUE;
63 }
64
65 bool WasAdded() const { return m_added; }
66
67 int m_id;
68 wxString m_text;
69 int m_image;
70 GtkNotebookPage *m_page;
71 GtkLabel *m_label;
72 wxWindow *m_client;
73 GtkNotebook *m_parent;
74 GtkWidget *m_box; // in which the label and image are packed
75
76 private:
77 bool m_added;
78 };
79
80 //-----------------------------------------------------------------------------
81 // "switch_page"
82 //-----------------------------------------------------------------------------
83
84 static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget),
85 GtkNotebookPage *WXUNUSED(page),
86 gint nPage,
87 gpointer data)
88 {
89 wxNotebook *notebook = (wxNotebook *)data;
90
91 int old = notebook->GetSelection();
92
93 // TODO: emulate PAGE_CHANGING event
94
95 wxNotebookEvent event( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
96 notebook->GetId(), nPage, old );
97 event.SetEventObject( notebook );
98 notebook->GetEventHandler()->ProcessEvent( event );
99 }
100
101 //-----------------------------------------------------------------------------
102 // "size_allocate"
103 //-----------------------------------------------------------------------------
104
105 static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win )
106 {
107 if ((win->m_x == alloc->x) &&
108 (win->m_y == alloc->y) &&
109 (win->m_width == alloc->width) &&
110 (win->m_height == alloc->height))
111 {
112 return;
113 }
114
115 win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
116
117 if (win->GetAutoLayout()) win->Layout();
118 }
119
120 //-----------------------------------------------------------------------------
121 // "key_press_event"
122 //-----------------------------------------------------------------------------
123
124 static gint
125 gtk_notebook_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxNotebook *notebook )
126 {
127 if (g_blockEventsOnDrag) return FALSE;
128
129 if (!notebook->HasVMT()) return FALSE;
130
131 if (gdk_event->keyval != GDK_Down) return FALSE;
132
133 if (notebook != notebook->FindFocus()) return FALSE;
134
135 if (notebook->m_pages.GetCount() == 0) return FALSE;
136
137 wxNode *node = notebook->m_pages.Nth( notebook->GetSelection() );
138
139 if (!node) return FALSE;
140
141 wxNotebookPage *page = (wxNotebookPage*) node->Data();
142
143 // don't let others the key event
144 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
145
146 page->m_client->SetFocus();
147
148 return TRUE;
149 }
150
151 //-----------------------------------------------------------------------------
152 // InsertChild callback for wxNotebook
153 //-----------------------------------------------------------------------------
154
155 static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
156 {
157 wxNotebookPage *page = new wxNotebookPage();
158
159 page->m_id = parent->GetPageCount();
160
161 page->m_box = gtk_hbox_new (FALSE, 0);
162 gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);
163
164 GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
165
166 page->m_client = child;
167 gtk_notebook_append_page( notebook, child->m_widget, page->m_box );
168
169 page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
170
171 page->m_parent = notebook;
172
173 gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
174 GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
175
176 wxASSERT_MSG( page->m_page, "Notebook page creation error" );
177
178 parent->m_pages.Append( page );
179 }
180
181 //-----------------------------------------------------------------------------
182 // wxNotebook
183 //-----------------------------------------------------------------------------
184
185 IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl)
186
187 void wxNotebook::Init()
188 {
189 m_imageList = (wxImageList *) NULL;
190 m_pages.DeleteContents( TRUE );
191 m_idHandler = 0;
192 }
193
194 wxNotebook::wxNotebook()
195 {
196 Init();
197 }
198
199 wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
200 const wxPoint& pos, const wxSize& size,
201 long style, const wxString& name )
202 {
203 Init();
204 Create( parent, id, pos, size, style, name );
205 }
206
207 wxNotebook::~wxNotebook()
208 {
209 // don't generate change page events any more
210 if (m_idHandler != 0)
211 gtk_signal_disconnect(GTK_OBJECT(m_widget), m_idHandler);
212
213 DeleteAllPages();
214 }
215
216 bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
217 const wxPoint& pos, const wxSize& size,
218 long style, const wxString& name )
219 {
220 m_needParent = TRUE;
221 m_acceptsFocus = TRUE;
222 m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook;
223
224 PreCreation( parent, id, pos, size, style, name );
225
226 m_widget = gtk_notebook_new();
227
228 #ifdef __WXDEBUG__
229 debug_focus_in( m_widget, "wxNotebook::m_widget", name );
230 #endif
231
232 gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
233
234 m_idHandler = gtk_signal_connect (
235 GTK_OBJECT(m_widget), "switch_page",
236 GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
237 (gpointer)this );
238
239 m_parent->AddChild( this );
240
241 (m_parent->m_insertCallback)( m_parent, this );
242
243 gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
244 GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );
245
246 PostCreation();
247
248 Show( TRUE );
249
250 return TRUE;
251 }
252
253 int wxNotebook::GetSelection() const
254 {
255 wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );
256
257 if (m_pages.Number() == 0) return -1;
258
259 GtkNotebookPage *g_page = GTK_NOTEBOOK(m_widget)->cur_page;
260 if (!g_page) return -1;
261
262 wxNotebookPage *page = (wxNotebookPage *) NULL;
263
264 wxNode *node = m_pages.First();
265 while (node)
266 {
267 page = (wxNotebookPage*)node->Data();
268
269 if ((page->m_page == g_page) || (page->m_page == (GtkNotebookPage*)NULL))
270 {
271 // page->m_page is NULL directly after gtk_notebook_append. gtk emits
272 // "switch_page" then and we ask for GetSelection() in the handler for
273 // "switch_page". otherwise m_page should never be NULL. all this
274 // might also be wrong.
275 break;
276 }
277 node = node->Next();
278 }
279
280 wxCHECK_MSG( node != NULL, -1, "wxNotebook: no selection?" );
281
282 return page->m_id;
283 }
284
285 int wxNotebook::GetPageCount() const
286 {
287 // count only the pages which were already added to the notebook for MSW
288 // compatibility (and, in fact, this behaviour makes more sense anyhow
289 // because only the added pages are shown)
290
291 int n = 0;
292 for ( wxNode *node = m_pages.First(); node; node = node->Next() )
293 {
294 wxNotebookPage *page = (wxNotebookPage*)node->Data();
295
296 if (page->WasAdded()) n++;
297 }
298
299 return n;
300 }
301
302 int wxNotebook::GetRowCount() const
303 {
304 return 1;
305 }
306
307 wxString wxNotebook::GetPageText( int page ) const
308 {
309 wxCHECK_MSG( m_widget != NULL, "", "invalid notebook" );
310
311 wxNotebookPage* nb_page = GetNotebookPage(page);
312 if (nb_page)
313 return nb_page->m_text;
314 else
315 return "";
316 }
317
318 int wxNotebook::GetPageImage( int page ) const
319 {
320 wxCHECK_MSG( m_widget != NULL, 0, "invalid notebook" );
321
322 wxNotebookPage* nb_page = GetNotebookPage(page);
323 if (nb_page)
324 return nb_page->m_image;
325 else
326 return 0;
327 }
328
329 wxNotebookPage* wxNotebook::GetNotebookPage(int page) const
330 {
331 wxCHECK_MSG( m_widget != NULL, (wxNotebookPage*)NULL, "invalid notebook" );
332
333 wxNotebookPage *nb_page = (wxNotebookPage *) NULL;
334
335 wxNode *node = m_pages.First();
336 while (node)
337 {
338 nb_page = (wxNotebookPage*)node->Data();
339 if (nb_page->m_id == page)
340 return nb_page;
341 node = node->Next();
342 }
343
344 wxFAIL_MSG( "Notebook page not found!" );
345
346 return (wxNotebookPage *) NULL;
347 }
348
349 int wxNotebook::SetSelection( int page )
350 {
351 wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );
352
353 int selOld = GetSelection();
354 wxNotebookPage* nb_page = GetNotebookPage(page);
355
356 if (!nb_page) return -1;
357
358 int page_num = 0;
359 GList *child = GTK_NOTEBOOK(m_widget)->children;
360 while (child)
361 {
362 if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
363 page_num++;
364 child = child->next;
365 }
366
367 if (!child) return -1;
368
369 gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page_num );
370
371 return selOld;
372 }
373
374 void wxNotebook::AdvanceSelection( bool bForward )
375 {
376 wxCHECK_RET( m_widget != NULL, "invalid notebook" );
377
378 int sel = GetSelection();
379 int max = GetPageCount();
380
381 if (bForward)
382 SetSelection( sel == max ? 0 : sel + 1 );
383 else
384 SetSelection( sel == 0 ? max : sel - 1 );
385 }
386
387 void wxNotebook::SetImageList( wxImageList* imageList )
388 {
389 m_imageList = imageList;
390 }
391
392 bool wxNotebook::SetPageText( int page, const wxString &text )
393 {
394 wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
395
396 wxNotebookPage* nb_page = GetNotebookPage(page);
397
398 if (!nb_page) return FALSE;
399
400 nb_page->m_text = text;
401
402 if (nb_page->m_text.IsEmpty()) nb_page->m_text = "";
403
404 gtk_label_set(nb_page->m_label, nb_page->m_text);
405
406 return TRUE;
407 }
408
409 bool wxNotebook::SetPageImage( int page, int image )
410 {
411 /* HvdH 28-12-98: now it works, but it's a bit of a kludge */
412
413 wxNotebookPage* nb_page = GetNotebookPage(page);
414
415 if (!nb_page) return FALSE;
416
417 /* Optimization posibility: return immediately if image unchanged.
418 * Not enabled because it may break existing (stupid) code that
419 * manipulates the imagelist to cycle images */
420
421 /* if (image == nb_page->m_image) return TRUE; */
422
423 /* For different cases:
424 1) no image -> no image
425 2) image -> no image
426 3) no image -> image
427 4) image -> image */
428
429 if (image == -1 && nb_page->m_image == -1)
430 return TRUE; /* Case 1): Nothing to do. */
431
432 GtkWidget *pixmapwid = (GtkWidget*) NULL;
433
434 if (nb_page->m_image != -1)
435 {
436 /* Case 2) or 4). There is already an image in the gtkhbox. Let's find it */
437
438 GList *child = gtk_container_children(GTK_CONTAINER(nb_page->m_box));
439 while (child)
440 {
441 if (GTK_IS_PIXMAP(child->data))
442 {
443 pixmapwid = GTK_WIDGET(child->data);
444 break;
445 }
446 child = child->next;
447 }
448
449 /* We should have the pixmap widget now */
450 wxASSERT(pixmapwid != NULL);
451
452 if (image == -1)
453 {
454 /* If there's no new widget, just remove the old from the box */
455 gtk_container_remove(GTK_CONTAINER(nb_page->m_box), pixmapwid);
456 nb_page->m_image = -1;
457
458 return TRUE; /* Case 2) */
459 }
460 }
461
462 /* Only cases 3) and 4) left */
463 wxASSERT( m_imageList != NULL ); /* Just in case */
464
465 /* Construct the new pixmap */
466 const wxBitmap *bmp = m_imageList->GetBitmap(image);
467 GdkPixmap *pixmap = bmp->GetPixmap();
468 GdkBitmap *mask = (GdkBitmap*) NULL;
469 if ( bmp->GetMask() )
470 {
471 mask = bmp->GetMask()->GetBitmap();
472 }
473
474 if (pixmapwid == NULL)
475 {
476 /* Case 3) No old pixmap. Create a new one and prepend it to the hbox */
477 pixmapwid = gtk_pixmap_new (pixmap, mask );
478
479 /* CHECKME: Are these pack flags okay? */
480 gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, 3);
481 gtk_widget_show(pixmapwid);
482 }
483 else
484 {
485 /* Case 4) Simply replace the pixmap */
486 gtk_pixmap_set(GTK_PIXMAP(pixmapwid), pixmap, mask);
487 }
488
489 nb_page->m_image = image;
490
491 return TRUE;
492 }
493
494 void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
495 {
496 wxFAIL_MSG( "wxNotebook::SetPageSize not implemented" );
497 }
498
499 void wxNotebook::SetPadding( const wxSize &WXUNUSED(padding) )
500 {
501 wxFAIL_MSG( "wxNotebook::SetPadding not implemented" );
502 }
503
504 bool wxNotebook::DeleteAllPages()
505 {
506 wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
507
508 wxNode *page_node = m_pages.First();
509 while (page_node)
510 {
511 wxNotebookPage *page = (wxNotebookPage*)page_node->Data();
512
513 DeletePage( page->m_id );
514
515 page_node = m_pages.First();
516 }
517
518 return TRUE;
519 }
520
521 bool wxNotebook::DeletePage( int page )
522 {
523 wxNotebookPage* nb_page = GetNotebookPage(page);
524 if (!nb_page) return FALSE;
525
526 int page_num = 0;
527 GList *child = GTK_NOTEBOOK(m_widget)->children;
528 while (child)
529 {
530 if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
531 page_num++;
532 child = child->next;
533 }
534
535 wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );
536
537 delete nb_page->m_client;
538
539 m_pages.DeleteObject( nb_page );
540
541 return TRUE;
542 }
543
544 bool wxNotebook::RemovePage( int page )
545 {
546 wxNotebookPage* nb_page = GetNotebookPage(page);
547 if (!nb_page) return FALSE;
548
549 int page_num = 0;
550 GList *child = GTK_NOTEBOOK(m_widget)->children;
551 while (child)
552 {
553 if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
554 page_num++;
555 child = child->next;
556 }
557
558 wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );
559
560 gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page_num );
561
562 m_pages.DeleteObject( nb_page );
563
564 return TRUE;
565 }
566
567 bool wxNotebook::AddPage(wxWindow* win, const wxString& text,
568 bool select, int imageId)
569 {
570 wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
571
572 /* we've created the notebook page in AddChild(). Now we just have to set
573 the caption for the page and set the others parameters. */
574
575 wxNotebookPage *page = (wxNotebookPage *) NULL;
576
577 wxNode *node = m_pages.First();
578 while (node)
579 {
580 page = (wxNotebookPage*)node->Data();
581 if ( page->m_client == win ) break;
582 node = node->Next();
583 }
584
585 wxCHECK_MSG( page != NULL, FALSE,
586 "Can't add a page whose parent is not the notebook!" );
587
588 wxCHECK_MSG( page->Add(), FALSE,
589 "Can't add the same page twice to a notebook." );
590
591 if (imageId != -1)
592 {
593 wxASSERT( m_imageList != NULL );
594
595 const wxBitmap *bmp = m_imageList->GetBitmap(imageId);
596 GdkPixmap *pixmap = bmp->GetPixmap();
597 GdkBitmap *mask = (GdkBitmap*) NULL;
598 if ( bmp->GetMask() )
599 {
600 mask = bmp->GetMask()->GetBitmap();
601 }
602
603 GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask );
604
605 gtk_box_pack_start(GTK_BOX(page->m_box), pixmapwid, FALSE, FALSE, 3);
606
607 gtk_widget_show(pixmapwid);
608 }
609
610 /* then set the attributes */
611 page->m_text = text;
612 if (page->m_text.IsEmpty()) page->m_text = "";
613 page->m_image = imageId;
614 page->m_label = (GtkLabel *)gtk_label_new(page->m_text);
615 gtk_box_pack_end( GTK_BOX(page->m_box), (GtkWidget *)page->m_label, FALSE, FALSE, 3);
616
617 /* @@@: what does this do? do we still need it?
618 gtk_misc_set_alignment(GTK_MISC(page->m_label), 0.0, 0.5); */
619
620 gtk_widget_show((GtkWidget *)page->m_label);
621
622 if (select) SetSelection( GetPageCount()-1 );
623
624 return TRUE;
625 }
626
627 wxWindow *wxNotebook::GetPage( int page ) const
628 {
629 wxCHECK_MSG( m_widget != NULL, (wxWindow*) NULL, "invalid notebook" );
630
631 wxNotebookPage* nb_page = GetNotebookPage(page);
632 if (!nb_page)
633 return (wxWindow *) NULL;
634 else
635 return nb_page->m_client;
636 }
637
638 // override these 2 functions to do nothing: everything is done in OnSize
639 void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
640 {
641 // don't set the sizes of the pages - their correct size is not yet known
642 wxControl::SetConstraintSizes(FALSE);
643 }
644
645 bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
646 {
647 return TRUE;
648 }
649
650 void wxNotebook::ApplyWidgetStyle()
651 {
652 SetWidgetStyle();
653 gtk_widget_set_style( m_widget, m_widgetStyle );
654 }
655
656 //-----------------------------------------------------------------------------
657 // wxNotebookEvent
658 //-----------------------------------------------------------------------------
659
660 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
661