git.sesse.net Git - vlc/blob - modules/gui/pda/pda_callbacks.c

   1 /*****************************************************************************
   2  * pda_callbacks.c : Callbacks for the pda Linux Gtk+ plugin.
   3  *****************************************************************************
   4  * Copyright (C) 2000, 2001 VideoLAN
   5  * $Id: pda_callbacks.c,v 1.10 2003/11/09 15:55:23 jpsaman Exp $
   6  *
   7  * Authors: Jean-Paul Saman <jpsaman@wxs.nl>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <sys/types.h>                                              /* off_t */
  28 #include <stdlib.h>
  29 #include <vlc/vlc.h>
  30 #include <vlc/intf.h>
  31 #include <vlc/vout.h>
  32
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <dirent.h>
  36 #include <sys/stat.h>
  37 #include <unistd.h>
  38
  39 #ifdef HAVE_CONFIG_H
  40 #  include <config.h>
  41 #endif
  42
  43 #include <gtk/gtk.h>
  44
  45 #include "pda_callbacks.h"
  46 #include "pda_interface.h"
  47 #include "pda_support.h"
  48 #include "pda.h"
  49
  50 static char* get_file_stat(const char *path, uid_t *uid, gid_t *gid, off_t *size);
  51
  52 /*****************************************************************************
  53  * Useful function to retrieve p_intf
  54  ****************************************************************************/
  55 void * E_(__GtkGetIntf)( GtkWidget * widget )
  56 {
  57     void *p_data;
  58
  59     if( GTK_IS_MENU_ITEM( widget ) )
  60     {
  61         /* Look for a GTK_MENU */
  62         while( widget->parent && !GTK_IS_MENU( widget ) )
  63         {
  64             widget = widget->parent;
  65         }
  66
  67         /* Maybe this one has the data */
  68         p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
  69         if( p_data )
  70         {
  71             return p_data;
  72         }
  73
  74         /* Otherwise, the parent widget has it */
  75         widget = gtk_menu_get_attach_widget( GTK_MENU( widget ) );
  76     }
  77
  78     /* We look for the top widget */
  79     widget = gtk_widget_get_toplevel( GTK_WIDGET( widget ) );
  80
  81     p_data = gtk_object_get_data( GTK_OBJECT( widget ), "p_intf" );
  82
  83     return p_data;
  84 }
  85
  86 void PlaylistRebuildListStore( GtkListStore * p_list, playlist_t * p_playlist )
  87 {
  88     GtkTreeIter iter;
  89     int         i_dummy;
  90     gchar *     ppsz_text[2];
  91     GdkColor    red;
  92     red.red     = 65535;
  93     red.blue    = 0;
  94     red.green   = 0;
  95
  96     vlc_mutex_lock( &p_playlist->object_lock );
  97     for( i_dummy = p_playlist->i_size ; i_dummy-- ; )
  98     {
  99         ppsz_text[0] = p_playlist->pp_items[i_dummy]->psz_name;
 100         ppsz_text[1] = "no info";
 101         gtk_list_store_append (p_list, &iter);
 102         gtk_list_store_set (p_list, &iter,
 103                             0, ppsz_text[0],
 104                             1, ppsz_text[1],
 105                             -1);
 106     }
 107     vlc_mutex_unlock( &p_playlist->object_lock );
 108 }
 109
 110
 111 /*****************************************************************************
 112  * Helper functions for URL changes in Media and Preferences notebook pages.
 113  ****************************************************************************/
 114 void MediaURLOpenChanged( GtkWidget *widget, gchar *psz_url )
 115 {
 116     intf_thread_t *p_intf = GtkGetIntf( widget );
 117     playlist_t   *p_playlist;
 118     GtkTreeView  *p_tvplaylist;
 119
 120     p_playlist = (playlist_t *)
 121              vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
 122
 123     if( p_playlist ==  NULL)
 124     {
 125         return;
 126     }
 127
 128     if( p_playlist )
 129     {
 130         if (p_intf->p_sys->b_autoplayfile)
 131         {
 132             playlist_Add( p_playlist, (char*)psz_url, 0, 0,
 133                           PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END);
 134         }
 135         else
 136         {
 137             playlist_Add( p_playlist, (char*)psz_url, 0, 0,
 138                           PLAYLIST_APPEND, PLAYLIST_END );
 139         }
 140         vlc_object_release(  p_playlist );
 141
 142         p_tvplaylist = (GtkTreeView*) lookup_widget( GTK_WIDGET(widget), "tvPlaylist" );
 143         if (p_tvplaylist)
 144         {
 145             GtkListStore *p_liststore;
 146             p_liststore = (GtkListStore *) gtk_tree_view_get_model(p_tvplaylist);
 147             PlaylistRebuildListStore(p_liststore, p_playlist);
 148         }
 149     }
 150 }
 151
 152 /*****************************************************************
 153  * Read directory helper function.
 154  ****************************************************************/
 155 void ReadDirectory(GtkListStore *p_list, char *psz_dir )
 156 {
 157     GtkTreeIter iter;
 158     struct dirent **namelist;
 159     int n=-1, status=-1;
 160
 161     g_print("changing to dir %s\n", psz_dir);
 162     if (psz_dir)
 163     {
 164        status = chdir(psz_dir);
 165        if (status<0)
 166           g_print( "permision denied\n" );
 167     }
 168     n = scandir(".", &namelist, 0, alphasort);
 169
 170     if (n<0)
 171         perror("scandir");
 172     else
 173     {
 174         int i;
 175         uint32_t uid;
 176         uint32_t gid;
 177         off_t  size;
 178         gchar *ppsz_text[5];
 179
 180         /* XXX : kludge temporaire pour yopy */
 181         ppsz_text[0]="..";
 182         ppsz_text[1] = get_file_stat("..", &uid, &gid, &size);
 183         ppsz_text[2] = "";
 184         ppsz_text[3] = "";
 185         ppsz_text[4] = "";
 186
 187         /* Add a new row to the model */
 188         gtk_list_store_append (p_list, &iter);
 189         gtk_list_store_set (p_list, &iter,
 190                             0, ppsz_text[0],
 191                             1, ppsz_text[1],
 192                             2, size,
 193                             3, ppsz_text[3],
 194                             4, ppsz_text[4],
 195                             -1);
 196
 197         if (ppsz_text[1]) free(ppsz_text[1]);
 198
 199         /* kludge */
 200         for (i=0; i<n; i++)
 201         {
 202             if (namelist[i]->d_name[0] != '.')
 203             {
 204                 /* This is a list of strings. */
 205                 ppsz_text[0] = namelist[i]->d_name;
 206                 ppsz_text[1] = get_file_stat(namelist[i]->d_name, &uid, &gid, &size);
 207                 ppsz_text[2] = "";
 208                 ppsz_text[3] = "";
 209                 ppsz_text[4] = "";
 210 #if 0
 211                 g_print( "(%d) file: %s permission: %s user: %ull group: %ull size: %ull\n", i, ppsz_text[0], ppsz_text[1], uid, gid, size );
 212 #endif
 213                 gtk_list_store_append (p_list, &iter);
 214                 gtk_list_store_set (p_list, &iter,
 215                                     0, ppsz_text[0],
 216                                     1, ppsz_text[1],
 217                                     2, size,
 218                                     3, ppsz_text[3],
 219                                     4, ppsz_text[4],
 220                                     -1);
 221
 222                 if (ppsz_text[1]) free(ppsz_text[1]);
 223             }
 224         }
 225         free(namelist);
 226     }
 227 }
 228
 229 static char* get_file_stat(const char *path, uid_t *uid, gid_t *gid, off_t *size)
 230 {
 231     struct stat st;
 232     char *perm;
 233
 234     perm = (char *) malloc(sizeof(char)*10);
 235     strncpy( perm, "----------", sizeof("----------"));
 236     if (lstat(path, &st)==0)
 237     {
 238         /* user, group, filesize */
 239         *uid = st.st_uid;
 240         *gid = st.st_gid;
 241         *size = st.st_size;
 242         /* determine permission modes */
 243         if (S_ISLNK(st.st_mode))
 244             perm[0]= 'l';
 245         else if (S_ISDIR(st.st_mode))
 246             perm[0]= 'd';
 247         else if (S_ISCHR(st.st_mode))
 248             perm[0]= 'c';
 249         else if (S_ISBLK(st.st_mode))
 250             perm[0]= 'b';
 251         else if (S_ISFIFO(st.st_mode))
 252             perm[0]= 'f';
 253         else if (S_ISSOCK(st.st_mode))
 254             perm[0]= 's';
 255         else if (S_ISREG(st.st_mode))
 256             perm[0]= '-';
 257         else /* Unknown type is an error */
 258             perm[0]= '?';
 259         /* Get file permissions */
 260         /* User */
 261         if (st.st_mode & S_IRUSR)
 262             perm[1]= 'r';
 263         if (st.st_mode & S_IWUSR)
 264             perm[2]= 'w';
 265         if (st.st_mode & S_IXUSR)
 266         {
 267             if (st.st_mode & S_ISUID)
 268                 perm[3] = 's';
 269             else
 270                 perm[3]= 'x';
 271         }
 272         else if (st.st_mode & S_ISUID)
 273             perm[3] = 'S';
 274         /* Group */
 275         if (st.st_mode & S_IRGRP)
 276             perm[4]= 'r';
 277         if (st.st_mode & S_IWGRP)
 278             perm[5]= 'w';
 279         if (st.st_mode & S_IXGRP)
 280         {
 281             if (st.st_mode & S_ISGID)
 282                 perm[6] = 's';
 283             else
 284                 perm[6]= 'x';
 285         }
 286         else if (st.st_mode & S_ISGID)
 287             perm[6] = 'S';
 288         /* Other */
 289         if (st.st_mode & S_IROTH)
 290             perm[7]= 'r';
 291         if (st.st_mode & S_IWOTH)
 292             perm[8]= 'w';
 293         if (st.st_mode & S_IXOTH)
 294         {
 295             // 'sticky' bit
 296             if (st.st_mode &S_ISVTX)
 297                 perm[9] = 't';
 298             else
 299                 perm[9]= 'x';
 300         }
 301         else if (st.st_mode &S_ISVTX)
 302             perm[9]= 'T';
 303     }
 304     return perm;
 305 }
 306
 307 /*
 308  * Main interface callbacks
 309  */
 310
 311 gboolean
 312 onPDADeleteEvent                       (GtkWidget       *widget,
 313                                         GdkEvent        *event,
 314                                         gpointer         user_data)
 315 {
 316     intf_thread_t *p_intf = GtkGetIntf( widget );
 317
 318     msg_Dbg( p_intf, "about to exit vlc ... " );
 319     vlc_mutex_lock( &p_intf->change_lock );
 320     p_intf->p_vlc->b_die = VLC_TRUE;
 321     vlc_mutex_unlock( &p_intf->change_lock );
 322     msg_Dbg( p_intf, "about to exit vlc ... signalled" );
 323
 324     return TRUE;
 325 }
 326
 327
 328 void
 329 onRewind                               (GtkButton       *button,
 330                                         gpointer         user_data)
 331 {
 332     intf_thread_t *  p_intf = GtkGetIntf( button );
 333
 334     if( p_intf->p_sys->p_input != NULL )
 335     {
 336         input_SetStatus( p_intf->p_sys->p_input, INPUT_STATUS_SLOWER );
 337     }
 338 }
 339
 340
 341 void
 342 onPause                                (GtkButton       *button,
 343                                         gpointer         user_data)
 344 {
 345     intf_thread_t *  p_intf = GtkGetIntf( button );
 346
 347     if( p_intf->p_sys->p_input != NULL )
 348     {
 349         input_SetStatus( p_intf->p_sys->p_input, INPUT_STATUS_PAUSE );
 350     }
 351 }
 352
 353
 354 void
 355 onPlay                                 (GtkButton       *button,
 356                                         gpointer         user_data)
 357 {
 358     intf_thread_t *  p_intf = GtkGetIntf( GTK_WIDGET( button ) );
 359     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
 360
 361     if( p_playlist  )
 362     {
 363         vlc_mutex_lock( &p_playlist->object_lock );
 364         if( p_playlist->i_size )
 365         {
 366             vlc_mutex_unlock( &p_playlist->object_lock );
 367             playlist_Play( p_playlist );
 368         }
 369         else
 370         {
 371             vlc_mutex_unlock( &p_playlist->object_lock );
 372         }
 373         vlc_object_release( p_playlist );
 374     }
 375 }
 376
 377
 378 void
 379 onStop                                 (GtkButton       *button,
 380                                         gpointer         user_data)
 381 {
 382     intf_thread_t *  p_intf = GtkGetIntf( GTK_WIDGET( button ) );
 383     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 384                                                        FIND_ANYWHERE );
 385     if( p_playlist)
 386     {
 387         playlist_Stop( p_playlist );
 388         vlc_object_release( p_playlist );
 389     }
 390 }
 391
 392
 393 void
 394 onForward                              (GtkButton       *button,
 395                                         gpointer         user_data)
 396 {
 397     intf_thread_t *  p_intf = GtkGetIntf( button );
 398
 399     if( p_intf->p_sys->p_input != NULL )
 400     {
 401         input_SetStatus( p_intf->p_sys->p_input, INPUT_STATUS_FASTER );
 402     }
 403 }
 404
 405
 406 void
 407 onAbout                                (GtkButton       *button,
 408                                         gpointer         user_data)
 409 {
 410     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(button) );
 411
 412     // Toggle notebook
 413     if (p_intf->p_sys->p_notebook)
 414     {
 415         gtk_widget_show( GTK_WIDGET(p_intf->p_sys->p_notebook) );
 416         gtk_notebook_set_page(p_intf->p_sys->p_notebook,6);
 417     }
 418 }
 419
 420
 421 gboolean
 422 SliderRelease                          (GtkWidget       *widget,
 423                                         GdkEventButton  *event,
 424                                         gpointer         user_data)
 425 {
 426     intf_thread_t *p_intf = GtkGetIntf( widget );
 427
 428     vlc_mutex_lock( &p_intf->change_lock );
 429     p_intf->p_sys->b_slider_free = 1;
 430     vlc_mutex_unlock( &p_intf->change_lock );
 431
 432     return TRUE;
 433 }
 434
 435
 436 gboolean
 437 SliderPress                            (GtkWidget       *widget,
 438                                         GdkEventButton  *event,
 439                                         gpointer         user_data)
 440 {
 441     intf_thread_t *p_intf = GtkGetIntf( widget );
 442
 443     vlc_mutex_lock( &p_intf->change_lock );
 444     p_intf->p_sys->b_slider_free = 0;
 445     vlc_mutex_unlock( &p_intf->change_lock );
 446
 447     return TRUE;
 448 }
 449
 450 void addSelectedToPlaylist(GtkTreeModel *model,
 451                                GtkTreePath *path,
 452                                GtkTreeIter *iter,
 453                                gpointer *userdata)
 454 {
 455     GtkTreeView  *p_tvplaylist = NULL;
 456     gchar *filename;
 457
 458     gtk_tree_model_get(model, iter, 0, &filename, -1);
 459
 460     /* Add to playlist object. */
 461     p_tvplaylist = (GtkTreeView *) lookup_widget( GTK_WIDGET(userdata), "tvPlaylist");
 462     if (p_tvplaylist)
 463     {
 464         GtkTreeModel *p_play_model;
 465         GtkTreeIter   p_play_iter;
 466
 467         p_play_model = gtk_tree_view_get_model(p_tvplaylist);
 468
 469         if (p_play_model)
 470         {
 471             /* Add a new row to the playlist treeview model */
 472             gtk_list_store_append (GTK_LIST_STORE(p_play_model), &p_play_iter);
 473             gtk_list_store_set (GTK_LIST_STORE(p_play_model), &p_play_iter,
 474                                     0, filename,   /* Add path to it !!! */
 475                                     1, "no info",
 476                                     -1 );
 477         }
 478     }
 479 }
 480
 481 void
 482 onFileListRow                          (GtkTreeView     *treeview,
 483                                         GtkTreePath     *path,
 484                                         GtkTreeViewColumn *column,
 485                                         gpointer         user_data)
 486 {
 487     GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
 488
 489     if (gtk_tree_selection_count_selected_rows(selection) == 1)
 490     {
 491         struct stat st;
 492         GtkTreeModel *model;
 493         GtkTreeIter   iter;
 494         gchar        *filename;
 495
 496         /* This might be a directory selection */
 497         model = gtk_tree_view_get_model(treeview);
 498         if (!model)
 499             g_print( "Error: model is a null pointer\n" );
 500         if (!gtk_tree_model_get_iter(model, &iter, path))
 501             g_print( "Error: could not get iter from model\n" );
 502
 503         gtk_tree_model_get(model, &iter, 0, &filename, -1);
 504
 505         if (stat((char*)filename, &st)==0)
 506         {
 507             if (S_ISDIR(st.st_mode))
 508             {
 509                 GtkListStore *p_model = NULL;
 510
 511                 /* Get new directory listing */
 512                 p_model = gtk_list_store_new (5,
 513                                            G_TYPE_STRING,
 514                                            G_TYPE_STRING,
 515                                            G_TYPE_UINT64,
 516                                            G_TYPE_STRING,
 517                                            G_TYPE_STRING);
 518                 if (p_model)
 519                 {
 520                     ReadDirectory(p_model, filename);
 521
 522                     /* Update TreeView with new model */
 523                     gtk_tree_view_set_model(treeview, (GtkTreeModel*) p_model);
 524                     g_object_unref(p_model);
 525                 }
 526             }
 527             else
 528             {
 529                 gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) treeview);
 530             }
 531         }
 532     }
 533     else
 534     {
 535         gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) treeview);
 536     }
 537 }
 538
 539
 540 void
 541 onFileListColumns                      (GtkTreeView     *treeview,
 542                                         gpointer         user_data)
 543 {
 544     g_print("onFileListColumn\n");
 545 }
 546
 547
 548 gboolean
 549 onFileListRowSelected                  (GtkTreeView     *treeview,
 550                                         gboolean         start_editing,
 551                                         gpointer         user_data)
 552 {
 553     g_print("onFileListRowSelected\n");
 554     return FALSE;
 555 }
 556
 557
 558 void
 559 onAddFileToPlaylist                    (GtkButton       *button,
 560                                         gpointer         user_data)
 561 {
 562     GtkTreeView       *treeview = NULL;
 563
 564     treeview = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvFileList");
 565     if (treeview)
 566     {
 567         onFileListRow(treeview, NULL, NULL, NULL );
 568     }
 569 }
 570
 571
 572 void
 573 NetworkBuildMRL                        (GtkEditable     *editable,
 574                                         gpointer         user_data)
 575 {
 576     GtkSpinButton *networkPort = NULL;
 577     GtkEntry      *entryMRL = NULL;
 578     GtkEntry      *networkType = NULL;
 579     GtkEntry      *networkAddress = NULL;
 580     GtkEntry      *networkProtocol = NULL;
 581     const gchar   *mrlNetworkType;
 582     const gchar   *mrlAddress;
 583     const gchar   *mrlProtocol;
 584     gint           mrlPort;
 585 #define VLC_MAX_MRL     256
 586     char           text[VLC_MAX_MRL];
 587     int            pos = 0;
 588
 589     entryMRL = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryMRL" );
 590
 591     networkType     = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkType" );
 592     networkAddress  = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkAddress" );
 593     networkPort     = (GtkSpinButton*) lookup_widget( GTK_WIDGET(editable), "entryNetworkPort" );
 594     networkProtocol = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkProtocolType" );
 595
 596     mrlNetworkType  = gtk_entry_get_text(GTK_ENTRY(networkType));
 597     mrlAddress     = gtk_entry_get_text(GTK_ENTRY(networkAddress));
 598     mrlPort        = gtk_spin_button_get_value_as_int(networkPort);
 599     mrlProtocol    = gtk_entry_get_text(GTK_ENTRY(networkProtocol));
 600
 601     /* Build MRL from parts ;-) */
 602     pos = snprintf( &text[0], VLC_MAX_MRL, "%s://", (char*)mrlProtocol);
 603     if (strncasecmp( (char*)mrlNetworkType, "multicast",9)==0)
 604     {
 605         pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "@" );
 606     }
 607     pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "%s:%d", (char*)mrlAddress, (int)mrlPort );
 608
 609     if (pos >= VLC_MAX_MRL)
 610         text[VLC_MAX_MRL-1]='\0';
 611
 612     gtk_entry_set_text(entryMRL,text);
 613 #undef VLC_MAX_MRL
 614 }
 615
 616 void
 617 onAddNetworkPlaylist                   (GtkButton       *button,
 618                                         gpointer         user_data)
 619 {
 620     GtkEntry     *p_mrl = NULL;
 621     GtkTreeView  *p_tvplaylist = NULL;
 622     GtkTreeModel *p_play_model;
 623     GtkTreeIter   p_play_iter;
 624     const gchar  *mrl_name;
 625
 626     p_mrl = (GtkEntry*) lookup_widget(GTK_WIDGET(button),"entryMRL" );
 627     if (p_mrl)
 628     {
 629         mrl_name = gtk_entry_get_text(p_mrl);
 630
 631         p_tvplaylist = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvPlaylist");
 632         if (NULL != p_tvplaylist)
 633         {
 634             p_play_model = gtk_tree_view_get_model(p_tvplaylist);
 635
 636             /* Add a new row to the playlist treeview model */
 637             gtk_list_store_append (GTK_LIST_STORE(p_play_model), &p_play_iter);
 638             gtk_list_store_set (GTK_LIST_STORE(p_play_model), &p_play_iter,
 639                                     0, mrl_name,   /* Add path to it !!! */
 640                                     1, "no info",
 641                                     -1 );
 642         }
 643     }
 644 }
 645
 646
 647 void
 648 onAddCameraToPlaylist                  (GtkButton       *button,
 649                                         gpointer         user_data)
 650 {
 651
 652 }
 653
 654
 655 gboolean
 656 PlaylistEvent                          (GtkWidget       *widget,
 657                                         GdkEvent        *event,
 658                                         gpointer         user_data)
 659 {
 660     g_print("onPlaylistEvent\n");
 661     return FALSE;
 662 }
 663
 664
 665 void
 666 onPlaylistColumnsChanged               (GtkTreeView     *treeview,
 667                                         gpointer         user_data)
 668 {
 669     g_print("onPlaylistColumnsChanged\n");
 670 }
 671
 672
 673 gboolean
 674 onPlaylistRowSelected                  (GtkTreeView     *treeview,
 675                                         gboolean         start_editing,
 676                                         gpointer         user_data)
 677 {
 678   g_print("onPlaylistRowSelected\n");
 679   return FALSE;
 680 }
 681
 682
 683 void
 684 onPlaylistRow                          (GtkTreeView     *treeview,
 685                                         GtkTreePath     *path,
 686                                         GtkTreeViewColumn *column,
 687                                         gpointer         user_data)
 688 {
 689     g_print("onPlaylistRow\n");
 690 }
 691
 692
 693 void
 694 onUpdatePlaylist                       (GtkButton       *button,
 695                                         gpointer         user_data)
 696 {
 697
 698 }
 699
 700
 701 void
 702 onDeletePlaylist                       (GtkButton       *button,
 703                                         gpointer         user_data)
 704 {
 705
 706 }
 707
 708
 709 void
 710 onClearPlaylist                        (GtkButton       *button,
 711                                         gpointer         user_data)
 712 {
 713
 714 }
 715
 716
 717 void
 718 onPreferenceSave                       (GtkButton       *button,
 719                                         gpointer         user_data)
 720 {
 721
 722 }
 723
 724
 725 void
 726 onPreferenceApply                      (GtkButton       *button,
 727                                         gpointer         user_data)
 728 {
 729
 730 }
 731
 732
 733 void
 734 onPreferenceCancel                     (GtkButton       *button,
 735                                         gpointer         user_data)
 736 {
 737
 738 }
 739
 740
 741
 742 void
 743 onNetworkMRLAdd                        (GtkContainer    *container,
 744                                         GtkWidget       *widget,
 745                                         gpointer         user_data)
 746 {
 747
 748 }
 749
 750
 751
 752 void
 753 V4LBuildMRL                            (GtkEditable     *editable,
 754                                         gpointer         user_data)
 755 {
 756 //    GtkSpinButton *networkPort = NULL;
 757 //    GtkEntry      *entryMRL = NULL;
 758
 759 }
 760
 761
 762 void
 763 onAddTranscodeToPlaylist               (GtkButton       *button,
 764                                         gpointer         user_data)
 765 {
 766
 767 }
 768