开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
gui_main.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：41k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

gui_main.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  *              Bill May        wmay@cisco.com
  20.  */
  21. /*
  22.  * gui_main.cpp - Contains the gtk based gui for this player.
  23.  */
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26. #include "player_session.h"
  27. #include "player_media.h"
  28. #include <glib.h>
  29. #include <gtk/gtk.h>
  30. #include "gui_utils.h"
  31. #include "media_utils.h"
  32. #include "player_util.h"
  33. #include "gui_xpm.h"
  34. #include <syslog.h>
  35. #include <rtsp/rtsp_client.h>
  36. #include "our_config_file.h"
  37. #include "playlist.h"
  38. #include <libhttp/http.h>
  39. #include <rtp/debug.h>
  40. #include "codec_plugin_private.h"
  41. /* ??? */
  42. #ifndef LOG_PRI
  43. #define LOG_PRI(p) ((p) & LOG_PRIMASK)
  44. #endif
  46. /* Local variables */
  47. static GtkWidget *main_window;
  48. static GtkWidget *main_vbox;
  49. static GtkWidget *close_menuitem;
  50. static GtkAccelGroup *accel_group = NULL;
  51. static GtkTooltips         *tooltips = NULL;
  52. static GList *playlist = NULL;
  53. static GtkWidget *combo;
  55. static volatile enum {
  56.   PLAYING_NONE,
  57.   PLAYING,
  58.   STOPPED,
  59.   PAUSED,
  60. } play_state = PLAYING_NONE;
  61. static CPlaylist *master_playlist;
  62. static CPlayerSession *psptr = NULL;
  63. static CMsgQueue master_queue;
  64. static GtkWidget *play_button;
  65. static GtkWidget *pause_button;
  66. static GtkWidget *stop_button;
  67. //static GtkWidget *rewind_button;
  68. //static GtkWidget *ff_button;
  69. static GtkWidget *speaker_button;
  70. static GtkWidget *volume_slider;
  71. static GtkWidget *time_slider;
  72. static GtkWidget *time_disp;
  73. static GtkWidget *session_desc[5];
  74. static SDL_mutex *command_mutex;
  75. static int master_looped;
  76. static int master_volume;
  77. static int master_muted;
  78. static int master_fullscreen = 0;
  79. static uint64_t master_time;
  80. static int time_slider_pressed = 0;
  81. static int master_screen_size = 100;
  82. static const char *last_entry = NULL;
  83. static const gchar *last_file = NULL;
  84. static GtkTargetEntry drop_types[] = 
  85. {
  86.   { "text/plain", 0, 1 }
  87. };
  89. static void media_list_query (CPlayerSession *psptr,
  90.       int num_video, 
  91.       video_query_t *vq,
  92.       int num_audio,
  93.       audio_query_t *aq)
  94. {
  95.   if (num_video > 0) {
  96.     if (config.get_config_value(CONFIG_PLAY_VIDEO) != 0) {
  97.       vq[0].enabled = 1;
  98.     } 
  99.   }
  100.   if (num_audio > 0) {
  101.     if (config.get_config_value(CONFIG_PLAY_AUDIO) != 0) {
  102.       aq[0].enabled = 1;
  103.     } 
  104.   }
  105. }
  107. static control_callback_vft_t cc_vft = {
  108.   media_list_query,
  109. };
  110. /*
  111.  * toggle_button_adjust - make sure a toggle button reflects the correct
  112.  * state
  113.  */
  114. static void toggle_button_adjust (GtkWidget *button, int state)
  115. {
  116.   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)) == state)
  117.     return;
  118.   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), state);
  119. }
  121. /*
  122.  * close_session - delete the session, and set the various gui pieces
  123.  */
  124. static void close_session (void)
  125. {
  126.   if (psptr != NULL) {
  127.     delete psptr;
  128.     psptr = NULL;
  129.     play_state = PLAYING_NONE;
  130.     gtk_widget_set_sensitive(close_menuitem, 0);
  131.     toggle_button_adjust(play_button, FALSE);
  132.     toggle_button_adjust(pause_button, FALSE);
  133.     toggle_button_adjust(stop_button, FALSE);
  134.     gtk_widget_set_sensitive(stop_button, 0);
  135.     gtk_widget_set_sensitive(play_button, 0);
  136.     gtk_widget_set_sensitive(pause_button, 0);
  137.     gtk_widget_set_sensitive(time_slider, 0);
  138.   }
  139. }
  141. /*
  142.  * When we hit play, adjust the gui
  143.  */
  144. static void adjust_gui_for_play (void)
  145. {
  146.   gtk_widget_set_sensitive(close_menuitem, 1);
  147.   gtk_widget_set_sensitive(play_button, 1);
  148.   gtk_widget_set_sensitive(pause_button, 1);
  149.   gtk_widget_set_sensitive(stop_button, 1);
  150.   if (psptr->session_is_seekable()) {
  151.     gtk_widget_set_sensitive(time_slider, 1);
  152.   }
  153.   play_state = PLAYING;
  154.   toggle_button_adjust(play_button, TRUE);
  155.   toggle_button_adjust(stop_button, FALSE);
  156.   toggle_button_adjust(pause_button, FALSE);
  157.   gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), last_entry);
  158.   gtk_editable_select_region(GTK_EDITABLE(GTK_COMBO(combo)->entry), 0, -1);
  159.   gtk_editable_set_position(GTK_EDITABLE(GTK_COMBO(combo)->entry), -1);
  160.   gtk_widget_grab_focus(combo);
  161. }
  164. static void create_session_from_name (const char *name)
  165. {
  166.   gint x, y, w, h;
  167.   GdkWindow *window;
  168.   window = GTK_WIDGET(main_window)->window;
  169.   gdk_window_get_position(window, &x, &y);
  170.   gdk_window_get_size(window, &w, &h);
  171.   y += h + 40;
  173.   if (config.get_config_value(CONFIG_PLAY_AUDIO) == 0 &&
  174.       config.get_config_value(CONFIG_PLAY_VIDEO) == 0) {
  175.     ShowMessage("Hey Dummy", "You have both audio and video disabled");
  176.     return;
  177.   }
  179.   // If we're already running a session, close it.
  180.   if (psptr != NULL) {
  181.     close_session();
  182.   }
  184.   psptr = new CPlayerSession(&master_queue,
  185.      NULL,
  186.      name);
  187.   if (psptr != NULL) {
  188.     char errmsg[512];
  189.     errmsg[0] = '';
  190.     // See if we can create media for this session
  191.     int ret = parse_name_for_session(psptr, name, errmsg, sizeof(errmsg),
  192.      &cc_vft);
  193.     if (ret >= 0) {
  194.       // Yup - valid session.  Set volume, set up sync thread, and
  195.       // start the session
  196.       if (ret > 0) {
  197. ShowMessage("Warning", errmsg);
  198.       }
  199.       if (master_muted == 0)
  200. psptr->set_audio_volume(master_volume);
  201.       else
  202. psptr->set_audio_volume(0);
  203.       psptr->set_up_sync_thread();
  204.       psptr->set_screen_location(x, y);
  205.       psptr->set_screen_size(master_screen_size / 50, master_fullscreen);
  206.       psptr->play_all_media(TRUE);  // check response here...
  207.     adjust_gui_for_play();
  208.     } else {
  209.       // Nope - display a message
  210.       delete psptr;
  211.       psptr = NULL;
  212.       char buffer[1024];
  213.       snprintf(buffer, sizeof(buffer), "%s cannot be openedn%s", name,
  214.        errmsg);
  215.       ShowMessage("Open error", buffer);
  216.     }
  217.   }
  218. }
  219. /*
  220.  * start a session
  221.  */
  222. static void start_session_from_name (const char *name)
  223. {
  224.   GList *p;
  225.   int in_list = 0;
  227.   // Save the last file, so we can use it next time we do a file open
  228.   if (last_entry != NULL) {
  229.     free((void *)last_entry);
  230.   }
  231.   last_entry = strdup(name);
  232.   if (strncmp("rtsp://", name, strlen("rtsp://")) != 0) {
  233.     if (last_file != NULL) {
  234.       free((void *)last_file);
  235.       last_file = NULL;
  236.     }
  237.     last_file = g_strdup(name);
  238.     config.set_config_string(CONFIG_PREV_DIRECTORY, strdup(last_file));
  239.   }
  241.   // See if entry is already in the list.
  242.   p = g_list_first(playlist);
  243.   while (p != NULL && in_list == 0) {
  244.     if (g_strcasecmp(name, (const gchar *)p->data) == 0) {
  245.       in_list = 1;
  246.     }
  247.     p = g_list_next(p);
  248.   }
  249.   
  250.   SDL_mutexP(command_mutex);
  251.   
  252.   // If we're running a playlist, close it now.
  253.   if (master_playlist != NULL) {
  254.     delete master_playlist;
  255.     master_playlist = NULL;
  256.   }
  258.   // Create a new player session
  259.   const char *suffix = strrchr(name, '.');
  260.   if ((suffix != NULL) && 
  261.       ((strcasecmp(suffix, ".mp4plist") == 0) ||
  262.        (strcasecmp(suffix, ".mxu") == 0) ||
  263.        (strcasecmp(suffix, ".gmp4_playlist") == 0))) {
  264.     const char *errmsg = NULL;
  265.     master_playlist = new CPlaylist(name, &errmsg);
  266.     if (errmsg != NULL) {
  267.       ShowMessage("Playlist error", errmsg);
  268.     } else {
  269.       create_session_from_name(master_playlist->get_first());
  270.     }
  271.   } else {
  272.     create_session_from_name(name);
  273.   }
  275.   // Add this file to the drop down list
  276.   // If we're playing, adjust the gui
  277.   if (psptr != NULL) {
  279.     if (in_list == 0) {
  280.       config.move_config_strings(CONFIG_PREV_FILE_3, CONFIG_PREV_FILE_2);
  281.       config.move_config_strings(CONFIG_PREV_FILE_2, CONFIG_PREV_FILE_1);
  282.       config.move_config_strings(CONFIG_PREV_FILE_1, CONFIG_PREV_FILE_0);
  283.       config.set_config_string(CONFIG_PREV_FILE_0, strdup(name));
  284.     }
  285.   }
  286.   if (in_list == 0) {
  287.     gchar *newone = g_strdup(name);
  288.     playlist = g_list_append(playlist, newone);
  289.     gtk_combo_set_popdown_strings (GTK_COMBO(combo), playlist);
  290.     gtk_widget_show(combo);
  291.   }
  292.   SDL_mutexV(command_mutex);
  293. }
  295. /*
  296.  * delete_event - called when window closed
  297.  */
  298. void delete_event (GtkWidget *widget, gpointer *data)
  299. {
  300.   if (psptr != NULL) {
  301.     delete psptr;
  302.   }
  303.   if (master_playlist != NULL) {
  304.     delete master_playlist;
  305.   }
  306.   close_plugins();
  307.   gtk_main_quit();
  308. }
  310. static void on_main_menu_close (GtkWidget *window, gpointer data)
  311. {
  312.   SDL_mutexP(command_mutex);
  313.   close_session();
  314.   master_fullscreen = 0;
  315.   SDL_mutexV(command_mutex);
  316. }
  318. static void on_main_menu_help (GtkWidget *window, gpointer data)
  319. {
  320. }
  322. static void on_main_menu_about (GtkWidget *window, gpointer data)
  323. {
  324.   char buffer[1024];
  325.   sprintf(buffer,
  326.   "gmp4player Version %s.n"
  327.   "An open source file/streaming MPEG4 playern"
  328.   "Developed by cisco Systems using then"
  329.   "following open source packages:n"
  330.   "n"
  331.   "SDL, SMPEG audio (MP3) from lokigamesn"
  332.   "RTP from UCLn"
  333.   "ISO reference decoder for MPEG4n"
  334.   "FAAC decodern"
  335.   "Xvid decodern"
  336.   "Developed by Bill May, 10/00 to present", VERSION);
  338.   ShowMessage("About gmp4player",buffer);
  339. }
  341. /*
  342.  * on_drag_data_received - copied from gtv, who copied from someone else
  343.  */
  344. static void on_drag_data_received (GtkWidget *widget,
  345.    GdkDragContext *context,
  346.    gint x,
  347.    gint y,
  348.    GtkSelectionData *selection_data,
  349.    guint info,
  350.    guint time)
  351. {
  352.     gchar *temp, *string;
  354.     string = (gchar *)selection_data->data;
  356.     /* remove newline at end of line, and the file:// url header
  357.        at the begining, copied this code from the xmms source */
  358.     temp = strchr(string, 'n');
  359.     if (temp)
  360.     {
  361.         if (*(temp - 1) == 'r')
  362.             *(temp - 1) = '';
  363.         *temp = '';
  364.     }
  365.     if (!strncasecmp(string, "file:", 5))
  366.         string = string + 5;
  367.     start_session_from_name(string);
  368. }
  370. static GtkWidget *filesel;
  372. static void on_filename_selected (GtkFileSelection *selector, 
  373.   gpointer user_data) 
  374. {
  375.   const gchar *name;
  377.   name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel));
  378.   start_session_from_name(name);
  379. }
  381. /*
  382.  * This is right out of the book...
  383.  */
  384. static void on_browse_button_clicked (GtkWidget *window, gpointer data)
  385. {
  386.   filesel = gtk_file_selection_new("Open Media file");
  387.   if (last_file != NULL) {
  388.     gtk_file_selection_set_filename(GTK_FILE_SELECTION(filesel), last_file);
  389.   }
  390.   gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(filesel));
  391.   gtk_signal_connect (GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button),
  392.       "clicked", 
  393.       GTK_SIGNAL_FUNC(on_filename_selected), 
  394.       filesel);
  395.                              
  396.   /* Ensure that the dialog box is destroyed when the user clicks a button. */
  397.      
  398.   gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button),
  399.     "clicked", 
  400.     GTK_SIGNAL_FUNC(gtk_widget_destroy),
  401.     GTK_OBJECT(filesel));
  403.   gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button),
  404.     "clicked", 
  405.     GTK_SIGNAL_FUNC(gtk_widget_destroy),
  406.     GTK_OBJECT(filesel));
  407.   
  408.   /* Display that dialog */
  409.      
  410.   gtk_widget_show (filesel);
  411.   
  412. }
  414. static void on_playlist_child_selected (GtkWidget *window, gpointer data)
  415. {
  416.   gchar *entry = 
  417.     gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry));
  418.   if (strcmp(entry, "") == 0) 
  419.     return;
  420.   if (last_entry && strcmp(entry, last_entry) == 0) 
  421.     return;
  422.   start_session_from_name(entry);
  423. }
  425. static void on_play_list_selected (GtkWidget *window, gpointer data)
  426. {
  427.   gchar *entry = gtk_entry_get_text(GTK_ENTRY(window));
  428.   start_session_from_name(entry);
  429. }
  431. static void on_play_clicked (GtkWidget *window, gpointer data)
  432. {
  433.   int ret;
  434.   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(play_button)) == FALSE) {
  435.     if (play_state == PLAYING) {
  436.       toggle_button_adjust(play_button, TRUE);
  437.     }
  438.     return;
  439.   }
  441.   if (psptr == NULL)
  442.     return;
  443.   ret = 0;
  444.   SDL_mutexP(command_mutex);
  445.   switch (play_state) {
  446.   case PAUSED:
  447.     ret = psptr->play_all_media(FALSE);
  448.     break;
  449.   case STOPPED:
  450.     ret = psptr->play_all_media(TRUE, 0.0);
  451.     break;
  452.   default:
  453.     break;
  454.   }
  455.   if (ret == 0)
  456.     adjust_gui_for_play();
  457.   SDL_mutexV(command_mutex);
  458.   if (ret != 0) {
  459.     close_session();
  460.     ShowMessage("Play error", "Error re-starting session");
  461.   }
  462. }
  464. static void do_pause (void)
  465. {
  466.   SDL_mutexP(command_mutex);
  467.   if (psptr != NULL && play_state == PLAYING) {
  468.     play_state = PAUSED;
  469.     toggle_button_adjust(play_button, FALSE);
  470.     toggle_button_adjust(pause_button, TRUE);
  471.     psptr->pause_all_media();
  472.   } else {
  473.     toggle_button_adjust(pause_button, play_state == PAUSED);
  474.   }
  475.   SDL_mutexV(command_mutex);
  476. }
  477. static void on_pause_clicked (GtkWidget *window, gpointer data)
  478. {
  479.   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pause_button)) == FALSE) {
  480.     if (play_state == PAUSED) {
  481.       toggle_button_adjust(pause_button, TRUE);
  482.     }
  483.     return;
  484.   }
  485.   do_pause();
  486. }
  488. static void on_stop_clicked (GtkWidget *window, gpointer data)
  489. {
  490.   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_button)) == FALSE) {
  491.     if (play_state == STOPPED) {
  492.       toggle_button_adjust(stop_button, TRUE);
  493.     }
  494.     return;
  495.   }
  496.   SDL_mutexP(command_mutex);
  497.   if (psptr != NULL && play_state == PLAYING) {
  498.     play_state = STOPPED;
  499.     toggle_button_adjust(play_button, FALSE);
  500.     toggle_button_adjust(stop_button, TRUE);
  501.     psptr->pause_all_media();
  502.   } else {
  503.     toggle_button_adjust(stop_button, play_state == STOPPED);
  504.   }
  505.   SDL_mutexV(command_mutex);
  506. }
  508. /*
  509.  * Set the speaker button to either mute or playing
  510.  */
  511. static void set_speaker_button (gchar **xpm_data)
  512. {
  513.   GtkWidget *wid;
  514.   wid = CreateWidgetFromXpm(speaker_button, xpm_data);
  515.   FreeChild(speaker_button);
  516.   gtk_container_add(GTK_CONTAINER(speaker_button), wid);
  517. }
  519. static void on_speaker_clicked (GtkWidget *window, gpointer data)
  520. {
  521.   int vol;
  522.   if (master_muted == 0) {
  523.     // mute the puppy
  524.     set_speaker_button(xpm_speaker_muted);
  525.     master_muted = 1;
  526.     vol = 0;
  527.   } else {
  528.     set_speaker_button(xpm_speaker);
  529.     master_muted = 0;
  530.     vol  = master_volume;
  531.   }
  532.   config.set_config_value(CONFIG_MUTED, master_muted);
  533.   if (psptr && psptr->session_has_audio()) {
  534.     psptr->set_audio_volume(vol);
  535.   }
  536. }
  537. static void volume_adjusted (int volume)
  538. {
  539.   GtkAdjustment *val = gtk_range_get_adjustment(GTK_RANGE(volume_slider));
  540.   gtk_adjustment_set_value(val, (gfloat)volume);
  541.   master_volume = volume;
  542.   config.set_config_value(CONFIG_VOLUME, master_volume);
  543.   gtk_range_set_adjustment(GTK_RANGE(volume_slider), val);
  544.   gtk_range_slider_update(GTK_RANGE(volume_slider));
  545.   gtk_range_clear_background(GTK_RANGE(volume_slider));
  546.   //gtk_range_draw_background(GTK_RANGE(volume_slider));
  547.    if (master_muted == 0 && psptr && psptr->session_has_audio()) {
  548.      psptr->set_audio_volume(master_volume);
  549.    }
  550. }
  552. static void on_volume_adjusted (GtkWidget *window, gpointer data)
  553. {
  554.   GtkAdjustment *val = gtk_range_get_adjustment(GTK_RANGE(volume_slider));
  555.   volume_adjusted((int)val->value);
  556. }
  558. static void on_debug_mpeg4isoonly (GtkWidget *window, gpointer data)
  559. {
  560.   GtkCheckMenuItem *checkmenu;
  562.   checkmenu = GTK_CHECK_MENU_ITEM(window);
  564.   config.set_config_value(CONFIG_USE_MPEG4_ISO_ONLY,
  565.   checkmenu->active == FALSE ? 0 : 1);
  566. }
  567. static void on_debug_use_old_mp4_lib (GtkWidget *window, gpointer data)
  568. {
  569.   GtkCheckMenuItem *checkmenu;
  571.   checkmenu = GTK_CHECK_MENU_ITEM(window);
  573.   config.set_config_value(CONFIG_USE_OLD_MP4_LIB,
  574.   checkmenu->active == FALSE ? 0 : 1);
  575. }
  577. static void on_debug_http (GtkWidget *window, gpointer data)
  578. {
  579.   int loglevel = GPOINTER_TO_INT(data);
  581.   http_set_loglevel(LOG_PRI(loglevel));
  582.   config.set_config_value(CONFIG_HTTP_DEBUG, LOG_PRI(loglevel));
  583. }
  585. static void on_debug_rtsp (GtkWidget *window, gpointer data)
  586. {
  587.   int loglevel = GPOINTER_TO_INT(data);
  589.   rtsp_set_loglevel(LOG_PRI(loglevel));
  590.   config.set_config_value(CONFIG_RTSP_DEBUG, LOG_PRI(loglevel));
  591. }
  592.   
  593. static void on_debug_rtp (GtkWidget *window, gpointer data)
  594. {
  595.   int loglevel = GPOINTER_TO_INT(data);
  596.   rtp_set_loglevel(LOG_PRI(loglevel));
  597.   config.set_config_value(CONFIG_RTP_DEBUG, LOG_PRI(loglevel));
  598. }
  600. static void on_debug_sdp (GtkWidget *window, gpointer data)
  601. {
  602.   int loglevel = GPOINTER_TO_INT(data);
  604.   sdp_set_loglevel(LOG_PRI(loglevel));
  605.   config.set_config_value(CONFIG_SDP_DEBUG, LOG_PRI(loglevel));
  606. }
  608. static void on_media_play_audio (GtkWidget *window, gpointer data)
  609. {
  610.   GtkCheckMenuItem *checkmenu;
  611.   checkmenu = GTK_CHECK_MENU_ITEM(window);
  613.   config.set_config_value(CONFIG_PLAY_AUDIO, checkmenu->active);
  614.   if (psptr != NULL) {
  615.     ShowMessage("Warning", "Play audio will not take effect until next session");
  616.   }
  617. }
  619. static void on_media_play_video (GtkWidget *window, gpointer data)
  620. {
  621.   GtkCheckMenuItem *checkmenu;
  622.   checkmenu = GTK_CHECK_MENU_ITEM(window);
  624.   config.set_config_value(CONFIG_PLAY_VIDEO, checkmenu->active);
  625.   if (psptr != NULL) {
  626.     ShowMessage("Warning", "Play video will not take effect until next session");
  627.   }
  628. }
  630. static void on_network_rtp_over_rtsp (GtkWidget *window, gpointer data)
  631. {
  632.   GtkCheckMenuItem *checkmenu;
  634.   checkmenu = GTK_CHECK_MENU_ITEM(window);
  637.   config.set_config_value(CONFIG_USE_RTP_OVER_RTSP,
  638.   checkmenu->active);
  639. }
  640.   
  642. static void on_video_radio (GtkWidget *window, gpointer data)
  643. {
  644.   int newsize = GPOINTER_TO_INT(data);
  645.   if (newsize != master_screen_size) {
  646.     master_screen_size = newsize;
  647.     if (psptr != NULL) {
  648.       psptr->set_screen_size(newsize / 50);
  649.     }
  650.   }
  651. }
  653. static void on_video_fullscreen (GtkWidget *window, gpointer data)
  654. {
  655.   if (psptr != NULL) {
  656.     master_fullscreen = 1;
  657.     psptr->set_screen_size(master_screen_size / 50, 1);
  658.   }
  659. }
  661. static void on_time_slider_pressed (GtkWidget *window, gpointer data)
  662. {
  663.   time_slider_pressed = 1;
  664. }
  666. static void on_time_slider_adjusted (GtkWidget *window, gpointer data)
  667. {
  668.   double maxtime, newtime;
  669.   time_slider_pressed = 0;
  670.   if (psptr == NULL) 
  671.     return;
  672.   maxtime = psptr->get_max_time();
  673.   if (maxtime == 0.0)
  674.     return;
  675.   GtkAdjustment *val = gtk_range_get_adjustment(GTK_RANGE(time_slider));
  676.   newtime = (maxtime * val->value) / 100.0;
  677.   SDL_mutexP(command_mutex);
  678.   if (play_state == PLAYING) {
  679.     psptr->pause_all_media();
  680.   }
  681.   // If we're going all the way back to the beginning, indicate that
  682.   int ret = psptr->play_all_media(newtime == 0.0 ? TRUE : FALSE, newtime);
  683.   if (ret == 0) 
  684.     adjust_gui_for_play();
  685.   SDL_mutexV(command_mutex);
  686.   if (ret == 0) {
  687.     gtk_range_set_adjustment(GTK_RANGE(time_slider), val);
  688.     gtk_range_slider_update(GTK_RANGE(time_slider));
  689.     gtk_range_clear_background(GTK_RANGE(time_slider));
  690.   //gtk_range_draw_background(GTK_RANGE(vol));
  691.   } else {
  692.     close_session();
  693.   }
  694. }
  696. static void on_loop_enabled_button (GtkWidget *widget, gpointer *data)
  697. {
  698.   master_looped = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  699.   config.set_config_value(CONFIG_LOOPED, master_looped);
  700. }
  702. /*
  703.  * Main timer routine - runs ~every 500 msec
  704.  * Might be able to adjust this to handle just when playing.
  705.  */
  706. static gint main_timer (gpointer raw)
  707. {
  708.   uint64_t play_time;
  709.   if (play_state == PLAYING) {
  710.     double max_time = psptr->get_max_time();
  711.     uint64_t pt = psptr->get_playing_time();
  712.     double playtime = ((double)pt) / 1000.0;
  713.     double val;
  715.     val = max_time;
  716.     if (time_slider_pressed == 0 && 
  717. val > 0.0 &&
  718. psptr->get_session_state() == SESSION_PLAYING) {
  719.       if (playtime < 0) {
  720. val = 0.0;
  721.       } else if (playtime > val) {
  722. val = 100.0;
  723.       } else {
  724. val = (playtime * 100.0) / val;
  725.       }
  726.       GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(time_slider));
  727.       adj->value = val;
  728.       gtk_range_set_adjustment(GTK_RANGE(time_slider), adj);
  729.       gtk_range_slider_update(GTK_RANGE(time_slider));
  730.       gtk_range_clear_background(GTK_RANGE(time_slider));
  731.       gtk_range_draw_background(GTK_RANGE(time_slider));
  732.       gtk_widget_show(time_slider);
  733.     }
  734.     int hr, min, tot;
  735.     tot = (int) playtime;
  736.     hr = tot / 3600;
  737.     tot %= 3600;
  738.     min = tot / 60;
  739.     tot %= 60;
  740.     playtime -= (double)((hr * 3600) + (min * 60));
  741.     if (max_time == 0.0) {
  742.       gchar buffer[30];
  743.       g_snprintf(buffer, 30, "%d:%02d:%04.1f", hr, min, playtime);
  744.       gtk_label_set_text(GTK_LABEL(time_disp), buffer);
  745.     } else {
  746.       int mhr, mmin, msec, mtot;
  747.       mtot = (int)max_time;
  748.       mhr = mtot / 3600;
  749.       mtot %= 3600;
  750.       mmin = mtot / 60;
  751.       msec = mtot % 60;
  753.       gchar buffer[60];
  754.       g_snprintf(buffer, 60, "%d:%02d:%04.1f of %d:%02d:%02d", 
  755.  hr, min, playtime, mhr, mmin, msec);
  756.       gtk_label_set_text(GTK_LABEL(time_disp), buffer);
  757.     }
  758.     
  759.     for (int ix = 0; ix < 4; ix++) {
  760.       const char *text;
  761.       text = psptr->get_session_desc(ix);
  762.       if (text != NULL) {
  763. gtk_label_set_text(GTK_LABEL(session_desc[ix]), text);
  764.       } else {
  765. gtk_label_set_text(GTK_LABEL(session_desc[ix]), "");
  766.       }
  767.     }
  768.   }
  769.   CMsg *newmsg;
  770.   while ((newmsg = master_queue.get_message()) != NULL) {
  771.     switch (newmsg->get_value()) {
  772.     case MSG_RECEIVED_QUIT:
  773.       //player_debug_message("received quit");
  774.       on_main_menu_close(NULL, 0);
  775.       break;
  776.     case MSG_SESSION_FINISHED:
  777.       player_debug_message("gui received finished message");
  778.       if (master_playlist != NULL) {
  779. SDL_mutexP(command_mutex);
  780. const char *start;
  781. do {
  782.   start = master_playlist->get_next();
  783.   if (start == NULL) {
  784.     if (master_looped)
  785.       start = master_playlist->get_first();
  786.   }
  787.   if (start != NULL)
  788.     create_session_from_name(start);
  789. } while (start != NULL && psptr == NULL);
  790. SDL_mutexV(command_mutex);
  791.       } else if (master_looped != 0) {
  792. if (play_state == PLAYING) {
  793.   if (psptr == NULL)
  794.     break;
  795.   SDL_mutexP(command_mutex);
  796.   psptr->pause_all_media();
  797.   psptr->play_all_media(TRUE, 0.0);
  798.   adjust_gui_for_play();
  799.   SDL_mutexV(command_mutex);
  800. }
  801.       } else if (psptr != NULL) {
  802. play_state = STOPPED;
  803. toggle_button_adjust(play_button, FALSE);
  804. toggle_button_adjust(stop_button, TRUE);
  805. psptr->pause_all_media();
  806. master_fullscreen = 0;
  807.       }
  809.       break;
  810.     case MSG_SDL_KEY_EVENT:
  811.       sdl_event_msg_t *msg;
  812.       uint32_t len;
  813.       msg = (sdl_event_msg_t *)newmsg->get_message(len);
  814.       if (len != sizeof(*msg)) {
  815. player_error_message("key event message is wrong size %d %d", 
  816.      len, (int) sizeof(*msg));
  817. break;
  818.       }
  819.       switch (msg->sym) {
  820.       case SDLK_ESCAPE:
  821. player_debug_message("Got escape");
  822. master_fullscreen = 0;
  823. break;
  824.       case SDLK_RETURN:
  825. if ((msg->mod & (KMOD_LALT | KMOD_RALT)) != 0) {
  826.   master_fullscreen = 1;
  827. }
  828. break;
  829.       case SDLK_c:
  830. if ((msg->mod & (KMOD_LCTRL | KMOD_RCTRL)) != 0) {
  831.   on_main_menu_close(NULL, 0);
  832. }
  833. break;
  834.       case SDLK_x:
  835. if ((msg->mod & (KMOD_LCTRL | KMOD_RCTRL)) != 0) {
  836.   delete_event(NULL, 0);
  837. }
  838. break;
  839.       case SDLK_UP:
  840. master_volume += 10;
  841. if (master_volume > 100) master_volume = 100;
  842. volume_adjusted(master_volume);
  843. break;
  844.       case SDLK_DOWN:
  845. if (master_volume > 10) {
  846.   master_volume -= 10;
  847. } else {
  848.   master_volume = 0;
  849. }
  850. volume_adjusted(master_volume);
  851. break;
  853.       case SDLK_SPACE:
  854. if (play_state == PLAYING) {
  855.   do_pause();
  856. } else if (play_state == PAUSED && psptr) {
  857.   SDL_mutexP(command_mutex);
  858.   if (psptr->play_all_media(FALSE) == 0) {
  859.     adjust_gui_for_play();
  860.     SDL_mutexV(command_mutex);
  861.   } else {
  862.     SDL_mutexV(command_mutex);
  863.     close_session();
  864.   }
  865. }
  866. break;
  867.       case SDLK_HOME:
  868. if (psptr && play_state == PLAYING) {
  869.   psptr->pause_all_media();
  870.   psptr->play_all_media(TRUE, 0.0);
  871. }
  872. break;
  873.       case SDLK_RIGHT:
  874. if (psptr && psptr->session_is_seekable() && play_state == PLAYING) {
  875.   SDL_mutexP(command_mutex);
  876.   play_time = psptr->get_playing_time();
  877.   double ptime, maxtime;
  878.   play_time += 10 * M_LLU;
  879.   ptime = (double)play_time;
  880.   ptime /= 1000.0;
  881.   maxtime = psptr->get_max_time();
  882.   if (ptime < maxtime) {
  883.     psptr->pause_all_media();
  884.     if (psptr->play_all_media(FALSE, ptime) == 0) {
  885.       adjust_gui_for_play();
  886.     } else {
  887.       SDL_mutexV(command_mutex);
  888.       close_session();
  889.       break;
  890.     }
  891.   }
  892.   SDL_mutexV(command_mutex);
  893. }
  894. break;
  895.       case SDLK_LEFT:
  896. if (psptr && psptr->session_is_seekable() && play_state == PLAYING) {
  897.   SDL_mutexP(command_mutex);
  898.   play_time = psptr->get_playing_time();
  899.   double ptime;
  900.   if (play_time >= 10 * M_LLU) {
  901.     play_time -= 10 * M_LLU;
  902.     ptime = (double)play_time;
  903.     ptime /= 1000.0;
  904.     psptr->pause_all_media();
  905.     if (psptr->play_all_media(FALSE, ptime) == 0) {
  906.       adjust_gui_for_play();
  907.     } else {
  908.       SDL_mutexV(command_mutex);
  909.       close_session();
  910.       break;
  911.     }
  912.   }
  913.   SDL_mutexV(command_mutex);
  914. }
  915. break;
  916.       case SDLK_PAGEUP:
  917. if (master_screen_size < 200) {
  918.   master_screen_size *= 2;
  919.   psptr->set_screen_size(master_screen_size / 50);
  920. }
  921. break;
  922.       case SDLK_PAGEDOWN:
  923. if (master_screen_size > 50) {
  924.   master_screen_size /= 2;
  925.   psptr->set_screen_size(master_screen_size / 50);
  926. }
  927. break;
  928.       default:
  929. break;
  930.       }
  931.       break;
  932.     }
  933.   }
  934.   return (TRUE);  // keep timer going
  935. }
  937. /*
  938.  * Main routine - set up window
  939.  */
  940. int main (int argc, char **argv)
  941. {
  942.   gtk_init(&argc, &argv);
  943. printf("%sn", *argv);
  944.   command_mutex = SDL_CreateMutex();
  945.   
  946.   config.read_config_file();
  947.   initialize_plugins();
  949.   if (config.get_config_value(CONFIG_RTP_BUFFER_TIME) != 2) {
  950.     config.set_config_value(CONFIG_RTP_BUFFER_TIME_MSEC, 
  951.     config.get_config_value(CONFIG_RTP_BUFFER_TIME) * 1000);
  952.     config.set_config_value(CONFIG_RTP_BUFFER_TIME,
  953.     config.get_config_default_value(CONFIG_RTP_BUFFER_TIME));
  954.   }
  955.   const char *read;
  956.   playlist = g_list_append(playlist, (void *)"");
  957.   read = config.get_config_string(CONFIG_PREV_FILE_0);
  958.   if (read != NULL) {
  959.     gchar *newone = g_strdup(read);
  960.     playlist = g_list_append(playlist, newone);
  961.   }
  962.   read = config.get_config_string(CONFIG_PREV_FILE_1);
  963.   if (read != NULL) {
  964.     gchar *newone = g_strdup(read);
  965.     playlist = g_list_append(playlist, newone);
  966.   }
  967.   read = config.get_config_string(CONFIG_PREV_FILE_2);
  968.   if (read != NULL) {
  969.     gchar *newone = g_strdup(read);
  970.     playlist = g_list_append(playlist, newone);
  971.   }
  972.   read = config.get_config_string(CONFIG_PREV_FILE_3);
  973.   if (read != NULL) {
  974.     gchar *newone = g_strdup(read);
  975.     playlist = g_list_append(playlist, newone);
  976.   }
  977.   
  978.   last_file = g_strdup(config.get_config_string(CONFIG_PREV_DIRECTORY));
  979.   master_looped = config.get_config_value(CONFIG_LOOPED);
  980.   master_muted = config.get_config_value(CONFIG_MUTED);
  981.   master_volume = config.get_config_value(CONFIG_VOLUME);
  982.   rtsp_set_error_func(player_library_message);
  983.   rtsp_set_loglevel(config.get_config_value(CONFIG_RTSP_DEBUG));
  984.   rtp_set_error_msg_func(player_library_message);
  985.   rtp_set_loglevel(config.get_config_value(CONFIG_RTP_DEBUG));
  986.   sdp_set_error_func(player_library_message);
  987.   sdp_set_loglevel(config.get_config_value(CONFIG_SDP_DEBUG));
  988.   http_set_error_func(player_library_message);
  989.   http_set_loglevel(config.get_config_value(CONFIG_HTTP_DEBUG));
  990.   /*
  991.    * Set up main window
  992.    */
  993.   main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  994.   gtk_window_set_policy(GTK_WINDOW(main_window), FALSE, TRUE, FALSE);
  995.   gtk_window_set_title(GTK_WINDOW(main_window), 
  996.        "cisco Open Source MPEG4 Player");
  997.   gtk_widget_set_uposition(GTK_WIDGET(main_window), 10, 10);
  998.   gtk_widget_set_usize(main_window, 450, 185);
  999.   gtk_window_set_default_size(GTK_WINDOW(main_window), 450, 185);
  1000.   gtk_signal_connect(GTK_OBJECT(main_window),
  1001.      "delete_event",
  1002.      GTK_SIGNAL_FUNC(delete_event),
  1003.      NULL);
  1004.   main_vbox = gtk_vbox_new(FALSE, 1);
  1005.   gtk_widget_show(main_vbox);
  1006.   // add stuff
  1007.   accel_group = gtk_accel_group_new();
  1008.   gtk_accel_group_attach(accel_group, GTK_OBJECT(main_window));
  1009.   tooltips = gtk_tooltips_new();
  1011.   GtkWidget *menubar, *menu, *menuitem;
  1012.   
  1013.   menubar = gtk_menu_bar_new();
  1014.   gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
  1015.   gtk_widget_show(menubar);
  1017.   menu = CreateBarSubMenu(menubar, "File");
  1018.   menuitem = CreateMenuItem(menu,
  1019.     accel_group,
  1020.     tooltips,
  1021.     "Open",
  1022.     "^O",
  1023.     "Open local media file",
  1024.     GTK_SIGNAL_FUNC(on_browse_button_clicked),
  1025.     NULL);
  1027.   close_menuitem = CreateMenuItem(menu,
  1028.     accel_group,
  1029.     tooltips,
  1030.     "Close",
  1031.     "^C",
  1032.     "Close file/stream being viewed",
  1033.     GTK_SIGNAL_FUNC(on_main_menu_close),
  1034.     NULL);
  1036.   // NULL entry is a seperator
  1037.   menuitem = CreateMenuItem(menu, 
  1038.     accel_group, 
  1039.     tooltips, 
  1040.     NULL, NULL, NULL, 
  1041.     NULL, NULL);
  1043.   menuitem = CreateMenuItem(menu,
  1044.     accel_group,
  1045.     tooltips,
  1046.     "Exit",
  1047.     "^X",
  1048.     "Exit program",
  1049.     GTK_SIGNAL_FUNC(delete_event),
  1050.     NULL);
  1052.   menu = CreateBarSubMenu(menubar, "Media");
  1054.   GtkWidget *videosub;
  1055.   videosub = CreateSubMenu(menu, "Video");
  1056.   GSList *videosizelist = NULL;
  1057.   GtkWidget *videoradio;
  1058.   videoradio = CreateMenuRadio(videosub,
  1059.        "50 %",
  1060.        &videosizelist,
  1061.        GTK_SIGNAL_FUNC(on_video_radio),
  1062.        GINT_TO_POINTER(50));
  1063.   videoradio = CreateMenuRadio(videosub,
  1064.        "100 %",
  1065.        &videosizelist,
  1066.        GTK_SIGNAL_FUNC(on_video_radio),
  1067.        GINT_TO_POINTER(100));
  1068.   gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(videoradio), TRUE);
  1069.   videoradio = CreateMenuRadio(videosub,
  1070.        "200 %",
  1071.        &videosizelist,
  1072.        GTK_SIGNAL_FUNC(on_video_radio),
  1073.        GINT_TO_POINTER(200));
  1075.   menuitem = CreateMenuItem(videosub, 
  1076.     accel_group, 
  1077.     tooltips, 
  1078.     NULL, NULL, NULL, 
  1079.     NULL, NULL);
  1081.   menuitem = CreateMenuItem(videosub,
  1082.     accel_group,
  1083.     tooltips,
  1084.     "Full Screen",
  1085.     "M-<enter>",
  1086.     "Full Screen",
  1087.     GTK_SIGNAL_FUNC(on_video_fullscreen),
  1088.     NULL);
  1090.   menuitem = CreateMenuCheck(menu, 
  1091.      "Play Audio", 
  1092.      GTK_SIGNAL_FUNC(on_media_play_audio),
  1093.      NULL,
  1094.      config.get_config_value(CONFIG_PLAY_AUDIO));
  1096.   menuitem = CreateMenuCheck(menu, 
  1097.      "Play Video", 
  1098.      GTK_SIGNAL_FUNC(on_media_play_video),
  1099.      NULL,
  1100.      config.get_config_value(CONFIG_PLAY_VIDEO));
  1102.   menu = CreateBarSubMenu(menubar, "Network");
  1103.   menuitem = CreateMenuCheck(menu,
  1104.      "Use RTP over RTSP(TCP)",
  1105.      GTK_SIGNAL_FUNC(on_network_rtp_over_rtsp),
  1106.      NULL,
  1107.      config.get_config_value(CONFIG_USE_RTP_OVER_RTSP));
  1109.   menu = CreateBarSubMenu(menubar, "Help");
  1110.   menuitem = CreateMenuItem(menu,
  1111.     accel_group,
  1112.     tooltips,
  1113.     "Help",
  1114.     NULL,
  1115.     NULL,
  1116.     GTK_SIGNAL_FUNC(on_main_menu_help),
  1117.     NULL);
  1118.   CreateMenuItemSeperator(menu);
  1119.   GtkWidget *debugsub;
  1120.   debugsub = CreateSubMenu(menu, "Debug");
  1121.   menuitem = CreateMenuCheck(debugsub, 
  1122.      "Mpeg4ISOOnly",
  1123.      GTK_SIGNAL_FUNC(on_debug_mpeg4isoonly),
  1124.      NULL,
  1125.      config.get_config_value(CONFIG_USE_MPEG4_ISO_ONLY) == 0 ? FALSE : TRUE);
  1127.   menuitem = CreateMenuCheck(debugsub, 
  1128.      "Use Old mp4 library",
  1129.      GTK_SIGNAL_FUNC(on_debug_use_old_mp4_lib),
  1130.      NULL,
  1131.      config.get_config_value(CONFIG_USE_OLD_MP4_LIB) == 0 ? FALSE : TRUE);
  1133.   CreateLogLevelSubmenu(debugsub, 
  1134. "HTTP library", 
  1135. config.get_config_value(CONFIG_HTTP_DEBUG),
  1136. GTK_SIGNAL_FUNC(on_debug_http));
  1137.   CreateLogLevelSubmenu(debugsub, 
  1138. "RTSP library", 
  1139. config.get_config_value(CONFIG_RTSP_DEBUG),
  1140. GTK_SIGNAL_FUNC(on_debug_rtsp));
  1141.   CreateLogLevelSubmenu(debugsub, 
  1142. "RTP library", 
  1143. config.get_config_value(CONFIG_RTP_DEBUG),
  1144. GTK_SIGNAL_FUNC(on_debug_rtp));
  1145.   CreateLogLevelSubmenu(debugsub, 
  1146. "SDP library", 
  1147. config.get_config_value(CONFIG_SDP_DEBUG),
  1148. GTK_SIGNAL_FUNC(on_debug_sdp));
  1150.   CreateMenuItemSeperator(menu);
  1151.   menuitem = CreateMenuItem(menu,
  1152.     accel_group,
  1153.     tooltips, 
  1154.     "About",
  1155.     NULL,
  1156.     NULL,
  1157.     GTK_SIGNAL_FUNC(on_main_menu_about),
  1158.     NULL);
  1160.   // this is how you turn off the widget
  1161.   gtk_widget_set_sensitive(close_menuitem, 0);
  1162.   GtkWidget *hbox;
  1164.   /*
  1165.    * first line - Play: combo box browse button 
  1166.    */
  1167.   hbox = gtk_hbox_new(FALSE, 1);
  1168.   gtk_widget_show(hbox);
  1170.   gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 5);
  1171.   
  1172.   GtkWidget *label;
  1173.   label = gtk_label_new("Play: ");
  1174.   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 10);
  1175.   gtk_widget_show(label);
  1177.   // combo box uses list playlist.
  1178.   combo = gtk_combo_new();
  1179.   gtk_signal_connect(GTK_OBJECT(GTK_COMBO(combo)->entry),
  1180.      "activate",
  1181.      GTK_SIGNAL_FUNC(on_play_list_selected), 
  1182.      NULL);
  1183.   gtk_signal_connect(GTK_OBJECT(GTK_COMBO(combo)->list),
  1184.      "select_child",
  1185.      GTK_SIGNAL_FUNC(on_playlist_child_selected),
  1186.      combo);
  1187.   gtk_combo_set_popdown_strings (GTK_COMBO(combo), playlist);
  1189.   gtk_combo_set_value_in_list(GTK_COMBO(combo), FALSE, FALSE);
  1190.   gtk_combo_disable_activate(GTK_COMBO(combo));
  1191.   gtk_combo_set_use_arrows_always(GTK_COMBO(combo), 1);
  1192.   gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
  1193.   gtk_widget_show(combo);
  1195.   /* button for browse */
  1196.   GtkWidget *button;
  1197.   button = gtk_button_new_with_label("Browse");
  1198.   gtk_signal_connect(GTK_OBJECT(button),
  1199.      "clicked",
  1200.      GTK_SIGNAL_FUNC(on_browse_button_clicked),
  1201.      NULL);
  1202.   gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 10);
  1203.   gtk_widget_show(button);
  1205.   /*************************************************************************
  1206.    * 2nd line  play pause stop speaker volume
  1207.    *************************************************************************/
  1208.   hbox = gtk_hbox_new(FALSE, 1);
  1209.   gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 5);
  1210.   gtk_widget_show(hbox);
  1212.   GtkWidget *vbox, *hbox2;
  1213.   vbox = gtk_vbox_new(TRUE, 1);
  1214.   gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 5);
  1215.   gtk_widget_show(vbox);
  1217.   hbox2 = gtk_hbox_new(TRUE, 1);
  1218.   gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
  1219.   gtk_widget_show(hbox2);
  1221.   GtkWidget *image;
  1222.   
  1223.   play_button = gtk_toggle_button_new();
  1224.   image = CreateWidgetFromXpm(main_window,xpm_play);
  1225.   gtk_container_add(GTK_CONTAINER(play_button), image);
  1226.   gdk_pixmap_unref((GdkPixmap *)image);
  1227.   gtk_widget_show(play_button);
  1228.   gtk_signal_connect(GTK_OBJECT(play_button),
  1229.      "clicked",
  1230.      GTK_SIGNAL_FUNC(on_play_clicked),
  1231.      NULL);
  1232.   gtk_box_pack_start(GTK_BOX(hbox2), play_button, FALSE, FALSE, 2);
  1234.   pause_button = gtk_toggle_button_new();
  1235.   image = CreateWidgetFromXpm(main_window,xpm_pause);
  1236.   gtk_container_add(GTK_CONTAINER(pause_button), image);
  1237.   gdk_pixmap_unref((GdkPixmap *)image);
  1238.   gtk_widget_show(pause_button);
  1239.   gtk_signal_connect(GTK_OBJECT(pause_button),
  1240.      "clicked",
  1241.      GTK_SIGNAL_FUNC(on_pause_clicked),
  1242.      NULL);
  1243.   gtk_box_pack_start(GTK_BOX(hbox2), pause_button, FALSE, FALSE, 2);
  1245.   stop_button = gtk_toggle_button_new();
  1246.   image = CreateWidgetFromXpm(main_window,xpm_stop);
  1247.   gtk_container_add(GTK_CONTAINER(stop_button), image);
  1248.   gdk_pixmap_unref((GdkPixmap *)image);
  1249.   gtk_widget_show(stop_button);
  1250.   gtk_signal_connect(GTK_OBJECT(stop_button),
  1251.      "clicked",
  1252.      GTK_SIGNAL_FUNC(on_stop_clicked),
  1253.      NULL);
  1254.   gtk_box_pack_start(GTK_BOX(hbox2), stop_button, FALSE, FALSE, 2);
  1257.   gtk_widget_set_sensitive(play_button, 0);
  1258.   gtk_widget_set_sensitive(pause_button, 0);
  1259.   gtk_widget_set_sensitive(stop_button, 0);
  1261.   GtkWidget *sep = gtk_vseparator_new();
  1262.   gtk_widget_show(sep);
  1263.   gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 5);
  1265.   vbox = gtk_vbox_new(FALSE, 1);
  1266.   gtk_widget_show(vbox);
  1267.   gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 5);
  1269.   hbox2 = gtk_hbox_new(FALSE, 1);
  1270.   gtk_widget_show(hbox2);
  1271.   gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
  1273.   speaker_button = gtk_button_new();
  1274.   image = CreateWidgetFromXpm(speaker_button,
  1275.       master_muted == 0 ?
  1276.       xpm_speaker : xpm_speaker_muted);
  1277.   gtk_container_add(GTK_CONTAINER(speaker_button), image);
  1278.   gdk_pixmap_unref((GdkPixmap *)image);
  1279.   gtk_widget_show(speaker_button);
  1280.   gtk_signal_connect(GTK_OBJECT(speaker_button),
  1281.      "clicked",
  1282.      GTK_SIGNAL_FUNC(on_speaker_clicked),
  1283.      NULL);
  1284.   gtk_box_pack_start(GTK_BOX(hbox2), speaker_button, FALSE, FALSE, 5);
  1286.   GtkObject *vol_adj;
  1287.   vol_adj = gtk_adjustment_new(master_volume,
  1288.        0.0,
  1289.        100.0,
  1290.        5.0,
  1291.        25.0,
  1292.        0.0);
  1293.   
  1294.   GtkWidget *vol;
  1295.   vol = gtk_hscale_new(GTK_ADJUSTMENT(vol_adj));
  1296.   gtk_scale_set_digits(GTK_SCALE(vol),0);
  1297.   gtk_scale_set_draw_value(GTK_SCALE(vol), 0);
  1298.   gtk_range_set_adjustment ( GTK_RANGE( vol ), GTK_ADJUSTMENT(vol_adj));
  1299.   gtk_range_slider_update ( GTK_RANGE( vol ) );
  1300.   gtk_range_clear_background ( GTK_RANGE( vol ) );
  1301.   //gtk_range_draw_background ( GTK_RANGE( vol ) );
  1303. #if 0
  1304.   // We don't need this - I'm not 100% sure why, but we don't...
  1305.   gtk_signal_connect(vol_adj,
  1306.      "value_changed",
  1307.      GTK_SIGNAL_FUNC(on_volume_adjusted),
  1308.      vol);
  1309. #endif
  1310.   gtk_signal_connect(GTK_OBJECT(vol), 
  1311.      "button_release_event",
  1312.      GTK_SIGNAL_FUNC(on_volume_adjusted),
  1313.      vol);
  1314.   gtk_widget_show(vol);
  1315.   volume_slider = vol;
  1316.   gtk_box_pack_start(GTK_BOX(hbox2), vol, TRUE, TRUE, 0);
  1317.   
  1318.   // boxes for Looped label 
  1319.   sep = gtk_vseparator_new();
  1320.   gtk_widget_show(sep);
  1321.   gtk_box_pack_start(GTK_BOX(hbox), sep, FALSE, FALSE, 5);
  1323.   vbox = gtk_vbox_new(TRUE, 1);
  1324.   gtk_widget_show(vbox);
  1325.   gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 5);
  1327.   hbox2 = gtk_hbox_new(TRUE, 1);
  1328.   gtk_widget_show(hbox2);
  1329.   gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
  1331.   GtkWidget *loop_enabled_button;
  1332.   loop_enabled_button = gtk_check_button_new_with_label("Looped");
  1333.   gtk_box_pack_start(GTK_BOX(hbox2), loop_enabled_button, FALSE, FALSE, 0);
  1334.   gtk_signal_connect(GTK_OBJECT(loop_enabled_button),
  1335.      "toggled",
  1336.      GTK_SIGNAL_FUNC(on_loop_enabled_button),
  1337.      loop_enabled_button);
  1338.   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(loop_enabled_button),
  1339.        master_looped);
  1340.   gtk_widget_show(loop_enabled_button);
  1341.   
  1342.   /* 
  1343.    * 3rd line - where we are meter...
  1344.    */
  1345.   hbox = gtk_hbox_new(FALSE, 5);
  1346.   gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
  1347.   gtk_widget_show(hbox);
  1349.   GtkObject *time_slider_adj;
  1350.   master_time = 0;
  1351.   time_slider_adj = gtk_adjustment_new(0.0,
  1352.   0.0,
  1353.   100.0,
  1354.   0.5,
  1355.   0.5,
  1356.   0.5);
  1357.   
  1358.   time_slider = gtk_hscale_new(GTK_ADJUSTMENT(time_slider_adj));
  1359.   gtk_widget_ref(time_slider);
  1360.   gtk_range_set_update_policy(GTK_RANGE(time_slider), GTK_UPDATE_DELAYED);
  1361.   gtk_scale_set_digits(GTK_SCALE(time_slider),0);
  1362.   gtk_scale_set_draw_value(GTK_SCALE(time_slider), 0);
  1363.   gtk_range_set_adjustment(GTK_RANGE(time_slider), 
  1364.    GTK_ADJUSTMENT(time_slider_adj));
  1365.   gtk_range_slider_update(GTK_RANGE(time_slider));
  1366.   gtk_range_clear_background(GTK_RANGE( time_slider));
  1367.   //gtk_range_draw_background(GTK_RANGE(time_slider));
  1368.   gtk_signal_connect(GTK_OBJECT(time_slider), 
  1369.      "button_release_event",
  1370.      GTK_SIGNAL_FUNC(on_time_slider_adjusted),
  1371.      time_slider);
  1372.   gtk_signal_connect(GTK_OBJECT(time_slider),
  1373.      "button_press_event",
  1374.      GTK_SIGNAL_FUNC(on_time_slider_pressed),
  1375.      NULL);
  1376.   gtk_widget_set_sensitive(time_slider, 0);
  1377.   gtk_widget_show(time_slider);
  1378.   gtk_box_pack_start(GTK_BOX(hbox), time_slider, TRUE, TRUE, 0);
  1379.   /* 
  1380.    * 4th line - time display...
  1381.    */
  1382.   hbox = gtk_hbox_new(FALSE, 1);
  1383.   gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
  1384.   gtk_widget_show(hbox);
  1385.   
  1386.   time_disp = gtk_label_new("0:00:00");
  1387.   gtk_widget_ref(time_disp);
  1388.   gtk_widget_show(time_disp);
  1389.   gtk_box_pack_start(GTK_BOX(hbox), time_disp, TRUE, TRUE,0);
  1391.   // session information
  1392.   for (int ix = 0; ix < 4; ix++) {
  1393.     hbox = gtk_hbox_new(FALSE, 1);
  1394.     gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
  1395.     gtk_widget_show(hbox);
  1396.   
  1397.     session_desc[ix] = gtk_label_new("");
  1398.     gtk_widget_ref(session_desc[ix]);
  1399.     gtk_widget_show(session_desc[ix]);
  1400.     gtk_box_pack_start(GTK_BOX(hbox), session_desc[ix], TRUE, TRUE,0);
  1401.   }
  1404.   gtk_timeout_add(500, main_timer, main_window);
  1405.   gtk_container_add(GTK_CONTAINER(main_window), main_vbox);
  1406.   gtk_widget_show(main_window);
  1408.   /*
  1409.    * set up drag and drop
  1410.    */
  1411.   gtk_drag_dest_set(main_window, 
  1412.     GTK_DEST_DEFAULT_ALL, 
  1413.     drop_types,
  1414.     1, 
  1415.     GDK_ACTION_COPY);
  1416.   gtk_signal_connect(GTK_OBJECT(main_window), 
  1417.      "drag_data_received",
  1418.      GTK_SIGNAL_FUNC(on_drag_data_received),
  1419.      main_window);
  1420.   /*
  1421.    * any args passed ?
  1422.    */
  1423.   argc--;
  1424.   argv++;
  1425.   if (argc > 0) {
  1426.     start_session_from_name(*argv);
  1427.   }
  1428.   gtk_main();
  1429.   exit(0);
  1430. }
  1432. /* end gui_main.cpp */