git.sesse.net Git - vlc/blob - plugins/gtk/intf_gnome.c

   1 /*****************************************************************************
   2  * intf_gnome.c: Gnome interface
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: intf_gnome.c,v 1.2 2001/05/30 17:03:12 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
  46 #include "stream_control.h"
  47 #include "input_ext-intf.h"
  48
  49 #include "intf_msg.h"
  50 #include "interface.h"
  51 #include "intf_playlist.h"
  52
  53 #include "video.h"
  54 #include "video_output.h"
  55
  56 #include "gnome_callbacks.h"
  57 #include "gnome_interface.h"
  58 #include "gnome_support.h"
  59 #include "gtk_display.h"
  60 #include "intf_gtk.h"
  61
  62 #include "main.h"
  63
  64 #include "modules.h"
  65 #include "modules_export.h"
  66
  67 /*****************************************************************************
  68  * Local prototypes.
  69  *****************************************************************************/
  70 static int  intf_Probe      ( probedata_t *p_data );
  71 static int  intf_Open       ( intf_thread_t *p_intf );
  72 static void intf_Close      ( intf_thread_t *p_intf );
  73 static void intf_Run        ( intf_thread_t *p_intf );
  74
  75 static gint GnomeManage     ( gpointer p_data );
  76
  77 /*****************************************************************************
  78  * g_atexit: kludge to avoid the Gnome thread to segfault at exit
  79  *****************************************************************************
  80  * gtk_init() makes several calls to g_atexit() which calls atexit() to
  81  * register tidying callbacks to be called at program exit. Since the Gnome
  82  * plugin is likely to be unloaded at program exit, we have to export this
  83  * symbol to intercept the g_atexit() calls. Talk about crude hack.
  84  *****************************************************************************/
  85 void g_atexit( GVoidFunc func )
  86 {
  87     intf_thread_t *p_intf = p_main->p_intf;
  88
  89     if( p_intf->p_sys->pf_gdk_callback == NULL )
  90     {
  91         p_intf->p_sys->pf_gdk_callback = func;
  92     }
  93     else if( p_intf->p_sys->pf_gtk_callback == NULL )
  94     {
  95         p_intf->p_sys->pf_gtk_callback = func;
  96     }
  97     /* else nothing, but we could do something here */
  98     return;
  99 }
 100
 101 /*****************************************************************************
 102  * Functions exported as capabilities. They are declared as static so that
 103  * we don't pollute the namespace too much.
 104  *****************************************************************************/
 105 void _M( intf_getfunctions )( function_list_t * p_function_list )
 106 {
 107     p_function_list->pf_probe = intf_Probe;
 108     p_function_list->functions.intf.pf_open  = intf_Open;
 109     p_function_list->functions.intf.pf_close = intf_Close;
 110     p_function_list->functions.intf.pf_run   = intf_Run;
 111 }
 112
 113 /*****************************************************************************
 114  * intf_Probe: probe the interface and return a score
 115  *****************************************************************************
 116  * This function tries to initialize Gnome and returns a score to the
 117  * plugin manager so that it can select the best plugin.
 118  *****************************************************************************/
 119 static int intf_Probe( probedata_t *p_data )
 120 {
 121     if( TestMethod( INTF_METHOD_VAR, "gnome" ) )
 122     {
 123         return( 999 );
 124     }
 125
 126     if( TestProgram( "gnome-vlc" ) )
 127     {
 128         return( 200 );
 129     }
 130
 131     return( 100 );
 132 }
 133
 134 /*****************************************************************************
 135  * intf_Open: initialize and create window
 136  *****************************************************************************/
 137 static int intf_Open( intf_thread_t *p_intf )
 138 {
 139     /* Allocate instance and initialize some members */
 140     p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
 141     if( p_intf->p_sys == NULL )
 142     {
 143         intf_ErrMsg("error: %s", strerror(ENOMEM));
 144         return( 1 );
 145     }
 146
 147     /* Initialize Gnome thread */
 148     p_intf->p_sys->b_popup_changed = 0;
 149     p_intf->p_sys->b_window_changed = 0;
 150     p_intf->p_sys->b_playlist_changed = 0;
 151
 152     p_intf->p_sys->i_playing = -1;
 153     p_intf->p_sys->b_slider_free = 1;
 154
 155     p_intf->p_sys->pf_gtk_callback = NULL;
 156     p_intf->p_sys->pf_gdk_callback = NULL;
 157
 158     return( 0 );
 159 }
 160
 161 /*****************************************************************************
 162  * intf_Close: destroy interface window
 163  *****************************************************************************/
 164 static void intf_Close( intf_thread_t *p_intf )
 165 {
 166     /* Destroy structure */
 167     free( p_intf->p_sys );
 168 }
 169
 170 /*****************************************************************************
 171  * intf_Run: Gnome thread
 172  *****************************************************************************
 173  * this part of the interface is in a separate thread so that we can call
 174  * gtk_main() from within it without annoying the rest of the program.
 175  * XXX: the approach may look kludgy, and probably is, but I could not find
 176  * a better way to dynamically load a Gnome interface at runtime.
 177  *****************************************************************************/
 178 static void intf_Run( intf_thread_t *p_intf )
 179 {
 180     /* gnome_init needs to know the command line. We don't care, so we
 181      * give it an empty one */
 182     char *p_args[] = { "" };
 183     int   i_args   = 1;
 184
 185     /* The data types we are allowed to receive */
 186     static GtkTargetEntry target_table[] =
 187     {
 188         { "text/uri-list", 0, DROP_ACCEPT_TEXT_URI_LIST },
 189         { "text/plain",    0, DROP_ACCEPT_TEXT_PLAIN }
 190     };
 191
 192     /* intf_Manage callback timeout */
 193     int i_timeout;
 194
 195     /* Initialize Gnome */
 196     gnome_init( p_main->psz_arg0, VERSION, i_args, p_args );
 197
 198     /* Create some useful widgets that will certainly be used */
 199     p_intf->p_sys->p_window = create_intf_window( );
 200     p_intf->p_sys->p_popup = create_intf_popup( );
 201     p_intf->p_sys->p_playlist = create_intf_playlist();
 202
 203     /* Set the title of the main window */
 204     gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window),
 205                           VOUT_TITLE " (Gnome interface)");
 206
 207     /* Accept file drops on the main window */
 208     gtk_drag_dest_set( GTK_WIDGET( p_intf->p_sys->p_window ),
 209                        GTK_DEST_DEFAULT_ALL, target_table,
 210                        1, GDK_ACTION_COPY );
 211     /* Accept file drops on the playlist window */
 212     gtk_drag_dest_set( GTK_WIDGET( gtk_object_get_data( GTK_OBJECT(
 213                             p_intf->p_sys->p_playlist ), "playlist_clist") ),
 214                        GTK_DEST_DEFAULT_ALL, target_table,
 215                        1, GDK_ACTION_COPY );
 216
 217     /* Get the interface labels */
 218     p_intf->p_sys->p_slider_frame = gtk_object_get_data(
 219                       GTK_OBJECT( p_intf->p_sys->p_window ), "slider_frame" );
 220     #define P_LABEL( name ) GTK_LABEL( gtk_object_get_data( \
 221                          GTK_OBJECT( p_intf->p_sys->p_window ), name ) )
 222     p_intf->p_sys->p_label_title = P_LABEL( "title_label" );
 223     p_intf->p_sys->p_label_chapter = P_LABEL( "chapter_label" );
 224     #undef P_LABEL
 225
 226     /* Connect the date display to the slider */
 227     #define P_SLIDER GTK_RANGE( gtk_object_get_data( \
 228                          GTK_OBJECT( p_intf->p_sys->p_window ), "slider" ) )
 229     p_intf->p_sys->p_adj = gtk_range_get_adjustment( P_SLIDER );
 230
 231     gtk_signal_connect ( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed",
 232                          GTK_SIGNAL_FUNC( GtkDisplayDate ), NULL );
 233     p_intf->p_sys->f_adj_oldvalue = 0;
 234     #undef P_SLIDER
 235
 236     /* We don't create these ones yet because we perhaps won't need them */
 237     p_intf->p_sys->p_about = NULL;
 238     p_intf->p_sys->p_modules = NULL;
 239     p_intf->p_sys->p_fileopen = NULL;
 240     p_intf->p_sys->p_disc = NULL;
 241     p_intf->p_sys->p_network = NULL;
 242     p_intf->p_sys->p_preferences = NULL;
 243     p_intf->p_sys->p_jump = NULL;
 244
 245     /* Store p_intf to keep an eye on it */
 246     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window),
 247                          "p_intf", p_intf );
 248
 249     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_popup),
 250                          "p_intf", p_intf );
 251
 252     gtk_object_set_data( GTK_OBJECT( p_intf->p_sys->p_playlist ),
 253                          "p_intf", p_intf );
 254
 255     gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_adj),
 256                          "p_intf", p_intf );
 257
 258     /* Show the control window */
 259     gtk_widget_show( p_intf->p_sys->p_window );
 260
 261     /* Sleep to avoid using all CPU - since some interfaces needs to access
 262      * keyboard events, a 100ms delay is a good compromise */
 263     i_timeout = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, GnomeManage, p_intf );
 264
 265     /* Enter gnome mode */
 266     gtk_main();
 267
 268     /* Remove the timeout */
 269     gtk_timeout_remove( i_timeout );
 270
 271     /* Get rid of stored callbacks so we can unload the plugin */
 272     if( p_intf->p_sys->pf_gtk_callback != NULL )
 273     {
 274         p_intf->p_sys->pf_gtk_callback( );
 275         p_intf->p_sys->pf_gtk_callback = NULL;
 276
 277     }
 278
 279     if( p_intf->p_sys->pf_gdk_callback != NULL )
 280     {
 281         p_intf->p_sys->pf_gdk_callback( );
 282         p_intf->p_sys->pf_gdk_callback = NULL;
 283     }
 284 }
 285
 286 /* following functions are local */
 287
 288 /*****************************************************************************
 289  * GnomeManage: manage main thread messages
 290  *****************************************************************************
 291  * In this function, called approx. 10 times a second, we check what the
 292  * main program wanted to tell us.
 293  *****************************************************************************/
 294 static gint GnomeManage( gpointer p_data )
 295 {
 296 #define p_intf ((intf_thread_t *)p_data)
 297
 298     vlc_mutex_lock( &p_intf->change_lock );
 299
 300     /* If the "display popup" flag has changed */
 301     if( p_intf->b_menu_change )
 302     {
 303         if( !GTK_IS_WIDGET( p_intf->p_sys->p_popup ) )
 304         {
 305             p_intf->p_sys->p_popup = create_intf_popup();
 306             gtk_object_set_data( GTK_OBJECT( p_intf->p_sys->p_popup ),
 307                                  "p_popup", p_intf );
 308         }
 309
 310         gnome_popup_menu_do_popup( p_intf->p_sys->p_popup,
 311                                    NULL, NULL, NULL, NULL );
 312         p_intf->b_menu_change = 0;
 313     }
 314
 315     /* update the playlist */
 316     GtkPlayListManage( p_intf );
 317
 318     if( p_intf->p_input != NULL && !p_intf->b_die )
 319     {
 320         vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
 321
 322         /* New input or stream map change */
 323         if( p_intf->p_input->stream.b_changed )
 324         {
 325             GtkModeManage( p_intf );
 326         }
 327
 328         /* Manage the slider */
 329         if( p_intf->p_input->stream.b_seekable )
 330         {
 331             float           newvalue;
 332             newvalue = p_intf->p_sys->p_adj->value;
 333
 334 #define p_area p_intf->p_input->stream.p_selected_area
 335             /* If the user hasn't touched the slider since the last time,
 336              * then the input can safely change it */
 337             if( newvalue == p_intf->p_sys->f_adj_oldvalue )
 338             {
 339                 /* Update the value */
 340                 p_intf->p_sys->p_adj->value = p_intf->p_sys->f_adj_oldvalue =
 341                     ( 100. * p_area->i_tell ) / p_area->i_size;
 342
 343                 gtk_signal_emit_by_name( GTK_OBJECT( p_intf->p_sys->p_adj ),
 344                                          "value_changed" );
 345             }
 346             /* Otherwise, send message to the input if the user has
 347              * finished dragging the slider */
 348             else if( p_intf->p_sys->b_slider_free )
 349             {
 350                 off_t i_seek = ( newvalue * p_area->i_size ) / 100;
 351
 352                 vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
 353                 input_Seek( p_intf->p_input, i_seek );
 354                 vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
 355
 356                 /* Update the old value */
 357                 p_intf->p_sys->f_adj_oldvalue = newvalue;
 358             }
 359 #undef p_area
 360         }
 361         vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
 362
 363         if( p_intf->p_sys->i_part !=
 364             p_intf->p_input->stream.p_selected_area->i_part )
 365         {
 366             p_intf->p_sys->b_chapter_update = 1;
 367             GtkSetupMenus( p_intf );
 368         }
 369
 370     }
 371     else if( !p_intf->b_die )
 372     {
 373         GtkModeManage( p_intf );
 374     }
 375
 376     /* Manage core vlc functions through the callback */
 377     p_intf->pf_manage( p_intf );
 378
 379     if( p_intf->b_die )
 380     {
 381         vlc_mutex_unlock( &p_intf->change_lock );
 382
 383         /* Prepare to die, young Skywalker */
 384         gtk_main_quit();
 385
 386         /* Just in case */
 387         return( FALSE );
 388     }
 389
 390     vlc_mutex_unlock( &p_intf->change_lock );
 391
 392     return( TRUE );
 393
 394 #undef p_intf
 395 }