]> git.sesse.net Git - vlc/blob - plugins/gnome/intf_gnome.c
* Fixed a remaining buffer overflow in the Gnome interface and applied
[vlc] / plugins / gnome / intf_gnome.c
1 /*****************************************************************************
2  * intf_gnome.c: Gnome interface
3  *****************************************************************************
4  * Copyright (C) 1999, 2000 VideoLAN
5  * $Id: intf_gnome.c,v 1.35 2001/05/01 15:12:22 sam Exp $
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *          Stéphane Borel <stef@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  * 
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 #define MODULE_NAME gnome
26 #include "modules_inner.h"
27
28 /*****************************************************************************
29  * Preamble
30  *****************************************************************************/
31 #include "defs.h"
32
33 #include <errno.h>                                                 /* ENOMEM */
34 #include <stdlib.h>                                                /* free() */
35 #include <string.h>                                            /* strerror() */
36 #include <stdio.h>
37
38 #include <gnome.h>
39
40 #include "config.h"
41 #include "common.h"
42 #include "threads.h"
43 #include "mtime.h"
44 #include "tests.h"
45 #include "modules.h"
46
47 #include "stream_control.h"
48 #include "input_ext-intf.h"
49
50 #include "intf_msg.h"
51 #include "interface.h"
52 #include "intf_playlist.h"
53
54 #include "gnome_callbacks.h"
55 #include "gnome_interface.h"
56 #include "gnome_support.h"
57 #include "intf_gnome.h"
58
59 #include "main.h"
60
61 /*****************************************************************************
62  * Local prototypes.
63  *****************************************************************************/
64 static int  intf_Probe     ( probedata_t *p_data );
65 static int  intf_Open      ( intf_thread_t *p_intf );
66 static void intf_Close     ( intf_thread_t *p_intf );
67 static void intf_Run       ( intf_thread_t *p_intf );
68
69 static gint GnomeManage    ( gpointer p_data );
70 static gint GnomeLanguageMenus( gpointer, GtkWidget *, es_descriptor_t *, gint,
71                               void (*pf_toggle)(GtkCheckMenuItem *, gpointer) );
72 static gint GnomeChapterMenu  ( gpointer, GtkWidget *,
73                               void (*pf_toggle)(GtkCheckMenuItem *, gpointer) );
74 static gint GnomeAngleMenu    ( gpointer, GtkWidget *,
75                               void (*pf_toggle)(GtkCheckMenuItem *, gpointer) );
76 static gint GnomeTitleMenu    ( gpointer, GtkWidget *, 
77                               void (*pf_toggle)(GtkCheckMenuItem *, gpointer) );
78 static gint GnomeSetupMenu    ( intf_thread_t * p_intf );
79 static void GnomeDisplayDate  ( GtkAdjustment *p_adj );
80 static gint GnomeDiscModeManage( intf_thread_t * p_intf );
81 static gint GnomeFileModeManage( intf_thread_t * p_intf );
82 static gint GnomeNetworkModeManage( intf_thread_t * p_intf );
83
84 /*****************************************************************************
85  * g_atexit: kludge to avoid the Gnome thread to segfault at exit
86  *****************************************************************************
87  * gtk_init() makes several calls to g_atexit() which calls atexit() to
88  * register tidying callbacks to be called at program exit. Since the Gnome
89  * plugin is likely to be unloaded at program exit, we have to export this
90  * symbol to intercept the g_atexit() calls. Talk about crude hack.
91  *****************************************************************************/
92 void g_atexit( GVoidFunc func )
93 {
94     intf_thread_t *p_intf = p_main->p_intf;
95
96     if( p_intf->p_sys->pf_gdk_callback == NULL )
97     {
98         p_intf->p_sys->pf_gdk_callback = func;
99     }
100     else if( p_intf->p_sys->pf_gtk_callback == NULL )
101     {
102         p_intf->p_sys->pf_gtk_callback = func;
103     }
104     /* else nothing, but we could do something here */
105     return;
106 }
107
108 /*****************************************************************************
109  * Functions exported as capabilities. They are declared as static so that
110  * we don't pollute the namespace too much.
111  *****************************************************************************/
112 void _M( intf_getfunctions )( function_list_t * p_function_list )
113 {
114     p_function_list->pf_probe = intf_Probe;
115     p_function_list->functions.intf.pf_open  = intf_Open;
116     p_function_list->functions.intf.pf_close = intf_Close;
117     p_function_list->functions.intf.pf_run   = intf_Run;
118 }
119
120 /*****************************************************************************
121  * intf_Probe: probe the interface and return a score
122  *****************************************************************************
123  * This function tries to initialize Gnome and returns a score to the
124  * plugin manager so that it can select the best plugin.
125  *****************************************************************************/
126 static int intf_Probe( probedata_t *p_data )
127 {
128     if( TestMethod( INTF_METHOD_VAR, "gnome" ) )
129     {
130         return( 999 );
131     }
132
133     if( TestProgram( "gnome-vlc" ) )
134     {
135         return( 200 );
136     }
137
138     return( 100 );
139 }
140
141 /*****************************************************************************
142  * intf_Open: initialize and create window
143  *****************************************************************************/
144 static int intf_Open( intf_thread_t *p_intf )
145 {
146     /* Allocate instance and initialize some members */
147     p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
148     if( p_intf->p_sys == NULL )
149     {
150         intf_ErrMsg("error: %s", strerror(ENOMEM));
151         return( 1 );
152     }
153
154     /* Initialize Gnome thread */
155     p_intf->p_sys->b_popup_changed = 0;
156     p_intf->p_sys->b_window_changed = 0;
157     p_intf->p_sys->b_playlist_changed = 0;
158
159     p_intf->p_sys->b_slider_free = 1;
160
161     p_intf->p_sys->b_mode_changed = 1;
162     p_intf->p_sys->i_intf_mode = FILE_MODE;
163
164     p_intf->p_sys->pf_gtk_callback = NULL;
165     p_intf->p_sys->pf_gdk_callback = NULL;
166
167     return( 0 );
168 }
169
170 /*****************************************************************************
171  * intf_Close: destroy interface window
172  *****************************************************************************/
173 static void intf_Close( intf_thread_t *p_intf )
174 {
175     /* Destroy structure */
176     free( p_intf->p_sys );
177 }
178
179 /*****************************************************************************
180  * intf_Run: Gnome thread
181  *****************************************************************************
182  * this part of the interface is in a separate thread so that we can call
183  * gtk_main() from within it without annoying the rest of the program.
184  * XXX: the approach may look kludgy, and probably is, but I could not find
185  * a better way to dynamically load a Gnome interface at runtime.
186  *****************************************************************************/
187 static void intf_Run( intf_thread_t *p_intf )
188 {
189     /* gnome_init needs to know the command line. We don't care, so we
190      * give it an empty one */
191     char *p_args[] = { "" };
192     int   i_args   = 1;
193
194     /* The data types we are allowed to receive */
195     static GtkTargetEntry target_table[] =
196     {
197         { "text/uri-list", 0, DROP_ACCEPT_TEXT_URI_LIST },
198         { "text/plain",    0, DROP_ACCEPT_TEXT_PLAIN }
199     };
200
201     /* intf_Manage callback timeout */
202     int i_timeout;
203
204     /* Initialize Gnome */
205     gnome_init( p_main->psz_arg0, VERSION, i_args, p_args );
206
207     /* Create some useful widgets that will certainly be used */
208     p_intf->p_sys->p_window = create_intf_window( );
209     p_intf->p_sys->p_popup = create_intf_popup( );
210     p_intf->p_sys->p_disc = create_intf_disc( );
211     p_intf->p_sys->p_network = create_intf_network( );
212
213     /* Set the title of the main window */
214     gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window),
215                           VOUT_TITLE " (Gnome interface)");
216
217     /* Accept file drops on the main window */
218     gtk_drag_dest_set( GTK_WIDGET( p_intf->p_sys->p_window ),
219                        GTK_DEST_DEFAULT_ALL, target_table,
220                        1, GDK_ACTION_COPY );
221
222     /* Get the interface labels */
223     #define P_LABEL( name ) GTK_LABEL( gtk_object_get_data( \
224                          GTK_OBJECT( p_intf->p_sys->p_window ), name ) )
225     p_intf->p_sys->p_label_date = P_LABEL( "label_date" );
226     p_intf->p_sys->p_label_status = P_LABEL( "label_status" );
227     p_intf->p_sys->p_label_title = P_LABEL( "label_title" );
228     p_intf->p_sys->p_label_chapter = P_LABEL( "label_chapter" );
229     #undef P_LABEL
230
231     /* Connect the date display to the slider */
232     #define P_SLIDER GTK_RANGE( gtk_object_get_data( \
233                          GTK_OBJECT( p_intf->p_sys->p_window ), "slider" ) )
234     p_intf->p_sys->p_adj = gtk_range_get_adjustment( P_SLIDER );
235
236     gtk_signal_connect ( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed",
237                          GTK_SIGNAL_FUNC( GnomeDisplayDate ), NULL );
238     p_intf->p_sys->f_adj_oldvalue = 0;
239     #undef P_SLIDER
240
241     /* We don't create these ones yet because we perhaps won't need them */
242     p_intf->p_sys->p_about = NULL;
243     p_intf->p_sys->p_playlist = NULL;
244     p_intf->p_sys->p_modules = NULL;
245     p_intf->p_sys->p_fileopen = NULL;
246
247     /* Store p_intf to keep an eye on it */
248     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window),
249                          "p_intf", p_intf );
250
251     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_popup),
252                          "p_intf", p_intf );
253
254     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_disc),
255                          "p_intf", p_intf );
256
257     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_network),
258                          "p_intf", p_intf );
259
260     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_adj),
261                          "p_intf", p_intf );
262
263     /* Show the control window */
264     gtk_widget_show( p_intf->p_sys->p_window );
265
266     /* Sleep to avoid using all CPU - since some interfaces needs to access
267      * keyboard events, a 100ms delay is a good compromise */
268     i_timeout = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, GnomeManage, p_intf );
269
270     /* Enter gnome mode */
271     gtk_main();
272
273     /* Remove the timeout */
274     gtk_timeout_remove( i_timeout );
275
276     /* Get rid of stored callbacks so we can unload the plugin */
277     if( p_intf->p_sys->pf_gtk_callback != NULL )
278     {
279         p_intf->p_sys->pf_gtk_callback( );
280         p_intf->p_sys->pf_gtk_callback = NULL;
281
282     }
283
284     if( p_intf->p_sys->pf_gdk_callback != NULL )
285     {
286         p_intf->p_sys->pf_gdk_callback( );
287         p_intf->p_sys->pf_gdk_callback = NULL;
288     }
289 }
290
291 /* following functions are local */
292
293 /*****************************************************************************
294  * GnomeManage: manage main thread messages
295  *****************************************************************************
296  * In this function, called approx. 10 times a second, we check what the
297  * main program wanted to tell us.
298  *****************************************************************************/
299 static gint GnomeManage( gpointer p_data )
300 {
301 #define p_intf ((intf_thread_t *)p_data)
302
303     vlc_mutex_lock( &p_intf->change_lock );
304
305     /* If the "display popup" flag has changed */
306     if( p_intf->b_menu_change )
307     {
308         gnome_popup_menu_do_popup( p_intf->p_sys->p_popup,
309                                    NULL, NULL, NULL, NULL );
310         p_intf->b_menu_change = 0;
311     }
312
313     if( p_intf->p_input != NULL )
314     {
315         GtkWidget *     p_slider;
316         float           newvalue;
317
318 //        vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
319         /* New input or stream map change */
320         if( p_intf->p_input->stream.b_changed || p_intf->p_sys->b_mode_changed )
321         {
322             switch( p_intf->p_input->stream.i_method & 0xf0 )
323             {
324                 case INPUT_METHOD_FILE:
325                     GnomeFileModeManage( p_intf );
326                     break;
327                 case INPUT_METHOD_DISC:
328                     GnomeDiscModeManage( p_intf );
329                     break;
330                 case INPUT_METHOD_NETWORK:
331                     GnomeNetworkModeManage( p_intf );
332                     break;
333                 default:
334                     intf_ErrMsg( "intf error: can't determine input method" );
335                     break;
336             }
337             p_slider = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
338                                    p_intf->p_sys->p_window ), "slider" ) );
339
340             if( p_intf->p_input->stream.b_seekable )
341             {
342                 gtk_widget_show( GTK_WIDGET( p_slider ) );
343             }
344             else
345             {
346                 gtk_widget_hide( GTK_WIDGET( p_slider ) );
347             }
348
349             /* get ready for menu regeneration */
350             p_intf->p_sys->b_title_update = 1;
351             p_intf->p_sys->b_chapter_update = 1;
352             p_intf->p_sys->b_angle_update = 1;
353             p_intf->p_sys->b_audio_update = 1;
354             p_intf->p_sys->b_spu_update = 1;
355             p_intf->p_sys->i_part = 0;
356
357             p_intf->p_input->stream.b_changed = 0;
358             p_intf->p_sys->b_mode_changed = 0;
359             intf_WarnMsg( 2, 
360                           "intf info: menus refreshed as stream has changed" );
361
362         }
363
364 //        vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
365
366         /* Update language/chapter menus after user request */
367         GnomeSetupMenu( p_intf );
368
369 #define p_area p_intf->p_input->stream.p_selected_area
370         /* Update menus when chapter changes */
371         p_intf->p_sys->b_chapter_update =
372                     ( p_intf->p_sys->i_part != p_area->i_part );
373
374         if( p_intf->p_input->stream.b_seekable )
375         {
376             /* Manage the slider */
377             newvalue = p_intf->p_sys->p_adj->value;
378     
379             /* If the user hasn't touched the slider since the last time,
380              * then the input can safely change it */
381             if( newvalue == p_intf->p_sys->f_adj_oldvalue )
382             {
383                 /* Update the value */
384                 p_intf->p_sys->p_adj->value = p_intf->p_sys->f_adj_oldvalue =
385                     ( 100. * p_area->i_tell ) / p_area->i_size;
386     
387                 gtk_signal_emit_by_name( GTK_OBJECT( p_intf->p_sys->p_adj ),
388                                          "value_changed" );
389             }
390             /* Otherwise, send message to the input if the user has
391              * finished dragging the slider */
392             else if( p_intf->p_sys->b_slider_free )
393             {
394                 off_t i_seek = ( newvalue * p_area->i_size ) / 100;
395     
396                 input_Seek( p_intf->p_input, i_seek );
397     
398                 /* Update the old value */
399                 p_intf->p_sys->f_adj_oldvalue = newvalue;
400             }
401         }
402 #undef p_area
403     }
404
405     /* Manage core vlc functions through the callback */
406     p_intf->pf_manage( p_intf );
407
408     if( p_intf->b_die )
409     {
410         vlc_mutex_unlock( &p_intf->change_lock );
411
412         /* Prepare to die, young Skywalker */
413         gtk_main_quit();
414
415         /* Just in case */
416         return( FALSE );
417     }
418
419     vlc_mutex_unlock( &p_intf->change_lock );
420
421     return( TRUE );
422
423 #undef p_intf
424 }
425
426 /*****************************************************************************
427  * GnomeLanguageMenus: update interactive menus of the interface
428  *****************************************************************************
429  * Sets up menus with information from input:
430  *  -languages
431  *  -sub-pictures
432  * Warning: since this function is designed to be called by management
433  * function, the interface lock has to be taken
434  *****************************************************************************/
435 static gint GnomeLanguageMenus( gpointer          p_data,
436                                 GtkWidget *       p_root,
437                                 es_descriptor_t * p_es,
438                                 gint              i_cat,
439                           void(*pf_toggle )( GtkCheckMenuItem *, gpointer ) )
440 {
441     intf_thread_t *     p_intf;
442     GtkWidget *         p_menu;
443     GtkWidget *         p_separator;
444     GtkWidget *         p_item;
445     GtkWidget *         p_item_active;
446     GSList *            p_group;
447     char                psz_name[ GNOME_MENU_LABEL_SIZE ];
448     gint                i_item;
449     gint                i;
450
451     
452
453     /* cast */
454     p_intf = (intf_thread_t *)p_data;
455
456     /* removes previous menu */
457     gtk_menu_item_remove_submenu( GTK_MENU_ITEM( p_root ) );
458     gtk_widget_set_sensitive( p_root, FALSE );
459
460     p_group = NULL;
461
462     /* menu container */
463     p_menu = gtk_menu_new();
464
465     /* special case for "off" item */
466     snprintf( psz_name, GNOME_MENU_LABEL_SIZE, "Off" );
467     psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
468
469     p_item = gtk_radio_menu_item_new_with_label( p_group, psz_name );
470     p_group = gtk_radio_menu_item_group( GTK_RADIO_MENU_ITEM( p_item ) );
471
472     gtk_widget_show( p_item );
473
474     /* signal hanling for off */
475     gtk_signal_connect( GTK_OBJECT( p_item ), "toggled",
476                         GTK_SIGNAL_FUNC ( pf_toggle ), NULL );
477
478     gtk_menu_append( GTK_MENU( p_menu ), p_item );
479
480     p_separator = gtk_menu_item_new();
481     gtk_widget_set_sensitive( p_separator, FALSE );
482     gtk_widget_show( p_separator );
483     gtk_menu_append( GTK_MENU( p_menu ), p_separator );
484
485     vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
486     p_item_active = NULL;
487     i_item = 0;
488
489     /* create a set of language buttons and append them to the container */
490     for( i = 0 ; i < p_intf->p_input->stream.i_es_number ; i++ )
491     {
492         if( p_intf->p_input->stream.pp_es[i]->i_cat == i_cat )
493         {
494             i_item++;
495             strcpy( psz_name, p_intf->p_input->stream.pp_es[i]->psz_desc );
496             if( psz_name[0] == '\0' )
497             {
498                 snprintf( psz_name, GNOME_MENU_LABEL_SIZE,
499                           "Language %d", i_item );
500                 psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
501             }
502
503             p_item = gtk_radio_menu_item_new_with_label( p_group, psz_name );
504             p_group =
505                 gtk_radio_menu_item_group( GTK_RADIO_MENU_ITEM( p_item ) );
506
507             if( p_es == p_intf->p_input->stream.pp_es[i] )
508             {
509                 /* don't lose p_item when we append into menu */
510                 p_item_active = p_item;
511             }
512
513             gtk_widget_show( p_item );
514
515             /* setup signal hanling */
516             gtk_signal_connect( GTK_OBJECT( p_item ), "toggled",
517                             GTK_SIGNAL_FUNC( pf_toggle ),
518                             (gpointer)( p_intf->p_input->stream.pp_es[i] ) );
519
520             gtk_menu_append( GTK_MENU( p_menu ), p_item );
521         }
522     }
523
524     vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
525
526     /* link the new menu to the menubar item */
527     gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_root ), p_menu );
528
529     /* acitvation will call signals so we can only do it
530      * when submenu is attached to menu - to get intf_window */
531     if( p_item_active != NULL )
532     {
533         gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( p_item_active ),
534                                         TRUE );
535     }
536
537     /* be sure that menu is sensitive if non empty */
538     if( i_item > 0 )
539     {
540         gtk_widget_set_sensitive( p_root, TRUE );
541     }
542
543     return TRUE;
544 }
545
546 /*****************************************************************************
547  * GnomeAngleMenu: generate angle menu for current title
548  *****************************************************************************/
549 static gint GnomeAngleMenu( gpointer p_data, GtkWidget * p_angle,
550                         void(*pf_toggle)( GtkCheckMenuItem *, gpointer ) )
551 {
552     intf_thread_t *     p_intf;
553     char                psz_name[ GNOME_MENU_LABEL_SIZE ];
554     GtkWidget *         p_angle_menu;
555     GSList *            p_angle_group;
556     GtkWidget *         p_item;
557     GtkWidget *         p_item_active;
558     gint                i_angle;
559
560     /* cast */
561     p_intf = (intf_thread_t*)p_data;
562
563     /* removes previous menu */
564     gtk_menu_item_remove_submenu( GTK_MENU_ITEM( p_angle ) );
565     gtk_widget_set_sensitive( p_angle, FALSE );
566
567     p_angle_menu = gtk_menu_new();;
568     p_angle_group = NULL;
569     p_item = NULL;
570     p_item_active = NULL;
571
572     for( i_angle = 0 ;
573          i_angle < p_intf->p_input->stream.p_selected_area->i_angle_nb ;
574          i_angle++ )
575     {
576         snprintf( psz_name, GNOME_MENU_LABEL_SIZE, "Angle %d", i_angle + 1 );
577         psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
578
579         p_item = gtk_radio_menu_item_new_with_label( p_angle_group,
580                                                      psz_name );
581         p_angle_group =
582             gtk_radio_menu_item_group( GTK_RADIO_MENU_ITEM( p_item ) );
583
584         if( p_intf->p_input->stream.p_selected_area->i_angle ==
585                                                             ( i_angle + 1 ) )
586         {
587             p_item_active = p_item;
588         }
589
590         gtk_widget_show( p_item );
591
592         /* setup signal hanling */
593         gtk_signal_connect( GTK_OBJECT( p_item ),
594                         "toggled",
595                         GTK_SIGNAL_FUNC( pf_toggle ),
596                         (gpointer)(i_angle + 1) );
597
598         gtk_menu_append( GTK_MENU( p_angle_menu ), p_item );
599     }
600
601     gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_angle ), p_angle_menu );
602
603     if( p_item_active != NULL )
604     {
605         gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( p_item_active ),
606                                         TRUE );
607     }
608
609     /* be sure that menu is sensitive if non empty */
610     if( p_intf->p_input->stream.p_selected_area->i_angle_nb > 1 )
611     {
612         gtk_widget_set_sensitive( p_angle, TRUE );
613     }
614
615     return TRUE;
616 }
617
618 /*****************************************************************************
619  * GnomeChapterMenu: generate chapter menu for current title
620  *****************************************************************************/
621 static gint GnomeChapterMenu( gpointer p_data, GtkWidget * p_chapter,
622                         void(*pf_toggle )( GtkCheckMenuItem *, gpointer ) )
623 {
624     intf_thread_t *     p_intf;
625     char                psz_name[ GNOME_MENU_LABEL_SIZE ];
626     GtkWidget *         p_chapter_menu;
627     GtkWidget *         p_chapter_submenu;
628     GtkWidget *         p_menu_item;
629     GtkWidget *         p_item;
630     GtkWidget *         p_item_selected;
631     GSList *            p_chapter_group;
632     gint                i_title;
633     gint                i_chapter;
634     gint                i_nb;
635
636     /* Cast */
637     p_intf = (intf_thread_t*)p_data;
638
639     /* Removes previous menu */
640     gtk_menu_item_remove_submenu( GTK_MENU_ITEM( p_chapter ) );
641     gtk_widget_set_sensitive( p_chapter, FALSE );
642
643     p_chapter_submenu = NULL;
644     p_chapter_group = NULL;
645     p_item_selected = NULL;
646     p_menu_item = NULL;
647
648     i_title = p_intf->p_input->stream.p_selected_area->i_id;
649     p_chapter_menu = gtk_menu_new();
650     i_nb = p_intf->p_input->stream.pp_areas[i_title]->i_part_nb;
651
652     for( i_chapter = 0 ; i_chapter < i_nb ; i_chapter++ )
653     {
654         /* we group chapters in packets of ten for small screens */
655         if( ( i_chapter % 10 == 0 ) && ( i_nb > 20 ) )
656         {
657             if( i_chapter != 0 )
658             {
659                 gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_menu_item ),
660                                            p_chapter_submenu );
661                 gtk_menu_append( GTK_MENU( p_chapter_menu ), p_menu_item );
662             }
663
664             snprintf( psz_name, GNOME_MENU_LABEL_SIZE,
665                       "%d - %d", i_chapter + 1, i_chapter + 10);
666             psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
667             p_menu_item = gtk_menu_item_new_with_label( psz_name );
668             gtk_widget_show( p_menu_item );
669             p_chapter_submenu = gtk_menu_new();
670         }
671
672         snprintf( psz_name, GNOME_MENU_LABEL_SIZE,
673                   "Chapter %d", i_chapter + 1 );
674         psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
675
676         p_item = gtk_radio_menu_item_new_with_label( p_chapter_group,
677                                                      psz_name );
678         p_chapter_group =
679             gtk_radio_menu_item_group( GTK_RADIO_MENU_ITEM( p_item ) );
680
681         if( p_intf->p_input->stream.pp_areas[i_title]->i_part
682                      == i_chapter + 1 )
683         {
684             p_item_selected = p_item;
685         }
686         
687         gtk_widget_show( p_item );
688
689         /* setup signal hanling */
690         gtk_signal_connect( GTK_OBJECT( p_item ),
691                         "toggled",
692                         GTK_SIGNAL_FUNC( pf_toggle ),
693                         (gpointer)(i_chapter + 1) );
694
695         if( i_nb > 20 )
696         {
697             gtk_menu_append( GTK_MENU( p_chapter_submenu ), p_item );
698         }
699         else
700         {
701             gtk_menu_append( GTK_MENU( p_chapter_menu ), p_item );
702         }
703     }
704
705     if( i_nb > 20 )
706     {
707         gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_menu_item ),
708                                    p_chapter_submenu );
709         gtk_menu_append( GTK_MENU( p_chapter_menu ), p_menu_item );
710     }
711
712     /* link the new menu to the title menu item */
713     gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_chapter ),
714                                p_chapter_menu );
715
716     /* toggle currently selected chapter */
717     if( p_item_selected != NULL )
718     {
719         gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( p_item_selected ),
720                                         TRUE );
721     }
722
723     /* be sure that chapter menu is sensitive, if there are several items */
724     if( p_intf->p_input->stream.pp_areas[i_title]->i_part_nb > 1 )
725     {
726         gtk_widget_set_sensitive( p_chapter, TRUE );
727     }
728
729     return TRUE;
730 }
731
732 /*****************************************************************************
733  * GnomeTitleMenu: sets menus for titles and chapters selection
734  *****************************************************************************
735  * Generates two types of menus:
736  *  -simple list of titles
737  *  -cascaded lists of chapters for each title
738  *****************************************************************************/
739 static gint GnomeTitleMenu( gpointer       p_data,
740                             GtkWidget *    p_navigation, 
741                             void(*pf_toggle )( GtkCheckMenuItem *, gpointer ) )
742 {
743     intf_thread_t *     p_intf;
744     char                psz_name[ GNOME_MENU_LABEL_SIZE ];
745     GtkWidget *         p_title_menu;
746     GtkWidget *         p_title_submenu;
747     GtkWidget *         p_title_item;
748     GtkWidget *         p_item_active;
749     GtkWidget *         p_chapter_menu;
750     GtkWidget *         p_chapter_submenu;
751     GtkWidget *         p_title_menu_item;
752     GtkWidget *         p_chapter_menu_item;
753     GtkWidget *         p_item;
754     GSList *            p_title_group;
755     GSList *            p_chapter_group;
756     gint                i_title;
757     gint                i_chapter;
758     gint                i_title_nb;
759     gint                i_chapter_nb;
760
761     /* cast */
762     p_intf = (intf_thread_t*)p_data;
763
764     /* removes previous menu */
765     gtk_menu_item_remove_submenu( GTK_MENU_ITEM( p_navigation ) );
766     gtk_widget_set_sensitive( p_navigation, FALSE );
767
768     p_title_menu = gtk_menu_new();
769     p_title_group = NULL;
770     p_title_submenu = NULL;
771     p_title_menu_item = NULL;
772     p_chapter_group = NULL;
773     p_chapter_submenu = NULL;
774     p_chapter_menu_item = NULL;
775     p_item_active = NULL;
776     i_title_nb = p_intf->p_input->stream.i_area_nb;
777
778     /* loop on titles */
779     for( i_title = 1 ; i_title < i_title_nb ; i_title++ )
780     {
781         /* we group titles in packets of ten for small screens */
782         if( ( i_title % 10 == 1 ) && ( i_title_nb > 20 ) )
783         {
784             if( i_title != 1 )
785             {
786                 gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_title_menu_item ),
787                                            p_title_submenu );
788                 gtk_menu_append( GTK_MENU( p_title_menu ), p_title_menu_item );
789             }
790
791             snprintf( psz_name, GNOME_MENU_LABEL_SIZE,
792                       "%d - %d", i_title, i_title + 9 );
793             psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
794             p_title_menu_item = gtk_menu_item_new_with_label( psz_name );
795             gtk_widget_show( p_title_menu_item );
796             p_title_submenu = gtk_menu_new();
797         }
798
799         snprintf( psz_name, GNOME_MENU_LABEL_SIZE, "Title %d (%d)", i_title,
800                   p_intf->p_input->stream.pp_areas[i_title]->i_part_nb );
801         psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
802
803         if( pf_toggle == on_menubar_title_toggle )
804         {
805             p_title_item = gtk_radio_menu_item_new_with_label( p_title_group,
806                                                            psz_name );
807             p_title_group =
808               gtk_radio_menu_item_group( GTK_RADIO_MENU_ITEM( p_title_item ) );
809
810             if( p_intf->p_input->stream.pp_areas[i_title] ==
811                          p_intf->p_input->stream.p_selected_area )
812             {
813                 p_item_active = p_title_item;
814             }
815
816             /* setup signal hanling */
817             gtk_signal_connect( GTK_OBJECT( p_title_item ),
818                      "toggled",
819                      GTK_SIGNAL_FUNC( pf_toggle ),
820                      (gpointer)(p_intf->p_input->stream.pp_areas[i_title]) );
821
822             if( p_intf->p_input->stream.i_area_nb > 1 )
823             {
824                 /* be sure that menu is sensitive */
825                 gtk_widget_set_sensitive( p_navigation, TRUE );
826             }
827         }
828         else
829         {
830     
831             p_title_item = gtk_menu_item_new_with_label( psz_name );
832             p_chapter_menu = gtk_menu_new();
833             i_chapter_nb =
834                     p_intf->p_input->stream.pp_areas[i_title]->i_part_nb;
835     
836             for( i_chapter = 0 ; i_chapter < i_chapter_nb ; i_chapter++ )
837             {
838                 /* we group chapters in packets of ten for small screens */
839                 if( ( i_chapter % 10 == 0 ) && ( i_chapter_nb > 20 ) )
840                 {
841                     if( i_chapter != 0 )
842                     {
843                         gtk_menu_item_set_submenu(
844                                     GTK_MENU_ITEM( p_chapter_menu_item ),
845                                     p_chapter_submenu );
846                         gtk_menu_append( GTK_MENU( p_chapter_menu ),
847                                          p_chapter_menu_item );
848                     }
849
850                     snprintf( psz_name, GNOME_MENU_LABEL_SIZE,
851                               "%d - %d", i_chapter + 1, i_chapter + 10 );
852                     psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
853                     p_chapter_menu_item =
854                             gtk_menu_item_new_with_label( psz_name );
855                     gtk_widget_show( p_chapter_menu_item );
856                     p_chapter_submenu = gtk_menu_new();
857                 }
858
859                 snprintf( psz_name, GNOME_MENU_LABEL_SIZE,
860                           "Chapter %d", i_chapter + 1 );
861                 psz_name[ GNOME_MENU_LABEL_SIZE - 1 ] = '\0';
862     
863                 p_item = gtk_radio_menu_item_new_with_label(
864                                                 p_chapter_group, psz_name );
865                 p_chapter_group = gtk_radio_menu_item_group(
866                                                 GTK_RADIO_MENU_ITEM( p_item ) );
867                 gtk_widget_show( p_item );
868
869 #define p_area p_intf->p_input->stream.pp_areas[i_title]
870                 if( ( p_area == p_intf->p_input->stream.p_selected_area ) &&
871                     ( p_area->i_part == i_chapter + 1 ) )
872                 {
873                     p_item_active = p_item;
874                 }
875 #undef p_area
876
877                 /* setup signal hanling */
878                 gtk_signal_connect( GTK_OBJECT( p_item ),
879                            "toggled",
880                            GTK_SIGNAL_FUNC( pf_toggle ),
881                            (gpointer)( ( i_title * 100 ) + ( i_chapter + 1) ) );
882
883                 if( i_chapter_nb > 20 )
884                 {
885                     gtk_menu_append( GTK_MENU( p_chapter_submenu ), p_item );
886                 }
887                 else
888                 {
889                     gtk_menu_append( GTK_MENU( p_chapter_menu ), p_item );
890                 }
891             }
892
893             if( i_chapter_nb > 20 )
894             {
895                 gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_chapter_menu_item ),
896                                            p_chapter_submenu );
897                 gtk_menu_append( GTK_MENU( p_chapter_menu ),
898                                  p_chapter_menu_item );
899             }
900
901             /* link the new menu to the title menu item */
902             gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_title_item ),
903                                        p_chapter_menu );
904
905             if( p_intf->p_input->stream.pp_areas[i_title]->i_part_nb > 1 )
906             {
907                 /* be sure that menu is sensitive */
908                 gtk_widget_set_sensitive( p_navigation, TRUE );
909             }
910         }
911         gtk_widget_show( p_title_item );
912
913         if( i_title_nb > 20 )
914         {
915             gtk_menu_append( GTK_MENU( p_title_submenu ), p_title_item );
916         }
917         else
918         {
919             gtk_menu_append( GTK_MENU( p_title_menu ), p_title_item );
920         }
921     }
922
923     if( i_title_nb > 20 )
924     {
925         gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_title_menu_item ),
926                                    p_title_submenu );
927         gtk_menu_append( GTK_MENU( p_title_menu ), p_title_menu_item );
928     }
929
930     /* be sure that menu is sensitive */
931     gtk_widget_set_sensitive( p_title_menu, TRUE );
932
933     /* link the new menu to the menubar item */
934     gtk_menu_item_set_submenu( GTK_MENU_ITEM( p_navigation ), p_title_menu );
935
936     if( p_item_active != NULL )
937     {
938         gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( p_item_active ),
939                                         TRUE );
940     }
941
942     return TRUE;
943 }
944
945 /*****************************************************************************
946  * GnomeSetupMenu: function that generates title/chapter/audio/subpic
947  * menus with help from preceding functions
948  *****************************************************************************/
949 static gint GnomeSetupMenu( intf_thread_t * p_intf )
950 {
951     es_descriptor_t *   p_audio_es;
952     es_descriptor_t *   p_spu_es;
953     GtkWidget *         p_menubar_menu;
954     GtkWidget *         p_popup_menu;
955     gint                i;
956
957     p_intf->p_sys->b_chapter_update |= p_intf->p_sys->b_title_update;
958     p_intf->p_sys->b_angle_update |= p_intf->p_sys->b_title_update;
959     p_intf->p_sys->b_audio_update |= p_intf->p_sys->b_title_update;
960     p_intf->p_sys->b_spu_update |= p_intf->p_sys->b_title_update;
961
962     if( p_intf->p_sys->b_title_update )
963     { 
964         char            psz_title[5];
965
966         p_menubar_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT( 
967                             p_intf->p_sys->p_window ), "menubar_title" ) );
968         GnomeTitleMenu( p_intf, p_menubar_menu, on_menubar_title_toggle );
969
970         snprintf( psz_title, 4, "%d",
971                   p_intf->p_input->stream.p_selected_area->i_id );
972         psz_title[ 4 ] = '\0';
973         gtk_label_set_text( p_intf->p_sys->p_label_title, psz_title );
974
975         p_intf->p_sys->b_title_update = 0;
976     }
977
978     if( p_intf->p_sys->b_chapter_update )
979     {
980         char            psz_chapter[5];
981
982         p_popup_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT( 
983                              p_intf->p_sys->p_popup ), "popup_navigation" ) );
984         GnomeTitleMenu( p_intf, p_popup_menu, on_popup_navigation_toggle );
985      
986         p_menubar_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT( 
987                              p_intf->p_sys->p_window ), "menubar_chapter" ) );
988         GnomeChapterMenu( p_intf, p_menubar_menu, on_menubar_chapter_toggle );
989
990         snprintf( psz_chapter, 4, "%d", 
991                   p_intf->p_input->stream.p_selected_area->i_part );
992         psz_chapter[ 4 ] = '\0';
993         gtk_label_set_text( p_intf->p_sys->p_label_chapter, psz_chapter );
994
995         p_intf->p_sys->i_part =
996                 p_intf->p_input->stream.p_selected_area->i_part;
997
998         p_intf->p_sys->b_chapter_update = 0;
999     }
1000
1001     if( p_intf->p_sys->b_angle_update )
1002     {
1003         p_menubar_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT( 
1004                              p_intf->p_sys->p_window ), "menubar_angle" ) );
1005         GnomeAngleMenu( p_intf, p_menubar_menu, on_menubar_angle_toggle );
1006
1007         p_popup_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT( 
1008                              p_intf->p_sys->p_popup ), "popup_angle" ) );
1009         GnomeAngleMenu( p_intf, p_popup_menu, on_popup_angle_toggle );
1010
1011         p_intf->p_sys->b_angle_update = 0;
1012     }
1013     
1014     /* look for selected ES */
1015     p_audio_es = NULL;
1016     p_spu_es = NULL;
1017
1018     for( i = 0 ; i < p_intf->p_input->stream.i_selected_es_number ; i++ )
1019     {
1020         if( p_intf->p_input->stream.pp_selected_es[i]->i_cat == AUDIO_ES )
1021         {
1022             p_audio_es = p_intf->p_input->stream.pp_selected_es[i];
1023         }
1024
1025         if( p_intf->p_input->stream.pp_selected_es[i]->i_cat == SPU_ES )
1026         {
1027             p_spu_es = p_intf->p_input->stream.pp_selected_es[i];
1028         }
1029     }
1030
1031     /* audio menus */
1032     if( p_intf->p_sys->b_audio_update )
1033     {
1034         /* find audio root menu */
1035         p_menubar_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1036                              p_intf->p_sys->p_window ), "menubar_audio" ) );
1037     
1038         p_popup_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT( 
1039                      p_intf->p_sys->p_popup ), "popup_audio" ) );
1040     
1041         GnomeLanguageMenus( p_intf, p_menubar_menu, p_audio_es, AUDIO_ES,
1042                             on_menubar_audio_toggle );
1043         GnomeLanguageMenus( p_intf, p_popup_menu, p_audio_es, AUDIO_ES,
1044                             on_popup_audio_toggle );
1045
1046         p_intf->p_sys->b_audio_update = 0;
1047     }
1048     
1049     /* sub picture menus */
1050     if( p_intf->p_sys->b_spu_update )
1051     {
1052         /* find spu root menu */
1053         p_menubar_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1054                           p_intf->p_sys->p_window ), "menubar_subtitle" ) );
1055     
1056         p_popup_menu = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT( 
1057                      p_intf->p_sys->p_popup ), "popup_subtitle" ) );
1058     
1059         GnomeLanguageMenus( p_intf, p_menubar_menu, p_spu_es, SPU_ES,
1060                             on_menubar_subtitle_toggle  );
1061         GnomeLanguageMenus( p_intf, p_popup_menu, p_spu_es, SPU_ES,
1062                             on_popup_subtitle_toggle );
1063
1064         p_intf->p_sys->b_spu_update = 0;
1065     }
1066
1067     return TRUE;
1068 }
1069
1070 /*****************************************************************************
1071  * GnomeDisplayDate: display stream date
1072  *****************************************************************************
1073  * This function displays the current date related to the position in
1074  * the stream. It is called whenever the slider changes its value.
1075  *****************************************************************************/
1076 void GnomeDisplayDate( GtkAdjustment *p_adj )
1077 {
1078     intf_thread_t *p_intf;
1079    
1080     p_intf = gtk_object_get_data( GTK_OBJECT( p_adj ), "p_intf" );
1081
1082     if( p_intf->p_input != NULL )
1083     {
1084 #define p_area p_intf->p_input->stream.p_selected_area
1085         char psz_time[ OFFSETTOTIME_MAX_SIZE ];
1086
1087         vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
1088
1089         gtk_label_set_text( p_intf->p_sys->p_label_date,
1090                             input_OffsetToTime( p_intf->p_input, psz_time,
1091                                    ( p_area->i_size * p_adj->value ) / 100 ) );
1092
1093         vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
1094 #undef p_area
1095      }
1096 }
1097
1098
1099 /*****************************************************************************
1100  * GnomeDiscModeManage
1101  *****************************************************************************/
1102 static gint GnomeDiscModeManage( intf_thread_t * p_intf )
1103 {
1104     GtkWidget *     p_dvd_box;
1105     GtkWidget *     p_file_box;
1106     GtkWidget *     p_network_box;
1107
1108     p_file_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1109                  p_intf->p_sys->p_window ), "file_box" ) );
1110     gtk_widget_hide( GTK_WIDGET( p_file_box ) );
1111
1112     p_network_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1113                  p_intf->p_sys->p_window ), "network_box" ) );
1114     gtk_widget_hide( GTK_WIDGET( p_network_box ) );
1115
1116     p_dvd_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1117                  p_intf->p_sys->p_window ), "dvd_box" ) );
1118     gtk_widget_show( GTK_WIDGET( p_dvd_box ) );
1119
1120     gtk_label_set_text( p_intf->p_sys->p_label_status,
1121                         "Status: playing DVD" );
1122
1123     return TRUE;
1124 }
1125
1126 /*****************************************************************************
1127  * GnomeFileModeManage
1128  *****************************************************************************/
1129 static gint GnomeFileModeManage( intf_thread_t * p_intf )
1130 {
1131     GtkWidget *     p_dvd_box;
1132     GtkWidget *     p_file_box;
1133     GtkWidget *     p_network_box;
1134     char *          psz_name;
1135
1136     p_network_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1137                  p_intf->p_sys->p_window ), "network_box" ) );
1138     gtk_widget_hide( GTK_WIDGET( p_network_box ) );
1139
1140     p_dvd_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1141                  p_intf->p_sys->p_window ), "dvd_box" ) );
1142     gtk_widget_hide( GTK_WIDGET( p_dvd_box ) );
1143
1144     p_file_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1145                  p_intf->p_sys->p_window ), "file_box" ) );
1146     gtk_widget_show( GTK_WIDGET( p_file_box ) );
1147
1148 #if 1
1149 //    psz_name = malloc( 16 + strlen( p_intf->p_input->p_source ) );
1150 //    sprintf( psz_name, "Status: playing %s", p_intf->p_input->p_source );
1151
1152     psz_name = strdup( p_intf->p_input->p_source );
1153
1154     gtk_label_set_text( p_intf->p_sys->p_label_status, psz_name );
1155
1156     free( psz_name );
1157 #else
1158     gtk_label_set_text( p_intf->p_sys->p_label_status,
1159                         "Status: foo" );
1160 #endif
1161
1162     return TRUE;
1163 }
1164
1165 /*****************************************************************************
1166  * GnomeNetworkModeManage
1167  *****************************************************************************/
1168 static gint GnomeNetworkModeManage( intf_thread_t * p_intf )
1169 {
1170     GtkWidget *     p_dvd_box;
1171     GtkWidget *     p_file_box;
1172     GtkWidget *     p_network_box;
1173
1174     p_dvd_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1175                  p_intf->p_sys->p_window ), "dvd_box" ) );
1176     gtk_widget_hide( GTK_WIDGET( p_dvd_box ) );
1177
1178     p_file_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1179                  p_intf->p_sys->p_window ), "file_box" ) );
1180     gtk_widget_hide( GTK_WIDGET( p_file_box ) );
1181
1182     p_network_box = GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
1183                  p_intf->p_sys->p_window ), "network_box" ) );
1184     gtk_widget_show( GTK_WIDGET( p_network_box ) );
1185
1186     gtk_label_set_text( p_intf->p_sys->p_label_status,
1187                         "Status: waiting for stream" );
1188
1189     return TRUE;
1190 }