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.5 2003/11/07 13:01:51 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  * Helper functions for URL changes in Media and Preferences notebook pages.
 112  ****************************************************************************/
 113 void MediaURLOpenChanged( GtkWidget *widget, gchar *psz_url )
 114 {
 115     intf_thread_t *p_intf = GtkGetIntf( widget );
 116     playlist_t   *p_playlist;
 117     GtkTreeView  *p_tvplaylist;
 118
 119     p_playlist = (playlist_t *)
 120              vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
 121
 122     if( p_playlist ==  NULL)
 123     {
 124         return;
 125     }
 126
 127     if( p_playlist )
 128     {
 129         if (p_intf->p_sys->b_autoplayfile)
 130         {
 131             playlist_Add( p_playlist, (char*)psz_url, 0, 0,
 132                           PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END);
 133         }
 134         else
 135         {
 136             playlist_Add( p_playlist, (char*)psz_url, 0, 0,
 137                           PLAYLIST_APPEND, PLAYLIST_END );
 138         }
 139         vlc_object_release(  p_playlist );
 140
 141         p_tvplaylist = (GtkTreeView*) lookup_widget( GTK_WIDGET(widget), "tvPlaylist" );
 142         if (p_tvplaylist)
 143         {
 144             GtkListStore *p_liststore;
 145             p_liststore = (GtkListStore *) gtk_tree_view_get_model(p_tvplaylist);
 146             PlaylistRebuildListStore(p_liststore, p_playlist);
 147         }
 148     }
 149 }
 150
 151 /*****************************************************************
 152  * Read directory helper function.
 153  ****************************************************************/
 154 void ReadDirectory(GtkListStore *p_list, char *psz_dir )
 155 {
 156     GtkTreeIter iter;
 157     struct dirent **namelist;
 158     int n=-1, status=-1;
 159
 160     g_print("changing to dir %s\n", psz_dir);
 161     if (psz_dir)
 162     {
 163        status = chdir(psz_dir);
 164        if (status<0)
 165           g_print( "permision denied\n" );
 166     }
 167     n = scandir(".", &namelist, 0, alphasort);
 168
 169     if (n<0)
 170         perror("scandir");
 171     else
 172     {
 173         int i;
 174         uint32_t uid;
 175         uint32_t gid;
 176         off_t  size;
 177         gchar *ppsz_text[5];
 178
 179         /* XXX : kludge temporaire pour yopy */
 180         ppsz_text[0]="..";
 181         ppsz_text[1] = get_file_stat("..", &uid, &gid, &size);
 182         ppsz_text[2] = "";
 183         ppsz_text[3] = "";
 184         ppsz_text[4] = "";
 185
 186         /* Add a new row to the model */
 187         gtk_list_store_append (p_list, &iter);
 188         gtk_list_store_set (p_list, &iter,
 189                             0, ppsz_text[0],
 190                             1, ppsz_text[1],
 191                             2, size,
 192                             3, ppsz_text[3],
 193                             4, ppsz_text[4],
 194                             -1);
 195
 196         if (ppsz_text[1]) free(ppsz_text[1]);
 197
 198         /* kludge */
 199         for (i=0; i<n; i++)
 200         {
 201             if (namelist[i]->d_name[0] != '.')
 202             {
 203                 /* This is a list of strings. */
 204                 ppsz_text[0] = namelist[i]->d_name;
 205                 ppsz_text[1] = get_file_stat(namelist[i]->d_name, &uid, &gid, &size);
 206                 ppsz_text[2] = "";
 207                 ppsz_text[3] = "";
 208                 ppsz_text[4] = "";
 209 #if 0
 210                 g_print( "(%d) file: %s permission: %s user: %ull group: %ull size: %ull\n", i, ppsz_text[0], ppsz_text[1], uid, gid, size );
 211 #endif
 212                 gtk_list_store_append (p_list, &iter);
 213                 gtk_list_store_set (p_list, &iter,
 214                                     0, ppsz_text[0],
 215                                     1, ppsz_text[1],
 216                                     2, size,
 217                                     3, ppsz_text[3],
 218                                     4, ppsz_text[4],
 219                                     -1);
 220
 221                 if (ppsz_text[1]) free(ppsz_text[1]);
 222             }
 223         }
 224         free(namelist);
 225     }
 226 }
 227
 228 static char* get_file_stat(const char *path, uid_t *uid, gid_t *gid, off_t *size)
 229 {
 230     struct stat st;
 231     char *perm;
 232
 233     perm = (char *) malloc(sizeof(char)*10);
 234     strncpy( perm, "----------", sizeof("----------"));
 235     if (lstat(path, &st)==0)
 236     {
 237         /* user, group, filesize */
 238         *uid = st.st_uid;
 239         *gid = st.st_gid;
 240         *size = st.st_size;
 241         /* determine permission modes */
 242         if (S_ISLNK(st.st_mode))
 243             perm[0]= 'l';
 244         else if (S_ISDIR(st.st_mode))
 245             perm[0]= 'd';
 246         else if (S_ISCHR(st.st_mode))
 247             perm[0]= 'c';
 248         else if (S_ISBLK(st.st_mode))
 249             perm[0]= 'b';
 250         else if (S_ISFIFO(st.st_mode))
 251             perm[0]= 'f';
 252         else if (S_ISSOCK(st.st_mode))
 253             perm[0]= 's';
 254         else if (S_ISREG(st.st_mode))
 255             perm[0]= '-';
 256         else /* Unknown type is an error */
 257             perm[0]= '?';
 258         /* Get file permissions */
 259         /* User */
 260         if (st.st_mode & S_IRUSR)
 261             perm[1]= 'r';
 262         if (st.st_mode & S_IWUSR)
 263             perm[2]= 'w';
 264         if (st.st_mode & S_IXUSR)
 265         {
 266             if (st.st_mode & S_ISUID)
 267                 perm[3] = 's';
 268             else
 269                 perm[3]= 'x';
 270         }
 271         else if (st.st_mode & S_ISUID)
 272             perm[3] = 'S';
 273         /* Group */
 274         if (st.st_mode & S_IRGRP)
 275             perm[4]= 'r';
 276         if (st.st_mode & S_IWGRP)
 277             perm[5]= 'w';
 278         if (st.st_mode & S_IXGRP)
 279         {
 280             if (st.st_mode & S_ISGID)
 281                 perm[6] = 's';
 282             else
 283                 perm[6]= 'x';
 284         }
 285         else if (st.st_mode & S_ISGID)
 286             perm[6] = 'S';
 287         /* Other */
 288         if (st.st_mode & S_IROTH)
 289             perm[7]= 'r';
 290         if (st.st_mode & S_IWOTH)
 291             perm[8]= 'w';
 292         if (st.st_mode & S_IXOTH)
 293         {
 294             // 'sticky' bit
 295             if (st.st_mode &S_ISVTX)
 296                 perm[9] = 't';
 297             else
 298                 perm[9]= 'x';
 299         }
 300         else if (st.st_mode &S_ISVTX)
 301             perm[9]= 'T';
 302     }
 303     return perm;
 304 }
 305
 306 /*
 307  * Main interface callbacks
 308  */
 309
 310 gboolean
 311 onPDADeleteEvent                       (GtkWidget       *widget,
 312                                         GdkEvent        *event,
 313                                         gpointer         user_data)
 314 {
 315     intf_thread_t *p_intf = GtkGetIntf( widget );
 316
 317     msg_Dbg( p_intf, "about to exit vlc ... " );
 318     vlc_mutex_lock( &p_intf->change_lock );
 319     p_intf->p_vlc->b_die = VLC_TRUE;
 320     vlc_mutex_unlock( &p_intf->change_lock );
 321     msg_Dbg( p_intf, "about to exit vlc ... signalled" );
 322
 323     return TRUE;
 324 }
 325
 326
 327 void
 328 onFileOpen                             (GtkButton       *button,
 329                                         gpointer         user_data)
 330 {
 331     intf_thread_t *p_intf = GtkGetIntf( button );
 332     GtkListStore *p_list;
 333
 334     if (p_intf->p_sys->p_notebook)
 335     {
 336        gtk_widget_show( GTK_WIDGET(p_intf->p_sys->p_notebook) );
 337        gtk_notebook_set_page(p_intf->p_sys->p_notebook,0);
 338     }
 339     gdk_window_raise( p_intf->p_sys->p_window->window );
 340     if (p_intf->p_sys->p_tvfile)
 341     {
 342        /* Get new directory listing */
 343        p_list = gtk_list_store_new (5,
 344                                   G_TYPE_STRING,
 345                                   G_TYPE_STRING,
 346                                   G_TYPE_UINT64,
 347                                   G_TYPE_STRING,
 348                                   G_TYPE_STRING);
 349        ReadDirectory(p_list, ".");
 350
 351        /* Update TreeView */
 352        gtk_tree_view_set_model(p_intf->p_sys->p_tvfile, (GtkTreeModel*) p_list);
 353        g_object_unref(p_list);
 354     }
 355 }
 356
 357
 358 void
 359 onPlaylist                             (GtkButton       *button,
 360                                         gpointer         user_data)
 361 {
 362     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(button) );
 363
 364     // Toggle notebook
 365     if (p_intf->p_sys->p_notebook)
 366     {
 367         gtk_widget_show( GTK_WIDGET(p_intf->p_sys->p_notebook) );
 368         gtk_notebook_set_page(p_intf->p_sys->p_notebook,1);
 369     }
 370     gdk_window_raise( p_intf->p_sys->p_window->window );
 371 }
 372
 373
 374 void
 375 onPreferences                          (GtkButton       *button,
 376                                         gpointer         user_data)
 377 {
 378     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET( button ) );
 379
 380     if (p_intf->p_sys->p_notebook)
 381     {
 382        gtk_widget_show( GTK_WIDGET(p_intf->p_sys->p_notebook) );
 383        gtk_notebook_set_page(p_intf->p_sys->p_notebook,2);
 384     }
 385     gdk_window_raise( p_intf->p_sys->p_window->window );
 386 }
 387
 388
 389 void
 390 onRewind                               (GtkButton       *button,
 391                                         gpointer         user_data)
 392 {
 393     intf_thread_t *  p_intf = GtkGetIntf( button );
 394
 395     if( p_intf->p_sys->p_input != NULL )
 396     {
 397         input_SetStatus( p_intf->p_sys->p_input, INPUT_STATUS_SLOWER );
 398     }
 399 }
 400
 401
 402 void
 403 onPause                                (GtkButton       *button,
 404                                         gpointer         user_data)
 405 {
 406     intf_thread_t *  p_intf = GtkGetIntf( button );
 407
 408     if( p_intf->p_sys->p_input != NULL )
 409     {
 410         input_SetStatus( p_intf->p_sys->p_input, INPUT_STATUS_PAUSE );
 411     }
 412 }
 413
 414
 415 void
 416 onPlay                                 (GtkButton       *button,
 417                                         gpointer         user_data)
 418 {
 419      intf_thread_t *  p_intf = GtkGetIntf( GTK_WIDGET( button ) );
 420      playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
 421
 422      if( p_playlist == NULL )
 423      {
 424          /* Display open page */
 425          onFileOpen(button,user_data);
 426      }
 427
 428      /* If the playlist is empty, open a file requester instead */
 429      vlc_mutex_lock( &p_playlist->object_lock );
 430      if( p_playlist->i_size )
 431      {
 432          vlc_mutex_unlock( &p_playlist->object_lock );
 433          playlist_Play( p_playlist );
 434          vlc_object_release( p_playlist );
 435          gdk_window_lower( p_intf->p_sys->p_window->window );
 436      }
 437      else
 438      {
 439          vlc_mutex_unlock( &p_playlist->object_lock );
 440          vlc_object_release( p_playlist );
 441          /* Display open page */
 442          onFileOpen(button,user_data);
 443     }
 444 }
 445
 446
 447 void
 448 onStop                                 (GtkButton       *button,
 449                                         gpointer         user_data)
 450 {
 451     intf_thread_t *  p_intf = GtkGetIntf( GTK_WIDGET( button ) );
 452     playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 453                                                        FIND_ANYWHERE );
 454     if( p_playlist)
 455     {
 456         playlist_Stop( p_playlist );
 457         vlc_object_release( p_playlist );
 458         gdk_window_raise( p_intf->p_sys->p_window->window );
 459     }
 460 }
 461
 462
 463 void
 464 onForward                              (GtkButton       *button,
 465                                         gpointer         user_data)
 466 {
 467     intf_thread_t *  p_intf = GtkGetIntf( button );
 468
 469     if( p_intf->p_sys->p_input != NULL )
 470     {
 471         input_SetStatus( p_intf->p_sys->p_input, INPUT_STATUS_FASTER );
 472     }
 473 }
 474
 475
 476 void
 477 onAbout                                (GtkButton       *button,
 478                                         gpointer         user_data)
 479 {
 480     intf_thread_t *p_intf = GtkGetIntf( GTK_WIDGET(button) );
 481
 482     // Toggle notebook
 483     if (p_intf->p_sys->p_notebook)
 484     {
 485         gtk_widget_show( GTK_WIDGET(p_intf->p_sys->p_notebook) );
 486         gtk_notebook_set_page(p_intf->p_sys->p_notebook,3);
 487     }
 488     gdk_window_raise( p_intf->p_sys->p_window->window );
 489 }
 490
 491
 492 gboolean
 493 SliderRelease                          (GtkWidget       *widget,
 494                                         GdkEventButton  *event,
 495                                         gpointer         user_data)
 496 {
 497     intf_thread_t *p_intf = GtkGetIntf( widget );
 498
 499     vlc_mutex_lock( &p_intf->change_lock );
 500     p_intf->p_sys->b_slider_free = 1;
 501     vlc_mutex_unlock( &p_intf->change_lock );
 502
 503     return TRUE;
 504 }
 505
 506
 507 gboolean
 508 SliderPress                            (GtkWidget       *widget,
 509                                         GdkEventButton  *event,
 510                                         gpointer         user_data)
 511 {
 512     intf_thread_t *p_intf = GtkGetIntf( widget );
 513
 514     vlc_mutex_lock( &p_intf->change_lock );
 515     p_intf->p_sys->b_slider_free = 0;
 516     vlc_mutex_unlock( &p_intf->change_lock );
 517
 518     return TRUE;
 519 }
 520
 521 void addSelectedToPlaylist(GtkTreeModel *model,
 522                                GtkTreePath *path,
 523                                GtkTreeIter *iter,
 524                                gpointer *userdata)
 525 {
 526     GtkTreeView  *p_tvplaylist = NULL;
 527     gchar *filename;
 528
 529     gtk_tree_model_get(model, iter, 0, &filename, -1);
 530
 531     /* Add to playlist object. */
 532     p_tvplaylist = (GtkTreeView *) lookup_widget( GTK_WIDGET(userdata), "tvPlaylist");
 533     if (p_tvplaylist)
 534     {
 535         GtkTreeModel *p_play_model;
 536         GtkTreeIter   p_play_iter;
 537
 538         p_play_model = gtk_tree_view_get_model(p_tvplaylist);
 539         /* Add a new row to the playlist treeview model */
 540         gtk_list_store_append (GTK_LIST_STORE(p_play_model), &p_play_iter);
 541         gtk_list_store_set (GTK_LIST_STORE(p_play_model), &p_play_iter,
 542                                 0, filename,   /* Add path to it !!! */
 543                                 1, "00:00:00",
 544                                 -1 );
 545         /* do we need to unref ?? */
 546     }
 547     else
 548        g_print("Error obtaining pointer to Play List");
 549 }
 550
 551 void
 552 onFileListRow                          (GtkTreeView     *treeview,
 553                                         GtkTreePath     *path,
 554                                         GtkTreeViewColumn *column,
 555                                         gpointer         user_data)
 556 {
 557     GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
 558
 559     if (gtk_tree_selection_count_selected_rows(selection) == 1)
 560     {
 561         struct stat st;
 562         GtkTreeModel *model;
 563         GtkTreeIter   iter;
 564         gchar        *filename;
 565
 566         /* This might be a directory selection */
 567         model = gtk_tree_view_get_model(treeview);
 568         if (!model)
 569             g_print( "Error: model is a null pointer\n" );
 570         if (!gtk_tree_model_get_iter(model, &iter, path))
 571             g_print( "Error: could not get iter from model\n" );
 572
 573         gtk_tree_model_get(model, &iter, 0, &filename, -1);
 574
 575         if (stat((char*)filename, &st)==0)
 576         {
 577             if (S_ISDIR(st.st_mode))
 578             {
 579                 GtkListStore *p_model = NULL;
 580
 581                 /* Get new directory listing */
 582                 p_model = gtk_list_store_new (5,
 583                                            G_TYPE_STRING,
 584                                            G_TYPE_STRING,
 585                                            G_TYPE_UINT64,
 586                                            G_TYPE_STRING,
 587                                            G_TYPE_STRING);
 588                 if (NULL == p_model)
 589                     g_print( "ERROR: model has a NULL pointer\n" );
 590                 ReadDirectory(p_model, filename);
 591
 592                 /* Update TreeView with new model */
 593                 gtk_tree_view_set_model(treeview, (GtkTreeModel*) p_model);
 594                 g_object_unref(p_model);
 595             }
 596             else
 597             {
 598                 gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) treeview);
 599             }
 600         }
 601     }
 602     else
 603     {
 604         gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) &addSelectedToPlaylist, (gpointer) treeview);
 605     }
 606 }
 607
 608
 609 void
 610 onFileListColumns                      (GtkTreeView     *treeview,
 611                                         gpointer         user_data)
 612 {
 613     g_print("onFileListColumn\n");
 614 }
 615
 616
 617 gboolean
 618 onFileListRowSelected                  (GtkTreeView     *treeview,
 619                                         gboolean         start_editing,
 620                                         gpointer         user_data)
 621 {
 622     g_print("onFileListRowSelected\n");
 623     return FALSE;
 624 }
 625
 626
 627 void
 628 onAddFileToPlaylist                    (GtkButton       *button,
 629                                         gpointer         user_data)
 630 {
 631     GtkTreeView       *treeview = NULL;
 632
 633     treeview = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvFileList");
 634     if (treeview)
 635     {
 636         onFileListRow(treeview, NULL, NULL, NULL );
 637     }
 638 }
 639
 640
 641 void
 642 onEntryMRLChanged                      (GtkEditable     *editable,
 643                                         gpointer         user_data)
 644 {
 645     g_print("onMRLChanged\n");
 646 }
 647
 648
 649 void
 650 onEntryMRLEditingDone                  (GtkCellEditable *celleditable,
 651                                         gpointer         user_data)
 652 {
 653     g_print("onMRLEditingDone\n");
 654 }
 655
 656
 657 void
 658 onNetworkPortChanged                   (GtkEditable     *editable,
 659                                         gpointer         user_data)
 660 {
 661
 662 }
 663
 664
 665 void
 666 onEntryNetworkPortEditingDone          (GtkCellEditable *celleditable,
 667                                         gpointer         user_data)
 668 {
 669
 670 }
 671
 672
 673 void
 674 onNetworkAddressChanged                (GtkEditable     *editable,
 675                                         gpointer         user_data)
 676 {
 677
 678 }
 679
 680
 681 void
 682 onEntryNetworkAddressEditingDone       (GtkCellEditable *celleditable,
 683                                         gpointer         user_data)
 684 {
 685
 686 }
 687
 688
 689 void
 690 onNetworkTypeChanged                   (GtkEditable     *editable,
 691                                         gpointer         user_data)
 692 {
 693
 694 }
 695
 696
 697 void
 698 onEntryNetworkTypeEditingDone          (GtkCellEditable *celleditable,
 699                                         gpointer         user_data)
 700 {
 701
 702 }
 703
 704
 705 void
 706 onProtocolTypeChanged                  (GtkEditable     *editable,
 707                                         gpointer         user_data)
 708 {
 709
 710 }
 711
 712
 713 void
 714 onEntryProtocolTypeEditingDone         (GtkCellEditable *celleditable,
 715                                         gpointer         user_data)
 716 {
 717
 718 }
 719
 720
 721 void
 722 onMRLTypeChanged                       (GtkEditable     *editable,
 723                                         gpointer         user_data)
 724 {
 725
 726 }
 727
 728
 729 void
 730 onEntryMRLTypeEditingDone              (GtkCellEditable *celleditable,
 731                                         gpointer         user_data)
 732 {
 733
 734 }
 735
 736
 737 void
 738 onStreamTypeChanged                    (GtkEditable     *editable,
 739                                         gpointer         user_data)
 740 {
 741
 742 }
 743
 744
 745 void
 746 onEntryStreamTypeEditingDone           (GtkCellEditable *celleditable,
 747                                         gpointer         user_data)
 748 {
 749
 750 }
 751
 752
 753 void
 754 onAddNetworkPlaylist                   (GtkButton       *button,
 755                                         gpointer         user_data)
 756 {
 757 #if 0
 758     GtkEntry *p_mrl;
 759
 760     p_mrl = (GtkEntry*) lookup_widget(GTK_WIDGET(button),"" );
 761     if (NULL != p_mrl)
 762     {
 763         GtkTreeView  *p_tvplaylist = NULL;
 764         GtkTreeModel *p_play_model;
 765         GtkTreeIter   p_play_iter;
 766         gchar *name;
 767
 768         p_tvplaylist = (GtkTreeView *) lookup_widget( GTK_WIDGET(button), "tvPlaylist");
 769         if (p_tvplaylist)
 770         {
 771             p_play_model = gtk_tree_view_get_model(p_tvplaylist);
 772             /* Add a new row to the playlist treeview model */
 773             gtk_list_store_append (p_play_model, &p_play_iter);
 774             gtk_list_store_set (p_play_model, &p_play_iter,
 775                                     0, name,   /* Add path to it !!! */
 776                                     1, "00:00:00",
 777                                     -1 );
 778             /* do we need to unref ?? */
 779         }
 780         else
 781     //       msg_Err(p_intf, "Error obtaining pointer to Play List");
 782            g_print("Error obtaining pointer to Play List");
 783     }
 784 #endif
 785 }
 786
 787
 788 void
 789 onV4LAudioChanged                      (GtkEditable     *editable,
 790                                         gpointer         user_data)
 791 {
 792
 793 }
 794
 795
 796 void
 797 onEntryV4LAudioEditingDone             (GtkCellEditable *celleditable,
 798                                         gpointer         user_data)
 799 {
 800
 801 }
 802
 803
 804 void
 805 onV4LVideoChanged                      (GtkEditable     *editable,
 806                                         gpointer         user_data)
 807 {
 808
 809 }
 810
 811
 812 void
 813 onEntryV4LVideoEditingDone             (GtkCellEditable *celleditable,
 814                                         gpointer         user_data)
 815 {
 816
 817 }
 818
 819
 820 void
 821 onAddCameraToPlaylist                  (GtkButton       *button,
 822                                         gpointer         user_data)
 823 {
 824
 825 }
 826
 827
 828 void
 829 onVideoDeviceChanged                   (GtkEditable     *editable,
 830                                         gpointer         user_data)
 831 {
 832
 833 }
 834
 835
 836 void
 837 onEntryVideoDeviceEditingDone          (GtkCellEditable *celleditable,
 838                                         gpointer         user_data)
 839 {
 840
 841 }
 842
 843
 844 void
 845 onVideoCodecChanged                    (GtkEditable     *editable,
 846                                         gpointer         user_data)
 847 {
 848
 849 }
 850
 851
 852 void
 853 onEntryVideoCodecEditingDone           (GtkCellEditable *celleditable,
 854                                         gpointer         user_data)
 855 {
 856
 857 }
 858
 859
 860 void
 861 onVideoBitrateChanged                  (GtkEditable     *editable,
 862                                         gpointer         user_data)
 863 {
 864
 865 }
 866
 867
 868 void
 869 onVideoBitrateEditingDone              (GtkCellEditable *celleditable,
 870                                         gpointer         user_data)
 871 {
 872
 873 }
 874
 875
 876 void
 877 onAudioDeviceChanged                   (GtkEditable     *editable,
 878                                         gpointer         user_data)
 879 {
 880
 881 }
 882
 883
 884 void
 885 onEntryAudioDeviceEditingDone          (GtkCellEditable *celleditable,
 886                                         gpointer         user_data)
 887 {
 888
 889 }
 890
 891
 892 void
 893 onAudioCodecChanged                    (GtkEditable     *editable,
 894                                         gpointer         user_data)
 895 {
 896
 897 }
 898
 899
 900 void
 901 onEntryAudioCodecEditingDone           (GtkCellEditable *celleditable,
 902                                         gpointer         user_data)
 903 {
 904
 905 }
 906
 907
 908 void
 909 onAudioBitrateChanged                  (GtkEditable     *editable,
 910                                         gpointer         user_data)
 911 {
 912
 913 }
 914
 915
 916 void
 917 onAudioBitrateEditingDone              (GtkCellEditable *celleditable,
 918                                         gpointer         user_data)
 919 {
 920
 921 }
 922
 923
 924 void
 925 onAddServerToPlaylist                  (GtkButton       *button,
 926                                         gpointer         user_data)
 927 {
 928
 929 }
 930
 931
 932 gboolean
 933 PlaylistEvent                          (GtkWidget       *widget,
 934                                         GdkEvent        *event,
 935                                         gpointer         user_data)
 936 {
 937     g_print("onPlaylistEvent\n");
 938     return FALSE;
 939 }
 940
 941
 942 void
 943 onPlaylistColumnsChanged               (GtkTreeView     *treeview,
 944                                         gpointer         user_data)
 945 {
 946     g_print("onPlaylistColumnsChanged\n");
 947 }
 948
 949
 950 gboolean
 951 onPlaylistRowSelected                  (GtkTreeView     *treeview,
 952                                         gboolean         start_editing,
 953                                         gpointer         user_data)
 954 {
 955   g_print("onPlaylistRowSelected\n");
 956   return FALSE;
 957 }
 958
 959
 960 void
 961 onPlaylistRow                          (GtkTreeView     *treeview,
 962                                         GtkTreePath     *path,
 963                                         GtkTreeViewColumn *column,
 964                                         gpointer         user_data)
 965 {
 966     g_print("onPlaylistRow\n");
 967 }
 968
 969
 970 void
 971 onUpdatePlaylist                       (GtkButton       *button,
 972                                         gpointer         user_data)
 973 {
 974
 975 }
 976
 977
 978 void
 979 onDeletePlaylist                       (GtkButton       *button,
 980                                         gpointer         user_data)
 981 {
 982
 983 }
 984
 985
 986 void
 987 onClearPlaylist                        (GtkButton       *button,
 988                                         gpointer         user_data)
 989 {
 990
 991 }
 992
 993
 994 void
 995 onPreferenceSave                       (GtkButton       *button,
 996                                         gpointer         user_data)
 997 {
 998
 999 }
1000
1001
1002 void
1003 onPreferenceApply                      (GtkButton       *button,
1004                                         gpointer         user_data)
1005 {
1006
1007 }
1008
1009
1010 void
1011 onPreferenceCancel                     (GtkButton       *button,
1012                                         gpointer         user_data)
1013 {
1014
1015 }
1016
1017