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.7 2003/11/08 16:04:05 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         /* Add a new row to the playlist treeview model */
 470         gtk_list_store_append (GTK_LIST_STORE(p_play_model), &p_play_iter);
 471         gtk_list_store_set (GTK_LIST_STORE(p_play_model), &p_play_iter,
 472                                 0, filename,   /* Add path to it !!! */
 473                                 1, "no info",
 474                                 -1 );
 475     }
 476     else
 477        g_print("Error obtaining pointer to Play List");
 478 }
 479
 480 void
 481 onFileListRow                          (GtkTreeView     *treeview,
 482                                         GtkTreePath     *path,
 483                                         GtkTreeViewColumn *column,
 484                                         gpointer         user_data)
 485 {
 486     GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
 487
 488     if (gtk_tree_selection_count_selected_rows(selection) == 1)
 489     {
 490         struct stat st;
 491         GtkTreeModel *model;
 492         GtkTreeIter   iter;
 493         gchar        *filename;
 494
 495         /* This might be a directory selection */
 496         model = gtk_tree_view_get_model(treeview);
 497         if (!model)
 498             g_print( "Error: model is a null pointer\n" );
 499         if (!gtk_tree_model_get_iter(model, &iter, path))
 500             g_print( "Error: could not get iter from model\n" );
 501
 502         gtk_tree_model_get(model, &iter, 0, &filename, -1);
 503
 504         if (stat((char*)filename, &st)==0)
 505         {
 506             if (S_ISDIR(st.st_mode))
 507             {
 508                 GtkListStore *p_model = NULL;
 509
 510                 /* Get new directory listing */
 511                 p_model = gtk_list_store_new (5,
 512                                            G_TYPE_STRING,
 513                                            G_TYPE_STRING,
 514                                            G_TYPE_UINT64,
 515                                            G_TYPE_STRING,
 516                                            G_TYPE_STRING);
 517                 if (NULL == p_model)
 518                     g_print( "ERROR: model has a NULL pointer\n" );
 519                 ReadDirectory(p_model, filename);
 520
 521                 /* Update TreeView with new model */
 522                 gtk_tree_view_set_model(treeview, (GtkTreeModel*) p_model);
 523                 g_object_unref(p_model);
 524             }
 525             else
 526             {
 527                 gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) treeview);
 528             }
 529         }
 530     }
 531     else
 532     {
 533         gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) treeview);
 534     }
 535 }
 536
 537
 538 void
 539 onFileListColumns                      (GtkTreeView     *treeview,
 540                                         gpointer         user_data)
 541 {
 542     g_print("onFileListColumn\n");
 543 }
 544
 545
 546 gboolean
 547 onFileListRowSelected                  (GtkTreeView     *treeview,
 548                                         gboolean         start_editing,
 549                                         gpointer         user_data)
 550 {
 551     g_print("onFileListRowSelected\n");
 552     return FALSE;
 553 }
 554
 555
 556 void
 557 onAddFileToPlaylist                    (GtkButton       *button,
 558                                         gpointer         user_data)
 559 {
 560     GtkTreeView       *treeview = NULL;
 561
 562     treeview = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvFileList");
 563     if (treeview)
 564     {
 565         onFileListRow(treeview, NULL, NULL, NULL );
 566     }
 567 }
 568
 569
 570 void
 571 onEntryMRLChanged                      (GtkEditable     *editable,
 572                                         gpointer         user_data)
 573 {
 574 }
 575
 576
 577 void
 578 onEntryMRLEditingDone                  (GtkCellEditable *celleditable,
 579                                         gpointer         user_data)
 580 {
 581     g_print("onMRLEditingDone\n");
 582 }
 583
 584
 585 void
 586 NetworkBuildMRL                        (GtkEditable     *editable,
 587                                         gpointer         user_data)
 588 {
 589     GtkSpinButton *networkPort = NULL;
 590     GtkEntry      *entryMRL = NULL;
 591     GtkEntry      *networkMRLType = NULL;
 592     GtkEntry      *networkAddress = NULL;
 593     GtkEntry      *networkProtocol = NULL;
 594     GtkEntry      *networkType = NULL;
 595     const gchar   *mrlType;
 596     const gchar   *mrlAddress;
 597     gint     mrlPort;
 598     const gchar   *mrlProtocol;
 599     const gchar   *mrlNetworkType;
 600 #define VLC_MAX_MRL     256
 601     char           text[VLC_MAX_MRL];
 602     int            pos = 0;
 603
 604     entryMRL = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryMRL" );
 605
 606     networkMRLType  = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkMRLType" );
 607     networkAddress  = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkAddress" );
 608     networkPort     = (GtkSpinButton*) lookup_widget( GTK_WIDGET(editable), "entryNetworkPort" );
 609     networkProtocol = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkProtocolType" );
 610     networkType     = (GtkEntry*) lookup_widget( GTK_WIDGET(editable), "entryNetworkType" );
 611
 612     mrlType        = gtk_entry_get_text(GTK_ENTRY(networkMRLType));
 613     mrlAddress     = gtk_entry_get_text(GTK_ENTRY(networkAddress));
 614     mrlPort        = gtk_spin_button_get_value_as_int(networkPort);
 615     mrlProtocol    = gtk_entry_get_text(GTK_ENTRY(networkProtocol));
 616     mrlNetworkType = gtk_entry_get_text(GTK_ENTRY(networkType));
 617
 618     /* Build MRL from parts ;-) */
 619     pos = snprintf( &text[0], VLC_MAX_MRL, "%s", (char*)mrlType);
 620     if (strncasecmp( (char*)mrlProtocol, "IPv6",4)==0 )
 621     {
 622         pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "6://" );
 623         if (strncasecmp( (char*)mrlNetworkType, "multicast",9)==0)
 624         {
 625             pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "@" );
 626         }
 627         pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "[%s]:%d", (char*)mrlAddress, (int)mrlPort );
 628     }
 629     else
 630     {
 631         pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "://" );
 632         if (strncasecmp( (char*)mrlNetworkType, "multicast",9)==0)
 633         {
 634             pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "@" );
 635         }
 636         pos += snprintf( &text[pos], VLC_MAX_MRL - pos, "%s:%d", (char*)mrlAddress, (int)mrlPort );
 637     }
 638
 639     if (pos >= VLC_MAX_MRL)
 640         text[VLC_MAX_MRL-1]='\0';
 641
 642     gtk_entry_set_text(entryMRL,text);
 643 #undef VLC_MAX_MRL
 644 }
 645
 646 void
 647 onAddNetworkPlaylist                   (GtkButton       *button,
 648                                         gpointer         user_data)
 649 {
 650     GtkEntry     *p_mrl = NULL;
 651     GtkTreeView  *p_tvplaylist = NULL;
 652     GtkTreeModel *p_play_model;
 653     GtkTreeIter   p_play_iter;
 654     const gchar  *mrl_name;
 655
 656     p_mrl = (GtkEntry*) lookup_widget(GTK_WIDGET(button),"entryMRL" );
 657     if (NULL != p_mrl)
 658     {
 659         mrl_name = gtk_entry_get_text(p_mrl);
 660
 661         p_tvplaylist = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvPlaylist");
 662         if (NULL != p_tvplaylist)
 663         {
 664             p_play_model = gtk_tree_view_get_model(p_tvplaylist);
 665
 666             /* Add a new row to the playlist treeview model */
 667             gtk_list_store_append (GTK_LIST_STORE(p_play_model), &p_play_iter);
 668             gtk_list_store_set (GTK_LIST_STORE(p_play_model), &p_play_iter,
 669                                     0, mrl_name,   /* Add path to it !!! */
 670                                     1, "no info",
 671                                     -1 );
 672         }
 673     }
 674 }
 675
 676
 677 void
 678 onV4LAudioChanged                      (GtkEditable     *editable,
 679                                         gpointer         user_data)
 680 {
 681
 682 }
 683
 684
 685 void
 686 onEntryV4LAudioEditingDone             (GtkCellEditable *celleditable,
 687                                         gpointer         user_data)
 688 {
 689
 690 }
 691
 692
 693 void
 694 onV4LVideoChanged                      (GtkEditable     *editable,
 695                                         gpointer         user_data)
 696 {
 697
 698 }
 699
 700
 701 void
 702 onEntryV4LVideoEditingDone             (GtkCellEditable *celleditable,
 703                                         gpointer         user_data)
 704 {
 705
 706 }
 707
 708
 709 void
 710 onAddCameraToPlaylist                  (GtkButton       *button,
 711                                         gpointer         user_data)
 712 {
 713
 714 }
 715
 716
 717 void
 718 onVideoDeviceChanged                   (GtkEditable     *editable,
 719                                         gpointer         user_data)
 720 {
 721
 722 }
 723
 724
 725 void
 726 onEntryVideoDeviceEditingDone          (GtkCellEditable *celleditable,
 727                                         gpointer         user_data)
 728 {
 729
 730 }
 731
 732
 733 void
 734 onVideoCodecChanged                    (GtkEditable     *editable,
 735                                         gpointer         user_data)
 736 {
 737
 738 }
 739
 740
 741 void
 742 onEntryVideoCodecEditingDone           (GtkCellEditable *celleditable,
 743                                         gpointer         user_data)
 744 {
 745
 746 }
 747
 748
 749 void
 750 onVideoBitrateChanged                  (GtkEditable     *editable,
 751                                         gpointer         user_data)
 752 {
 753
 754 }
 755
 756
 757 void
 758 onVideoBitrateEditingDone              (GtkCellEditable *celleditable,
 759                                         gpointer         user_data)
 760 {
 761
 762 }
 763
 764
 765 void
 766 onAudioDeviceChanged                   (GtkEditable     *editable,
 767                                         gpointer         user_data)
 768 {
 769
 770 }
 771
 772
 773 void
 774 onEntryAudioDeviceEditingDone          (GtkCellEditable *celleditable,
 775                                         gpointer         user_data)
 776 {
 777
 778 }
 779
 780
 781 void
 782 onAudioCodecChanged                    (GtkEditable     *editable,
 783                                         gpointer         user_data)
 784 {
 785
 786 }
 787
 788
 789 void
 790 onEntryAudioCodecEditingDone           (GtkCellEditable *celleditable,
 791                                         gpointer         user_data)
 792 {
 793
 794 }
 795
 796
 797 void
 798 onAudioBitrateChanged                  (GtkEditable     *editable,
 799                                         gpointer         user_data)
 800 {
 801
 802 }
 803
 804
 805 void
 806 onAudioBitrateEditingDone              (GtkCellEditable *celleditable,
 807                                         gpointer         user_data)
 808 {
 809
 810 }
 811
 812
 813 void
 814 onAddServerToPlaylist                  (GtkButton       *button,
 815                                         gpointer         user_data)
 816 {
 817
 818 }
 819
 820
 821 gboolean
 822 PlaylistEvent                          (GtkWidget       *widget,
 823                                         GdkEvent        *event,
 824                                         gpointer         user_data)
 825 {
 826     g_print("onPlaylistEvent\n");
 827     return FALSE;
 828 }
 829
 830
 831 void
 832 onPlaylistColumnsChanged               (GtkTreeView     *treeview,
 833                                         gpointer         user_data)
 834 {
 835     g_print("onPlaylistColumnsChanged\n");
 836 }
 837
 838
 839 gboolean
 840 onPlaylistRowSelected                  (GtkTreeView     *treeview,
 841                                         gboolean         start_editing,
 842                                         gpointer         user_data)
 843 {
 844   g_print("onPlaylistRowSelected\n");
 845   return FALSE;
 846 }
 847
 848
 849 void
 850 onPlaylistRow                          (GtkTreeView     *treeview,
 851                                         GtkTreePath     *path,
 852                                         GtkTreeViewColumn *column,
 853                                         gpointer         user_data)
 854 {
 855     g_print("onPlaylistRow\n");
 856 }
 857
 858
 859 void
 860 onUpdatePlaylist                       (GtkButton       *button,
 861                                         gpointer         user_data)
 862 {
 863
 864 }
 865
 866
 867 void
 868 onDeletePlaylist                       (GtkButton       *button,
 869                                         gpointer         user_data)
 870 {
 871
 872 }
 873
 874
 875 void
 876 onClearPlaylist                        (GtkButton       *button,
 877                                         gpointer         user_data)
 878 {
 879
 880 }
 881
 882
 883 void
 884 onPreferenceSave                       (GtkButton       *button,
 885                                         gpointer         user_data)
 886 {
 887
 888 }
 889
 890
 891 void
 892 onPreferenceApply                      (GtkButton       *button,
 893                                         gpointer         user_data)
 894 {
 895
 896 }
 897
 898
 899 void
 900 onPreferenceCancel                     (GtkButton       *button,
 901                                         gpointer         user_data)
 902 {
 903
 904 }
 905
 906
 907
 908 void
 909 onNetworkMRLAdd                        (GtkContainer    *container,
 910                                         GtkWidget       *widget,
 911                                         gpointer         user_data)
 912 {
 913
 914 }
 915
 916