=== modified file '.pc/gnomeradio-alsamixer.patch/src/gui.c' --- .pc/gnomeradio-alsamixer.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-alsamixer.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1245,7 +1245,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === modified file '.pc/gnomeradio-auto_device.patch/src/gui.c' --- .pc/gnomeradio-auto_device.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-auto_device.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1264,7 +1264,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === modified file '.pc/gnomeradio-documentation.patch/src/gui.c' --- .pc/gnomeradio-documentation.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-documentation.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1260,7 +1260,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === modified file '.pc/gnomeradio-g_list.patch/src/gui.c' --- .pc/gnomeradio-g_list.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-g_list.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1263,7 +1263,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === modified file '.pc/gnomeradio-gtk_stock.patch/src/gui.c' --- .pc/gnomeradio-gtk_stock.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-gtk_stock.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1274,7 +1274,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === modified file '.pc/gnomeradio-media_types.patch/src/gui.c' --- .pc/gnomeradio-media_types.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-media_types.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1215,7 +1215,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === modified file '.pc/gnomeradio-preferences.patch/src/gui.c' --- .pc/gnomeradio-preferences.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-preferences.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1282,7 +1282,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === added file '.pc/gnomeradio-preferences.patch/src/prefs.h' --- .pc/gnomeradio-preferences.patch/src/prefs.h 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-preferences.patch/src/prefs.h 2013-10-03 19:38:23 +0000 @@ -0,0 +1,36 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef _PREFS_H +#define _PREFS_H + +#include + +gboolean save_settings(void); +gboolean load_settings(void); + +enum +{ + RADIO_DEVICE, + MIXER_DEVICE, + PRESETS +}; + +gboolean action_mode (gint mode); + +GtkWidget* prefs_window(GtkWidget *app); + +#endif === added file '.pc/gnomeradio-preferences.patch/src/radio.c' --- .pc/gnomeradio-preferences.patch/src/radio.c 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-preferences.patch/src/radio.c 2013-10-03 19:38:23 +0000 @@ -0,0 +1,218 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "radio.h" +#include "v4l1.h" +#include "v4l2.h" +#include "alsa_stream.h" +#include "get_media_devices.h" + +extern int autodetect; + +extern int alsa_loopback; +extern char *alsa_playback; +extern char *alsa_capture; +extern int alsa_latency; +extern int alsa_debug; + +static RadioDev *dev; + +/* + * These functions handle the radio device + */ +int radio_init(char *device, DriverType driver) +{ + int rv = -1; + + if (autodetect) { + void *md; + const char *p = NULL; + char buf[PATH_MAX]; + + *device = 0; + md = discover_media_devices(); + if (!md) { + fprintf (stderr, "open: Failed to open \"auto\" device"); + if (*device) + fprintf (stderr, " at %s\n", device); + else + fprintf (stderr, "\n"); + goto failure; + } + + while (1) { + p = get_associated_device(md, p, MEDIA_V4L_RADIO, NULL, NONE); + if (!p) + break; + snprintf(buf, sizeof(buf), "/dev/%s", p); + device = &buf[0]; + } + + free_media_devices(md); + } + + switch (driver) { + case DRIVER_ANY: + case DRIVER_V4L2: + default: + goto try_v4l2; + case DRIVER_V4L1: + goto try_v4l1; + } + +try_v4l1: + dev = v4l1_radio_dev_new(); + rv = dev->init (dev, device); + if (rv == 0) { + fprintf(stderr, "v4l1: Initialization failed\n"); + dev->finalize (dev); + dev = NULL; + if (alsa_loopback) + alsa_loopback = 0; + if (driver != DRIVER_ANY) + goto failure; + } else { + goto success; + } + +try_v4l2: + dev = v4l2_radio_dev_new(); + rv = dev->init (dev, device); + if (rv == 0) { + fprintf(stderr, "v4l2: Initialization failed\n"); + dev->finalize (dev); + dev = NULL; + if (alsa_loopback) + alsa_loopback = 0; + if (driver != DRIVER_ANY) + goto failure; + } else { + goto success; + } + +success: + if (autodetect) + fprintf(stderr, "open: Using radio device: %s\n", device); + + if (alsa_loopback) { + if (alsa_capture == NULL) { + void *md = discover_media_devices(); + const char *p = strrchr(device, '/'); + if (p) + p++; + else + p = device; + + p = get_associated_device(md, NULL, MEDIA_SND_CAP, p, MEDIA_V4L_RADIO); + if (p) + alsa_capture = strdup(p); + else + alsa_loopback = 0; + + free_media_devices(md); + } + + if (alsa_loopback) { + if (alsa_playback == NULL) + alsa_playback = "default"; + + fprintf(stderr, "alsa: Using audio loopback device from %s (%s) to %s\n", + alsa_capture, device, alsa_playback); + } + } + + radio_unmute(); +failure: + + return rv; +} + +int radio_is_init(void) +{ + if (dev) return dev->is_init (dev); + else return 0; +} + +void radio_stop(void) +{ + radio_mute(); + + if (dev) dev->finalize (dev); +} + +void radio_set_freq(float frequency) +{ + if (dev) dev->set_freq (dev, frequency); +} + +void radio_unmute(void) +{ + if (dev) dev->mute (dev, 0); + if (alsa_loopback) + alsa_thread_startup(alsa_playback, alsa_capture, + alsa_latency, stderr, alsa_debug); +} + +void radio_mute(void) +{ + if (dev) dev->mute (dev, 1); + if (alsa_loopback) + alsa_thread_stop(); +} + +int radio_get_stereo(void) +{ + if (dev) return dev->get_stereo (dev); + else return -1; +} + +int radio_get_signal(void) +{ + if (dev) return dev->get_signal (dev); + else return -1; +} + +int radio_check_station(float freq) +{ + static int a, b; + static float last; + int signal; + + signal = radio_get_signal(); + + if (last == 0.0f) + last = freq; + + if ((a + b + signal > 8) && (fabsf(freq - last) > 0.25f)) { + a = b = 0; + last = freq; + return 1; + } + a = b; + b = signal; + return 0; +} + === modified file '.pc/gnomeradio-save_the_world.patch/src/gui.c' --- .pc/gnomeradio-save_the_world.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-save_the_world.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1263,7 +1263,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === modified file '.pc/gnomeradio-thread_safe.patch/src/gui.c' --- .pc/gnomeradio-thread_safe.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-thread_safe.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -1264,7 +1264,7 @@ } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, === added directory '.pc/gnomeradio-tray_menu.patch' === removed directory '.pc/gnomeradio-tray_menu.patch' === added directory '.pc/gnomeradio-tray_menu.patch/src' === removed directory '.pc/gnomeradio-tray_menu.patch/src' === added file '.pc/gnomeradio-tray_menu.patch/src/gui.c' --- .pc/gnomeradio-tray_menu.patch/src/gui.c 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/gui.c 2013-10-03 19:38:23 +0000 @@ -0,0 +1,1582 @@ +/* gui.c + * + * Copyright (C) 2001 Jörgen Scheibengruber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + +/*** the gui to gnomeradio */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "gui.h" +#include "trayicon.h" +#include "mixer.h" +#include "radio.h" +#include "rec_tech.h" +#include "lirc.h" +#include "prefs.h" +#include "record.h" +#include "alsa_stream.h" +#include "rb_gst_media_types.h" +#include "rb_missing_plugins.h" + +#include "../data/pixmaps/digits.xpm" +#include "../data/pixmaps/signal.xpm" +#include "../data/pixmaps/stereo.xpm" +#include "../data/pixmaps/freq_up.xpm" +#include "../data/pixmaps/freq_down.xpm" + +#define DIGIT_WIDTH 20 +#define DIGIT_HEIGTH 30 +#define SIGNAL_WIDTH 25 +#define STEREO_WIDTH 35 +#define SCAN_SPEED 20 + +#define TRANSLATORS "TRANSLATORS" + +/* Latency is not a big problem for radio (no video to sync with), and + USB radio devices benefit from a larger default latency */ +#define DEFAULT_LATENCY 500 + +int autodetect; +int can_capture; + +int alsa_loopback = 0; +char *alsa_playback = NULL; +char *alsa_capture = NULL; +int alsa_latency = DEFAULT_LATENCY; +int alsa_debug = 0; + +int mom_ps; +gnomeradio_settings settings; + +gboolean main_visible; + +GtkWidget *app; +GtkWidget *preset_combo; +GtkAdjustment *adj; +GtkWidget *volume_button; + +static GtkWidget *drawing_area; +static GdkPixbuf *digits; +static GdkPixbuf *signal_s; +static GdkPixbuf *stereo; +static GtkWidget *freq_scale; +static GtkWidget *scbw_button; +static GtkWidget *stbw_button; +static GtkWidget *stfw_button; +static GtkWidget *scfw_button; +static GtkWidget *rec_button; +static GtkWidget *prefs_button; + +static int timeout_id; +static int bp_timeout_id = -1; +static int bp_timeout_steps = 0; +static gint mode; + +static DBusGProxy * connect_to_session (void); + +static gboolean is_first_start(void) +{ + GConfClient *client; + gboolean first_start; + + client = gconf_client_get_default(); + if (!client) + return TRUE; + + first_start = gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL); + + g_object_unref (client); + + return !first_start; +} + +static void set_first_time_flag(void) +{ + GConfClient *client; + + client = gconf_client_get_default(); + if (!client) + return; + + gconf_client_set_bool(client, "/apps/gnomeradio/first_time_flag", TRUE, NULL); + + g_object_unref (client); +} + +typedef struct { + GtkWidget *dialog; + GtkWidget *progress; + GList *stations; + GtkWidget *label; +} FreqScanData; + +static gboolean initial_frequency_scan_cb(gpointer data) +{ + static gfloat freq = FREQ_MIN - 4.0f/STEPS; + FreqScanData *fsd = data; + + g_assert(fsd); + + if (freq > FREQ_MAX) { + gtk_widget_destroy(fsd->dialog); + timeout_id = 0; + return FALSE; + } + + if (radio_check_station(freq)) { + char *text = g_strdup_printf(ngettext("%d station found", + "%d stations found", + g_list_length(fsd->stations) + 1), + g_list_length(fsd->stations) + 1); + + gfloat *f = g_malloc(sizeof(gfloat)); + gtk_label_set_text(GTK_LABEL(fsd->label), text); + g_free(text); + + g_print("Found a station at %.2f MHz\n", freq); + + *f = freq; + fsd->stations = g_list_append(fsd->stations, f); + } + + gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(fsd->progress), MAX(0, (freq - FREQ_MIN)/(FREQ_MAX - FREQ_MIN))); + + freq += 1.0/STEPS; + radio_set_freq(freq); + + return TRUE; +} + +static void initial_frequency_scan(GtkWidget *app) +{ + FreqScanData data; + GtkWidget *content_area; + GtkWidget *label; + gchar *markup; + + data.stations = NULL; + + data.dialog = gtk_dialog_new_with_buttons (_("Scanning"), GTK_WINDOW (app), DIALOG_FLAGS, + _("_Cancel"), GTK_RESPONSE_CANCEL, + NULL); + /* gtk_dialog_set_has_separator(GTK_DIALOG(data.dialog), FALSE); */ + gtk_window_set_resizable(GTK_WINDOW(data.dialog), FALSE); + + content_area = gtk_dialog_get_content_area (GTK_DIALOG (data.dialog)); + + label = gtk_label_new (NULL); + gtk_widget_set_halign (label, GTK_ALIGN_START); + markup = g_strdup_printf ("%s", _("Scanning for available stations:")); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (markup); + gtk_box_pack_start (GTK_BOX (content_area), label, FALSE, FALSE, 6); + + data.progress = gtk_progress_bar_new (); + gtk_box_pack_start (GTK_BOX (content_area), data.progress, TRUE, FALSE, 6); + + data.label = gtk_label_new (_("No stations found")); + gtk_widget_set_halign (data.label, GTK_ALIGN_START); + gtk_box_pack_start (GTK_BOX (content_area), data.label, TRUE, FALSE, 6); + + gtk_widget_show_all(data.dialog); + + radio_mute(); + timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)initial_frequency_scan_cb, (gpointer)&data); + gtk_dialog_run(GTK_DIALOG(data.dialog)); + + radio_unmute(); + if (timeout_id) { + g_source_remove(timeout_id); + timeout_id = 0; + gtk_widget_destroy(data.dialog); + } else { + if (data.stations != NULL) { + gfloat f = *((gfloat*)data.stations->data); + gtk_adjustment_set_value(adj, f*STEPS); + radio_set_freq(f); + + GtkWidget *dialog; + GList *l; + + char *text = g_strdup_printf (ngettext ("%d station found.\n" + "Do you want to add it as preset?", + "%d stations found.\n" + "Do you want to add them as presets?", g_list_length (data.stations)), + g_list_length (data.stations)); + + dialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_QUESTION, + GTK_BUTTONS_YES_NO, "%s", text); + g_free(text); + + int response = gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); + + for (l = data.stations; l; l = l->next) { + if (response == GTK_RESPONSE_YES) { + preset *ps = g_malloc0(sizeof(preset)); + ps->title = g_strdup(_("unnamed")); + ps->freq = *((gfloat*) l->data); + settings.presets = g_list_prepend(settings.presets, ps); + } + g_free (l->data); + } + settings.presets = g_list_reverse(settings.presets); + } + } +} + +int gtk_volume_button_get_value (GtkWidget *button) +{ + return (int) (gtk_scale_button_get_value(GTK_SCALE_BUTTON(button)) * 100); +} + +void gtk_volume_button_set_value (GtkWidget *button, int value) +{ + gtk_scale_button_set_value(GTK_SCALE_BUTTON(button), (gdouble) value / 100); +} + +static void prefs_button_clicked_cb(GtkButton *button, gpointer app) +{ + GtkWidget* dialog; + gint choise; + + dialog = prefs_window(app); + + /* Michael Jochum proposed to not use gnome_dialog_set_parent() + but following instead. */ + gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(app)); + gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); + + /*gnome_dialog_set_parent(GNOME_DIALOG(dialog), GTK_WINDOW(app));*/ + + action_mode (mode); + + choise = GTK_RESPONSE_HELP; + while (choise == GTK_RESPONSE_HELP) + { + choise = gtk_dialog_run(GTK_DIALOG(dialog)); + switch (choise) + { + case GTK_RESPONSE_HELP: + display_help_cb("gnomeradio-settings"); + break; + default: + /* We need the hide signal to get the value of the device[mixer]_entry */ + gtk_widget_hide(dialog); + gtk_widget_destroy(dialog); + } + } +} + +void start_radio(gboolean restart, GtkWidget *app) +{ + DriverType driver = DRIVER_ANY; + + if (restart) { + radio_stop(); + if (settings.audio_loopback) + alsa_loopback = 1; + else + alsa_loopback = 0; + } + + if (settings.driver) { + if (0 == strcmp(settings.driver, "v4l1")) + driver = DRIVER_V4L1; + if (0 == strcmp(settings.driver, "v4l2")) + driver = DRIVER_V4L2; + } + + autodetect = 0; + if ((0 == strcmp(settings.device, "auto")) || (0 == strcmp(settings.device, ""))) + autodetect = 1; + + if (settings.audio_loopback) + alsa_loopback = 1; + + if (!radio_init(settings.device, driver)) { + char *caption, *detail; + + can_capture = 0; + if (restart) + audio_box_set_visible (can_capture); + + if (autodetect) { + caption = g_strdup_printf (_("Could not find any radio device!")); + detail = g_strdup_printf (_("Please ensure that you have a radio device connected to your computer.\n" + "You can also use the dmesg command: \"dmesg | grep radio\" to determine\n" + "whether device is properly detected.")); + } else { + caption = g_strdup_printf (_("Could not open radio device \"%s\"!"), settings.device); + detail = g_strdup_printf (_("You can auto detect radio device by typing \"auto\" in device settings.")); + } + + show_error_message(caption, detail); + g_free(caption); + g_free(detail); + + if (!restart) { + mode = RADIO_DEVICE; + prefs_button_clicked_cb(NULL, app); + mode = PRESETS; + } + } +} + +void start_mixer(gboolean restart, GtkWidget *app) +{ + gint vol; + + if (restart) + mixer->close_device(); + + if (!mixer_set_device(settings.mixer)) { + char *caption, *detail; + + caption = g_strdup_printf (_("Could not open mixer device and channel \"%s\"!"), settings.mixer); + detail = g_strdup_printf (_("You can use alsamixer to get information about sound device.\n" + "The format to set mixer to use: \"device/channel\" (e.g. hw:0/Line).")); + + show_error_message(caption, detail); + g_free(caption); + g_free(detail); + + gtk_widget_set_sensitive(volume_button, FALSE); + + if (!restart) { + mode = MIXER_DEVICE; + prefs_button_clicked_cb(NULL, app); + mode = PRESETS; + } + + } else { + vol = mixer->get_volume(); + if (vol >= 0) + gtk_volume_button_set_value(volume_button, vol); + gtk_widget_set_sensitive(volume_button, TRUE); + } +} + +static gboolean redraw_status_window(void) +{ + + GdkWindow *real_window; + cairo_t *cr; + int win_width; + int val, freq[5], signal_strength, is_stereo; + + val = (int)(rint(gtk_adjustment_get_value(adj)/STEPS * 100.0)); + + freq[0] = val / 10000; + freq[1] = (val % 10000) / 1000; + freq[2] = (val % 1000) / 100; + freq[3] = (val % 100) / 10; + freq[4] = val % 10; + + signal_strength = radio_get_signal(); + is_stereo = radio_get_stereo(); + + if (signal_strength > 3) signal_strength = 3; + if (signal_strength < 0) signal_strength = 0; + is_stereo = (is_stereo == 1) ? 1 : 0; + + real_window = gtk_widget_get_window(drawing_area); + if (real_window == NULL) + /* UI has not been realized yet */ + return TRUE; + /* gdk_drawable_get_size(real_window, &win_width, &win_height); */ + win_width = gdk_window_get_width (real_window); + + /* use doublebuffering to avoid flickering */ + /* window = gdk_pixmap_new(real_window, win_width, win_height, -1); */ + + cr = gdk_cairo_create (real_window); + cairo_set_source_rgb (cr, 0, 0, 0); + cairo_paint (cr); + + win_width -= 5; + + if (freq[0]) { + /* gdk_draw_drawable(window, gc, digits, freq[0] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*6 - freq[0] * DIGIT_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH); + cairo_fill (cr); + } else { + cairo_rectangle(cr, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH); + cairo_fill (cr); + } + + /* gdk_draw_drawable(window, gc, digits, freq[1] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*5, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*5 - freq[1] * DIGIT_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*5, 5, DIGIT_WIDTH, DIGIT_HEIGTH); + cairo_fill(cr); + /* gdk_draw_drawable(window, gc, digits, freq[2] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*4, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*4 - freq[2] * DIGIT_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*4, 5, DIGIT_WIDTH, DIGIT_HEIGTH); + cairo_fill(cr); + /* gdk_draw_drawable(window, gc, digits, 10 * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*3, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*3 - 10 * DIGIT_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*3, 5, DIGIT_WIDTH, DIGIT_HEIGTH); + cairo_fill(cr); + /* gdk_draw_drawable(window, gc, digits, freq[3] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*2, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*2 - freq[3] * DIGIT_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*2, 5, DIGIT_WIDTH, DIGIT_HEIGTH); + cairo_fill(cr); + /* gdk_draw_drawable(window, gc, digits, freq[4] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*1, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*1 - freq[4] * DIGIT_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*1, 5, DIGIT_WIDTH, DIGIT_HEIGTH); + cairo_fill(cr); + /* gdk_draw_drawable(window, gc, signal_s, signal_strength * SIGNAL_WIDTH, 0, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH, 5, SIGNAL_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, signal_s, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH - signal_strength * SIGNAL_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH, 5, SIGNAL_WIDTH, DIGIT_HEIGTH); + cairo_fill(cr); + /* gdk_draw_drawable(window, gc, stereo, is_stereo * STEREO_WIDTH, 0, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH, 5, STEREO_WIDTH, DIGIT_HEIGTH); */ + gdk_cairo_set_source_pixbuf (cr, stereo, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH - is_stereo * STEREO_WIDTH, 5); + cairo_rectangle (cr, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH, 5, STEREO_WIDTH, DIGIT_HEIGTH); + cairo_fill(cr); + + /* draw the pixmap to the real window */ + /* gdk_draw_drawable(real_window, gc, window, 0, 0, 0, 0, win_width + 5, win_height); */ + + cairo_destroy (cr); + /* g_object_unref(G_OBJECT(window)); */ + + return TRUE; +} + +static gboolean draw_cb(GtkWidget *widget, cairo_t *cr, gpointer data) +{ + redraw_status_window(); + return TRUE; +} + +void exit_gnome_radio(void) +{ + if (settings.mute_on_exit) + radio_stop(); + + mixer->close_device(); + save_settings(); + gtk_main_quit(); +} + +const char* get_preset(float freq, int *num) +{ + GList *node = settings.presets; + + int i = *num = -1; + for (;node;) + { + ++i; + preset *ps = (preset*)node->data; + if (fabs(ps->freq - freq) < 0.01) + { + *num = i; + return ps->title; + } + node = node->next; + } + return NULL; +} + +static void adj_value_changed_cb(GtkAdjustment* data, gpointer window) +{ + char *buffer; + float freq = rint(gtk_adjustment_get_value(adj))/STEPS; + const char *preset_title = get_preset(freq, &mom_ps); + + preset_combo_set_item(mom_ps); + + redraw_status_window(); + + if (preset_title) + buffer = g_strdup_printf(_("Gnomeradio - %s"), preset_title); + else + buffer = g_strdup_printf(_("Gnomeradio - %.2f MHz"), freq); + gtk_window_set_title(GTK_WINDOW(window), buffer); + if (tray_icon) gtk_status_icon_set_tooltip_text(GTK_STATUS_ICON(tray_icon), buffer); + g_free(buffer); + + buffer = g_strdup_printf(_("Frequency: %.2f MHz"), freq); + gtk_widget_set_tooltip_text(freq_scale, buffer); + g_free(buffer); + + radio_set_freq(gtk_adjustment_get_value(adj)/STEPS); +} + +static void volume_value_changed_cb(GtkVolumeButton *button, gpointer user_data) +{ + int vol = (int)(gtk_volume_button_get_value(volume_button) + 0.5f); + + mixer->set_volume(vol - mixer->get_volume()); + + if (tray_menu) { + g_signal_handler_block(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), vol == 0); + g_signal_handler_unblock(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id); + } +} + +#if 0 +static gboolean poll_volume_change(gpointer data) +{ + int vol; + if ((vol = mixer->get_volume()) < 0) + return FALSE; + + if (vol != (int)volume->value) + { + g_print("external volume change detected\n"); + gtk_adjustment_set_value(volume, (double)vol); + } + + return TRUE; +} +#endif + +static void change_frequency(gpointer data) +{ + gboolean increase = (gboolean) GPOINTER_TO_INT (data); + gint v = gtk_adjustment_get_value(adj); + + if (increase) + { + if (v >= FREQ_MAX*STEPS) + gtk_adjustment_set_value(adj, FREQ_MIN*STEPS); + else + gtk_adjustment_set_value(adj, v+1); + } + else + { + if (v <= FREQ_MIN*STEPS) + gtk_adjustment_set_value(adj, FREQ_MAX*STEPS); + else + gtk_adjustment_set_value(adj, v-1); + } +} + +static gboolean change_frequency_timeout(gpointer data) +{ + change_frequency(data); + if (bp_timeout_steps < 10) + { + g_source_remove(bp_timeout_id); + bp_timeout_id = g_timeout_add(200 - 20*bp_timeout_steps, + (GSourceFunc)change_frequency_timeout, data); + bp_timeout_steps++; + } + return TRUE; +} + +static void step_button_pressed_cb(GtkButton *button, gpointer data) +{ + bp_timeout_id = g_timeout_add(500, (GSourceFunc)change_frequency_timeout, data); +} + +static void step_button_clicked_cb(GtkButton *button, gpointer data) +{ + change_frequency(data); +} + +static void step_button_released_cb(GtkButton *button, gpointer data) +{ + if (bp_timeout_id > -1) + g_source_remove(bp_timeout_id); + bp_timeout_id = -1; + bp_timeout_steps = 0; +} + +static gboolean scan_freq(gpointer data) +{ + static gint start, mom, max; + gint dir = GPOINTER_TO_INT (data); + + if (!max) { + max = (FREQ_MAX - FREQ_MIN) * STEPS; + } + + if (radio_check_station(gtk_adjustment_get_value(adj)/STEPS) || (start > max)) { + start = mom = 0; + radio_unmute(); + timeout_id = 0; + return FALSE; + } + if (!mom) { + mom = gtk_adjustment_get_value(adj); + } + + if (mom > FREQ_MAX*STEPS) + mom = FREQ_MIN*STEPS; + else if (mom < FREQ_MIN*STEPS) + mom = FREQ_MAX*STEPS; + else + mom = mom + dir; + start += 1; + gtk_adjustment_set_value(adj, mom); + + return TRUE; +} + +void scfw_button_clicked_cb(GtkButton *button, gpointer data) +{ + if (timeout_id) { + g_source_remove(timeout_id); + timeout_id = 0; + radio_unmute(); + return; + } + radio_mute(); + timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)scan_freq, (gpointer)1); +} + +void scbw_button_clicked_cb(GtkButton *button, gpointer data) +{ + if (timeout_id) { + g_source_remove(timeout_id); + timeout_id = 0; + radio_unmute(); + return; + } + radio_mute(); + timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)scan_freq, (gpointer)(-1)); +} + +void preset_combo_set_item(gint i) +{ + if (i < -1) return; + if (preset_combo == NULL) return; + gtk_combo_box_set_active(GTK_COMBO_BOX(preset_combo), i + 1); +} + +static void preset_combo_change_cb(GtkWidget *combo, gpointer data) +{ + preset* ps; + mom_ps = gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) - 1; + + if (mom_ps < 0) return; + + ps = (preset*)g_list_nth_data(settings.presets, mom_ps); + gtk_adjustment_set_value(adj, ps->freq * STEPS); +} + +void change_preset(gboolean next) +{ + preset *ps; + int len = g_list_length(settings.presets); + if (len < 1) + return; + + if (next) + mom_ps = (mom_ps + 1) % len; + else + mom_ps = (mom_ps - 1 + len) % len; + + ps = g_list_nth_data(settings.presets, mom_ps); + gtk_adjustment_set_value(adj, ps->freq*STEPS); + preset_combo_set_item(mom_ps); +} + +void gnomeradio_switch_to_preset (gint index) +{ + if (0 <= index && index < g_list_length(settings.presets)) { + preset *ps = g_list_nth_data(settings.presets, index); + gtk_adjustment_set_value(adj, ps->freq*STEPS); + mom_ps = index; + preset_combo_set_item(mom_ps); + } +} + +static void quit_button_clicked_cb(GtkButton *button, gpointer data) +{ + exit_gnome_radio(); +} + +void tray_icon_items_set_sensible(gboolean sensible) +{ + GList* menuitems; + GtkWidget *menuitem; + int i, cnt = g_list_length(settings.presets); + + + menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); + + g_assert(cnt + 6 == g_list_length(menuitems)); + + /* Disable the presets */ + for (i = 0; i < cnt; i++) { + menuitem = g_list_nth_data(menuitems, i); + gtk_widget_set_sensitive(menuitem, sensible); + } + + /* Disable the mute button (separator => +1) */ + menuitem = g_list_nth_data(menuitems, cnt + 1); + gtk_widget_set_sensitive(menuitem, sensible); + + /* Disable the record button */ + menuitem = g_list_nth_data(menuitems, cnt + 2); + gtk_widget_set_sensitive(menuitem, sensible); + + /* Disable the quit button */ + menuitem = g_list_nth_data(menuitems, cnt + 5); + gtk_widget_set_sensitive(menuitem, sensible); +} + +void recording_set_sensible(gboolean sensible) +{ + /* Disable the presets */ + gtk_widget_set_sensitive(preset_combo, sensible); + + /* Disable the scan button */ + gtk_widget_set_sensitive(freq_scale, sensible); + gtk_widget_set_sensitive(scfw_button, sensible); + gtk_widget_set_sensitive(scbw_button, sensible); + gtk_widget_set_sensitive(stfw_button, sensible); + gtk_widget_set_sensitive(stbw_button, sensible); + + /* Disable the record button */ + gtk_widget_set_sensitive(rec_button, sensible); + + /* Disable the preferences button */ + gtk_widget_set_sensitive(prefs_button, sensible); +} + +static int start_recording(const gchar *destination, const char* station, const char* time) +{ + Recording* recording; + GFile *file; + GFileInfo *info; + gchar *caption, *detail; + + file = g_file_new_for_path (rec_settings.destination); + info = g_file_query_info (file, + G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, + G_FILE_QUERY_INFO_NONE, + NULL, + NULL); + + if (info != NULL) { + if (!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) { + caption = g_strdup_printf (_("Could not write file to \"%s\" location!"), rec_settings.destination); + detail = g_strdup_printf (_("Check your settings and make sure that you have write access to it.")); + show_error_message (caption, detail); + + g_free (caption); + g_free (detail); + + g_object_unref(info); + g_object_unref(file); + + return -1; + } + g_object_unref(info); + } + g_object_unref(file); + + if (rb_gst_check_missing_plugins (rb_gst_get_encoding_profile (rec_settings.profile), NULL, NULL)) { + gchar *extension, *format; + + extension = g_utf8_strup (rb_gst_media_type_to_extension (rec_settings.profile), -1); + format = g_strdup_printf ("%s", extension); + caption = g_strdup_printf (_("Could not write file in \"%s\" format!"), format); + detail = g_strdup_printf (_("You need to install additional software required to use this format.")); + show_error_message (caption, detail); + + g_free (extension); + g_free (format); + g_free (caption); + g_free (detail); + + return -1; + } + + /* You can translate the filename for a recording: + * args for this format are: path, station title, time + */ + char *filename = g_strdup_printf (_("%s/%s_%s"), destination, station, time); + recording = recording_start (filename); + g_free (filename); + + if (!recording) + return -1; + + tray_icon_items_set_sensible (FALSE); + recording_set_sensible (FALSE); + + recording->station = g_strdup (station); + record_status_window (recording); + + run_status_window (recording); + + return 1; +} + +void rec_button_clicked_cb(GtkButton *button, gpointer app) +{ + char *station; + char time_str[100]; + time_t t; + struct tm lt; + + t = time(NULL); + localtime_r(&t, <); + /* consult man strftime to translate this. This is a filename, so don't use "/" or ":", please */ + strftime(time_str, 100, _("%Y%m%d-%H%M%S"), <); + + if (mom_ps < 0) { + station = g_strdup_printf(_("%.2f MHz"), rint(gtk_adjustment_get_value(adj))/STEPS); + } else { + g_assert(mom_ps < g_list_length(settings.presets)); + preset* ps = g_list_nth_data(settings.presets, mom_ps); + g_assert(ps); + + station = g_strdup(ps->title); + } + +/* if (!check_filename(filename)) { + GtkWidget *errdialog; + errdialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + _("Error opening file '%s':\n%s"), filename, strerror(errno)); + gtk_dialog_run (GTK_DIALOG (errdialog)); + gtk_widget_destroy (errdialog); + } else */ + start_recording(rec_settings.destination, station, time_str); + g_free(station); +} + +void toggle_volume(void) +{ + static int old_vol; + int vol = mixer->get_volume(); + + if (vol) { + old_vol = vol; + vol = 0; + /* Stop/start the alsa stream on mute/unmute + * This fixes muting not working on cards without a mute control, or where + * the mute control does not work (such as on my card, where mute only influences + * the analog audio path and not the digital audio path used when streaming alsa + * sound) + */ + if (alsa_loopback) + alsa_thread_stop(); + } else { + vol = old_vol; + if (alsa_loopback) + alsa_thread_startup(alsa_playback, alsa_capture, + alsa_latency, stderr, alsa_debug); + } + mixer->set_volume(vol); + gtk_volume_button_set_value(volume_button, vol); + /*gtk_adjustment_set_value(volume, vol);*/ +} + +/* +static void volume_button_toggled_cb(GtkButton *button, gpointer data) +{ + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(volume_button))) + { + gtk_widget_set_tooltip_text(volume_button, _("Unmute")); + } + else + { + gtk_widget_set_tooltip_text(volume_button, _("Mute")); + } + toggle_volume(); +} +*/ + +static char *get_license_text (void) +{ + const gchar *license[] = { + N_("Gnomeradio is free software; you can redistribute it and/or modify " + "it under the terms of the GNU General Public License as published by " + "the Free Software Foundation; either version 2 of the License, or " + "(at your option) any later version."), + N_("Gnomeradio is distributed in the hope that it will be useful, " + "but WITHOUT ANY WARRANTY; without even the implied warranty of " + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the " + "GNU General Public License for more details."), + N_("You should have received a copy of the GNU General Public License " + "along with Gnomeradio; if not, write to the Free Software Foundation, " + "Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA") + }; + return g_strjoin ("\n\n", + _(license[0]), + _(license[1]), + _(license[2]), + NULL); +} + +static void about_button_clicked_cb(GtkButton *button, gpointer data) +{ + static GtkWidget *about; + const char *authors[] = {"J\xc3\xb6rgen Scheibengruber ", NULL}; + + /* Feel free to put your names here translators :-) */ + char *translators = _("TRANSLATORS"); + char *license = get_license_text (); + + if (about) + { + gtk_window_present (GTK_WINDOW (about)); + return; + } + + gtk_show_about_dialog (NULL, + "version", VERSION, + "copyright", _("Copyright \xc2\xa9 2001 - 2006 J\xc3\xb6rgen Scheibengruber"), + "comments", _("Listen to FM radio"), + "authors", authors, + "translator-credits", strcmp("TRANSLATORS", translators) ? translators : NULL, + "logo-icon-name", "gnomeradio", + "license", license, + "wrap-license", TRUE, + "website-label", _("Gnomeradio Website"), + "website", "http://www.gnome.org/projects/gnomeradio/", + NULL); + + g_free (license); + + /* about = gnome_about_new ("Gnomeradio", VERSION, "Copyright 2001 - 2006 Jörgen Scheibengruber", + text, (const char **) authors, NULL, + strcmp("TRANSLATORS", translators) ? translators : NULL, + app_icon); + + gtk_widget_show(about); + g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&about); + g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&app_icon); */ +} + +static gint delete_event_cb(GtkWidget* window, GdkEventAny* e, gpointer data) +{ + exit_gnome_radio(); + return TRUE; +} + +void display_help_cb(char *topic) +{ + GError *error = NULL; + + char *uri; + + if (topic) + uri = g_strdup_printf ("help:gnomeradio/%s", topic); + else + uri = g_strdup ("help:gnomeradio"); + + gtk_show_uri (NULL, uri, GDK_CURRENT_TIME, &error); + + if (error) + { + GtkWidget *dialog; + dialog = gtk_message_dialog_new (NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + _("Failed to open %s: %s"), uri, error->message); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + g_error_free (error); + error = NULL; + } + + g_free (uri); +} + +void toggle_mainwindow_visibility(GtkWidget *app) +{ + static gint posx, posy; + if (gtk_widget_get_visible(app)) + { + gtk_window_get_position(GTK_WINDOW(app), &posx, &posy); + gtk_widget_hide(app); + } + else + { + if ((posx >= 0) && (posy >= 0)) + gtk_window_move(GTK_WINDOW(app), posx, posy); + gtk_window_present(GTK_WINDOW(app)); + } +} + +GtkWidget* gnome_radio_gui(void) +{ + GtkWidget *app; + GtkWidget *vbox; + GtkWidget *box; + GtkWidget *frame; + GtkWidget *menubox; + GtkWidget *label; + GtkWidget *pixmap; + GdkPixbuf *pixbuf; + GtkWidget *vseparator; + GtkWidget *about_button; +/* GtkWidget *quit_button; */ + GtkWidget *image; + gchar *text; + gboolean rtl; + + app = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_resizable(GTK_WINDOW(app), FALSE); + gtk_window_set_wmclass(GTK_WINDOW(app), "gnomeradio", "Gnomeradio"); + + gtk_widget_realize (app); + gtk_widget_get_window (app); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_container_set_border_width (GTK_CONTAINER(vbox), 3); + + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + + frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN); + gtk_container_set_border_width (GTK_CONTAINER (frame), 2); + + drawing_area = gtk_drawing_area_new(); + gtk_widget_set_size_request(drawing_area, DIGIT_WIDTH*6+10+SIGNAL_WIDTH+STEREO_WIDTH, DIGIT_HEIGTH+10); + + gtk_container_add (GTK_CONTAINER (frame), drawing_area); + + digits = gdk_pixbuf_new_from_xpm_data ((const char**) digits_xpm); + signal_s = gdk_pixbuf_new_from_xpm_data ((const char**) signal_xpm); + stereo = gdk_pixbuf_new_from_xpm_data ((const char**) stereo_xpm); + + menubox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + + label = gtk_label_new (_("Presets:")); + + preset_combo = gtk_combo_box_text_new (); + gtk_widget_set_size_request (preset_combo, 10, -1); + + gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 3); + gtk_box_pack_start (GTK_BOX (box), menubox, TRUE, TRUE, 3); + gtk_box_pack_start (GTK_BOX (menubox), label, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (menubox), preset_combo, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 4); + + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + + pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**) freq_down_xpm); + pixmap = gtk_image_new_from_pixbuf (pixbuf); + + gtk_box_pack_start (GTK_BOX(box), pixmap, FALSE, FALSE, 2); + + adj = GTK_ADJUSTMENT (gtk_adjustment_new (SUNSHINE*STEPS, FREQ_MIN*STEPS, FREQ_MAX*STEPS+1, 1, STEPS, 1)); + freq_scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj); + gtk_scale_set_digits (GTK_SCALE (freq_scale), 0); + gtk_scale_set_draw_value (GTK_SCALE (freq_scale), FALSE); + + gtk_box_pack_start (GTK_BOX(box), freq_scale, TRUE, TRUE, 0); + + pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**) freq_up_xpm); + pixmap = gtk_image_new_from_pixbuf (pixbuf); + + gtk_box_pack_start (GTK_BOX (box), pixmap, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX (vbox), box, TRUE, TRUE, 2); + + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + + rtl = gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL; + + scbw_button = gtk_button_new (); + image = gtk_image_new_from_icon_name (rtl ? "media-seek-backward-rtl" : "media-seek-backward", + GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (scbw_button), image); + + gtk_box_pack_start (GTK_BOX (box), scbw_button, FALSE, FALSE, 2); + + stbw_button = gtk_button_new (); + image = gtk_image_new_from_icon_name (rtl ? "media-skip-backward-rtl" : "media-skip-backward", + GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (stbw_button), image); + + gtk_box_pack_start (GTK_BOX (box), stbw_button, FALSE, FALSE, 2); + + stfw_button = gtk_button_new (); + image = gtk_image_new_from_icon_name (rtl ? "media-skip-forward-rtl" : "media-skip-forward", + GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (stfw_button), image); + + gtk_box_pack_start (GTK_BOX (box), stfw_button, FALSE, FALSE, 2); + + scfw_button = gtk_button_new (); + image = gtk_image_new_from_icon_name (rtl ? "media-seek-forward-rtl" : "media-seek-forward", + GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (scfw_button), image); + + gtk_box_pack_start (GTK_BOX (box), scfw_button, FALSE, FALSE, 2); + + vseparator = gtk_separator_new (GTK_ORIENTATION_VERTICAL); + + gtk_box_pack_start (GTK_BOX (box), vseparator, FALSE, FALSE, 2); + + volume_button = gtk_volume_button_new(); + gtk_button_set_relief(GTK_BUTTON(volume_button), GTK_RELIEF_NORMAL); + gtk_widget_set_sensitive(volume_button, FALSE); + + gtk_box_pack_start (GTK_BOX (box), volume_button, FALSE, FALSE, 2); + + rec_button = gtk_button_new (); + image = gtk_image_new_from_icon_name ("media-record", GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (rec_button), image); + + gtk_box_pack_start (GTK_BOX (box), rec_button, FALSE, FALSE, 2); + + vseparator = gtk_separator_new (GTK_ORIENTATION_VERTICAL); + + gtk_box_pack_start (GTK_BOX (box), vseparator, FALSE, FALSE, 2); + + prefs_button = gtk_button_new (); + image = gtk_image_new_from_icon_name ("document-properties", GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (prefs_button), image); + + gtk_box_pack_start (GTK_BOX (box), prefs_button, FALSE, FALSE, 2); + + about_button = gtk_button_new (); + image = gtk_image_new_from_icon_name ("help-about", GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (about_button), image); + + gtk_box_pack_start (GTK_BOX (box), about_button, FALSE, FALSE, 2); + +/* quit_button = gtk_button_new (); + image = gtk_image_new_from_icon_name ("application-exit", GTK_ICON_SIZE_LARGE_TOOLBAR); + gtk_button_set_image (GTK_BUTTON (quit_button), image); + gtk_box_pack_start (GTK_BOX (box), quit_button, FALSE, FALSE, 2); */ + + gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 4); + + g_signal_connect (G_OBJECT (app), "delete_event", G_CALLBACK (delete_event_cb), NULL); + g_signal_connect (G_OBJECT (drawing_area), "draw", G_CALLBACK (draw_cb), NULL); + g_signal_connect (G_OBJECT (preset_combo), "changed", G_CALLBACK (preset_combo_change_cb), NULL); + g_signal_connect (G_OBJECT (adj), "value-changed", G_CALLBACK (adj_value_changed_cb), (gpointer) app); + g_signal_connect (G_OBJECT (scbw_button), "clicked", G_CALLBACK (scbw_button_clicked_cb), NULL); + g_signal_connect (G_OBJECT (stbw_button), "pressed", G_CALLBACK (step_button_pressed_cb), (gpointer) FALSE); + g_signal_connect (G_OBJECT (stbw_button), "clicked", G_CALLBACK (step_button_clicked_cb), (gpointer) FALSE); + g_signal_connect (G_OBJECT (stbw_button), "released", G_CALLBACK (step_button_released_cb), NULL); + g_signal_connect (G_OBJECT (stfw_button), "pressed", G_CALLBACK (step_button_pressed_cb), (gpointer) TRUE); + g_signal_connect (G_OBJECT (stfw_button), "clicked", G_CALLBACK (step_button_clicked_cb), (gpointer) TRUE); + g_signal_connect (G_OBJECT (stfw_button), "released", G_CALLBACK (step_button_released_cb), NULL); + g_signal_connect (G_OBJECT (scfw_button), "clicked", G_CALLBACK (scfw_button_clicked_cb), NULL); + g_signal_connect (G_OBJECT (volume_button), "value-changed", G_CALLBACK (volume_value_changed_cb), NULL); + g_signal_connect (G_OBJECT (rec_button), "clicked", G_CALLBACK (rec_button_clicked_cb), (gpointer) app); + g_signal_connect (G_OBJECT (prefs_button), "clicked", G_CALLBACK (prefs_button_clicked_cb), (gpointer) app); + g_signal_connect (G_OBJECT (about_button), "clicked", G_CALLBACK (about_button_clicked_cb), NULL); +/* g_signal_connect (G_OBJECT (quit_button), "clicked", G_CALLBACK (quit_button_clicked_cb), NULL); */ + + gtk_widget_set_tooltip_text (scbw_button, _("Scan Backwards")); + gtk_widget_set_tooltip_text (stbw_button, _("0.05 MHz Backwards")); + gtk_widget_set_tooltip_text (stfw_button, _("0.05 MHz Forwards")); + gtk_widget_set_tooltip_text (scfw_button, _("Scan Forwards")); + gtk_widget_set_tooltip_text (volume_button, _("Adjust the Volume")); + gtk_widget_set_tooltip_text (rec_button, _("Record radio as MP3, OGG, FLAC or M4A")); + gtk_widget_set_tooltip_text (prefs_button, _("Preferences")); + gtk_widget_set_tooltip_text (about_button, _("About Gnomeradio")); +/* gtk_widget_set_tooltip_text (quit_button, _("Quit")); */ + + text = g_strdup_printf (_("Frequency: %.2f MHz"), gtk_adjustment_get_value (adj)/STEPS); + gtk_widget_set_tooltip_text (freq_scale, text); + g_free (text); + + gtk_container_add (GTK_CONTAINER (app), vbox); + gtk_widget_show_all (vbox); + + return app; +} + +static void +session_die_cb(void) +{ + if (settings.mute_on_exit) + radio_stop(); + + mixer->close_device(); + gtk_main_quit(); + exit (0); +} + +/* +static void +save_session_cb(gint phase, GnomeSaveStyle save_style, + gint is_shutdown, GnomeInteractStyle interact_style, + gint is_fast, gpointer client_data) +{ + save_settings(); +} +*/ + +static void +gconf_error_handler(GConfClient *client, GError *error) +{ + g_print("GConf error: %s\n", error->message); +} + +gboolean +key_press_event_cb(GtkWidget *app, GdkEventKey *event, gpointer data) +{ + int vol = (int)(gtk_volume_button_get_value(volume_button) + 0.5f); + + switch (event->keyval) + { + case GDK_KEY_F1: display_help_cb(NULL); + break; + case GDK_KEY_m: + toggle_volume(); + break; + case GDK_KEY_q: + exit_gnome_radio(); + break; + case GDK_KEY_r: + rec_button_clicked_cb(NULL, app); + break; + case GDK_KEY_s: + stop_rec_button_clicked_cb(NULL, data); + break; + case GDK_KEY_f: + scfw_button_clicked_cb(NULL, NULL); + break; + case GDK_KEY_b: + scbw_button_clicked_cb(NULL, NULL); + break; + case GDK_KEY_n: + change_preset(TRUE); + break; + case GDK_KEY_p: + change_preset(FALSE); + break; + case GDK_KEY_KP_Add: + case GDK_KEY_plus: + gtk_volume_button_set_value(volume_button, vol > 95 ? 100 : vol + 5); + /*gtk_adjustment_set_value(volume, (volume->value > 95) ? 100 : volume->value+5);*/ + break; + case GDK_KEY_minus: + case GDK_KEY_KP_Subtract: + gtk_volume_button_set_value(volume_button, vol < 5 ? 0 : vol - 5); + /*gtk_adjustment_set_value(volume,(volume->value < 5) ? 0 : volume->value-5);*/ + break; + } + return FALSE; +} + +enum +{ + ARG_ALSA_LOOPBACK, + ARG_ALSA_CAPTURE, + ARG_ALSA_PLAYBACK, + ARG_ALSA_LATENCY, + ARG_ALSA_DEBUG +}; + +static gboolean +parse_one_option (gint opt, const gchar * arg, GError ** err) +{ + switch (opt) { + case ARG_ALSA_LOOPBACK: + alsa_loopback = 1; + break; + case ARG_ALSA_CAPTURE: + if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { + alsa_capture = g_strdup (arg); + break; + } else { + g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, + _("Invalid argument name '%s'. Example usage: --alsa-capture=hw:1,0"), arg); + return FALSE; + } + case ARG_ALSA_PLAYBACK: + if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { + alsa_playback = g_strdup (arg); + break; + } else { + g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, + _("Invalid argument name '%s'. Example usage: --alsa-playback=hw:0,0"), arg); + return FALSE; + } + case ARG_ALSA_LATENCY: + alsa_latency = atoi (arg); + break; + case ARG_ALSA_DEBUG: + alsa_debug = 1; + break; + default: + g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION, + _("Unknown option")); + return FALSE; + } + + return TRUE; +} + +static gboolean +option_alsa_cb (const gchar * opt, + const gchar * arg, gpointer data, GError ** err) +{ + static const struct + { + const gchar *opt; + int val; + } options[] = { + { + "--alsa-loopback", ARG_ALSA_LOOPBACK}, { + "--alsa-capture", ARG_ALSA_CAPTURE}, { + "--alsa-playback", ARG_ALSA_PLAYBACK}, { + "--alsa-latency", ARG_ALSA_LATENCY}, { + "--alsa-debug", ARG_ALSA_DEBUG}, { + NULL} + }; + gint val = 0, n; + + for (n = 0; options[n].opt; n++) { + if (!strcmp (opt, options[n].opt)) { + val = options[n].val; + break; + } + } + + return parse_one_option (val, arg, err); +} + +static GOptionGroup * +alsa_get_option_group (void) +{ + GOptionGroup *group; + + static const GOptionEntry alsa_args[] = { + { "alsa-loopback", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Enable loopback digital audio from radio device"), NULL }, + { "alsa-capture", '\0', 0, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Set an capture device for loopback digital audio (default: auto)"), N_("DEVICE") }, + { "alsa-playback", '\0', 0, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Set an playback device for loopback digital audio (default: default)"), N_("DEVICE") }, + { "alsa-latency", '\0', 0, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Set a latency for loopback digital audio in ms (default: 500)"), N_("TIME") }, + { "alsa-debug", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Enable debug output for loopback digital audio"), NULL }, + { NULL } + }; + + group = g_option_group_new ("alsa", _("Alsa Options"), + _("Show Alsa Options"), NULL, NULL); + g_option_group_add_entries (group, alsa_args); + + return group; +} + +G_GNUC_NORETURN static gboolean +option_version_cb (const gchar * opt, + const gchar * arg, gpointer data, GError ** err) +{ + g_print ("%s %s\n", PACKAGE, VERSION); + exit (0); +} + +int main(int argc, char* argv[]) +{ + GList *l; + DBusGProxy *proxy; + GError *err = NULL; + gboolean do_scan = FALSE; + GOptionContext *ctx; + const GOptionEntry entries[] = { + { "scan", '\0', 0, G_OPTION_ARG_NONE, &do_scan, N_("Scan for available stations"), NULL }, + { "version", 0, G_OPTION_FLAG_NO_ARG | G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_CALLBACK, option_version_cb, NULL, NULL }, + { NULL } + }; + + bindtextdomain(PACKAGE, GNOMELOCALEDIR); + bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); + textdomain(PACKAGE); + + g_set_application_name(_("Gnomeradio")); + g_setenv("PULSE_PROP_media.role", "production", TRUE); + + ctx = g_option_context_new("- Listen to FM radio"); + g_option_context_add_main_entries(ctx, entries, GETTEXT_PACKAGE); + g_option_context_add_group(ctx, alsa_get_option_group()); + g_option_context_add_group(ctx, gtk_get_option_group (TRUE)); + g_option_context_add_group(ctx, gst_init_get_option_group()); + if (g_option_context_parse(ctx, &argc, &argv, &err) == FALSE) { + g_print(_("%s\nRun '%s --help' to see a full list of available command line options.\n"), + err->message, argv[0]); + g_option_context_free(ctx); + g_error_free(err); + exit(1); + } + g_option_context_free(ctx); + + gtk_init(&argc, &argv); + gtk_window_set_default_icon_name("gnomeradio"); + /* Main app */ + main_visible = FALSE; + app = gnome_radio_gui(); + + /* Initizialize GStreamer */ + gst_init(&argc, &argv); + + rb_missing_plugins_init (GTK_WINDOW (app)); + + /* Initizialize Gconf */ + if (!gconf_init(argc, argv, &err)) { + char *details; + details = g_strdup_printf(_("%s\n\nChanges to the settings won't be saved."), err->message); + show_warning_message(_("Failed to init GConf!"), details); + g_error_free(err); + g_free(details); + err = NULL; + } else { + gconf_client_set_global_default_error_handler((GConfClientErrorHandlerFunc)gconf_error_handler); + gconf_client_set_error_handling(gconf_client_get_default(), GCONF_CLIENT_HANDLE_ALL); + } + + load_settings(); + + start_radio(FALSE, app); + start_mixer(FALSE, app); + if (is_first_start() || do_scan) { + if (!radio_is_init()) { + fprintf(stderr, "Could not scan. Radio is not initialized\n"); + } else { + initial_frequency_scan(app); + set_first_time_flag(); + } + } + create_tray_menu(app); + + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), _("manual")); + for (l = settings.presets; l; l = l->next) { + preset *ps = (preset*) l->data; + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), ps->title); + } + + preset_combo_set_item(mom_ps); + + gtk_widget_show_all(app); + main_visible = TRUE; + mode = PRESETS; + + /* Create an tray icon */ + create_tray_icon(app); + + adj_value_changed_cb(NULL, (gpointer) app); + /*volume_value_changed_cb(NULL, NULL);*/ + +#ifdef HAVE_LIRC + if(!my_lirc_init()) + { +/* GtkWidget *dialog; + dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, + _("Could not start lirc")); + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); +*/ + fprintf(stderr, "Could not start lirc\n"); + } + else + start_lirc(); +#endif + +/* Connect the Session Management signals + */ + + proxy = connect_to_session (); + g_signal_connect(G_OBJECT(app), "key-press-event", + G_CALLBACK(key_press_event_cb), NULL); + + /* Redraw the status window every 3 seconds + * Necessary, because the mono/stereo reception + * needs some time to be correctly detected + */ + g_timeout_add_seconds(3, (GSourceFunc)redraw_status_window, NULL); + + /* Checks if the volume has been changed by an + * external app + */ + /*gtk_timeout_add(100, (GSourceFunc)poll_volume_change, NULL);*/ + + gtk_main(); + +#ifdef HAVE_LIRC + my_lirc_deinit(); +#endif + + if (proxy) { + DBusGConnection *conn; + conn = (DBusGConnection *)g_object_get_data (G_OBJECT (proxy), "connection"); + if (conn) + dbus_g_connection_unref (conn); + + g_object_unref (proxy); + } + + return 0; +} + +static DBusGProxy * connect_to_session (void) +{ + DBusGConnection *connection; + DBusGProxy *proxy; + GError *error = NULL; + + connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); + + if (error) { + g_warning ("Could not connect to system bus: %s", error->message); + g_error_free(error); + return NULL; + } + /* Get the current session object */ + proxy = dbus_g_proxy_new_for_name (connection, + "org.gnome.SessionManager", + "/org/gnome/SessionManager", + "org.gnome.SessionManager"); + + if (!proxy) { + g_warning ("Unable to get the SessionManager."); + dbus_g_connection_unref (connection); + return NULL; + } + + dbus_g_proxy_add_signal (proxy, "SessionOver", G_TYPE_INVALID, G_TYPE_INVALID); + dbus_g_proxy_connect_signal (proxy, "SessionOver", G_CALLBACK (session_die_cb), NULL, NULL); + + g_object_set_data (G_OBJECT (proxy), "connection", connection); + return proxy; +} + +static void show_message(GtkMessageType type, const char* text, const char* details) +{ + GtkWidget *dialog; + + g_assert(text); + + dialog = gtk_message_dialog_new (NULL, DIALOG_FLAGS, type, GTK_BUTTONS_CLOSE, + "%s", text); + if (details) { + gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", details); + } + gtk_dialog_run(GTK_DIALOG (dialog)); + gtk_widget_destroy(dialog); +} + +void show_error_message(const char* error, const char* details) +{ + show_message(GTK_MESSAGE_ERROR, error, details); +} + +void show_warning_message(const char* warning, const char* details) +{ + show_message(GTK_MESSAGE_WARNING, warning, details); +} === removed file '.pc/gnomeradio-tray_menu.patch/src/gui.c' --- .pc/gnomeradio-tray_menu.patch/src/gui.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/gui.c 1970-01-01 00:00:00 +0000 @@ -1,1563 +0,0 @@ -/* gui.c - * - * Copyright (C) 2001 Jörgen Scheibengruber - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA - */ - -/*** the gui to gnomeradio */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include "gui.h" -#include "trayicon.h" -#include "mixer.h" -#include "radio.h" -#include "rec_tech.h" -#include "lirc.h" -#include "prefs.h" -#include "record.h" -#include "alsa_stream.h" -#include "rb_gst_media_types.h" -#include "rb_missing_plugins.h" - -#include "../data/pixmaps/digits.xpm" -#include "../data/pixmaps/signal.xpm" -#include "../data/pixmaps/stereo.xpm" -#include "../data/pixmaps/freq_up.xpm" -#include "../data/pixmaps/freq_down.xpm" - -#define DIGIT_WIDTH 20 -#define DIGIT_HEIGTH 30 -#define SIGNAL_WIDTH 25 -#define STEREO_WIDTH 35 -#define SCAN_SPEED 20 - -#define TRANSLATORS "TRANSLATORS" - -/* Latency is not a big problem for radio (no video to sync with), and - USB radio devices benefit from a larger default latency */ -#define DEFAULT_LATENCY 500 - -int autodetect; - -int alsa_loopback = 0; -char *alsa_playback = NULL; -char *alsa_capture = NULL; -int alsa_latency = DEFAULT_LATENCY; -int alsa_debug = 0; - -int mom_ps; -gnomeradio_settings settings; - -gboolean main_visible; - -GtkWidget *app; -GtkWidget *preset_combo; -GtkAdjustment *adj; -GtkWidget *volume_button; - -static GtkWidget *drawing_area; -static GdkPixbuf *digits; -static GdkPixbuf *signal_s; -static GdkPixbuf *stereo; -static GtkWidget *freq_scale; -static GtkWidget *scbw_button; -static GtkWidget *stbw_button; -static GtkWidget *stfw_button; -static GtkWidget *scfw_button; -static GtkWidget *rec_button; -static GtkWidget *prefs_button; - -static int timeout_id; -static int bp_timeout_id = -1; -static int bp_timeout_steps = 0; -static gint mode; - -static DBusGProxy * connect_to_session (void); - -static gboolean is_first_start(void) -{ - GConfClient *client = gconf_client_get_default(); - if (!client) - return TRUE; - - return !gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL); -} - -static void set_first_time_flag(void) -{ - GConfClient *client = gconf_client_get_default(); - if (!client) - return; - - gconf_client_set_bool(client, "/apps/gnomeradio/first_time_flag", TRUE, NULL); -} - -typedef struct { - GtkWidget *dialog; - GtkWidget *progress; - GList *stations; - GtkWidget *label; -} FreqScanData; - -static gboolean initial_frequency_scan_cb(gpointer data) -{ - static gfloat freq = FREQ_MIN - 4.0f/STEPS; - FreqScanData *fsd = data; - - g_assert(fsd); - - if (freq > FREQ_MAX) { - gtk_widget_destroy(fsd->dialog); - timeout_id = 0; - return FALSE; - } - - if (radio_check_station(freq)) { - char *text = g_strdup_printf(ngettext("%d station found", - "%d stations found", - g_list_length(fsd->stations) + 1), - g_list_length(fsd->stations) + 1); - - gfloat *f = g_malloc(sizeof(gfloat)); - gtk_label_set_text(GTK_LABEL(fsd->label), text); - g_free(text); - - g_print("Found a station at %.2f MHz\n", freq); - - *f = freq; - fsd->stations = g_list_append(fsd->stations, f); - } - - gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(fsd->progress), MAX(0, (freq - FREQ_MIN)/(FREQ_MAX - FREQ_MIN))); - - freq += 1.0/STEPS; - radio_set_freq(freq); - - return TRUE; -} - -static void initial_frequency_scan(GtkWidget *app) -{ - FreqScanData data; - GtkWidget *content_area; - GtkWidget *label; - gchar *markup; - - data.stations = NULL; - - data.dialog = gtk_dialog_new_with_buttons (_("Scanning"), GTK_WINDOW (app), DIALOG_FLAGS, - _("_Cancel"), GTK_RESPONSE_CANCEL, - NULL); - /* gtk_dialog_set_has_separator(GTK_DIALOG(data.dialog), FALSE); */ - gtk_window_set_resizable(GTK_WINDOW(data.dialog), FALSE); - - content_area = gtk_dialog_get_content_area (GTK_DIALOG (data.dialog)); - - label = gtk_label_new (NULL); - gtk_widget_set_halign (label, GTK_ALIGN_START); - markup = g_strdup_printf ("%s", _("Scanning for available stations:")); - gtk_label_set_markup (GTK_LABEL (label), markup); - g_free (markup); - gtk_box_pack_start (GTK_BOX (content_area), label, FALSE, FALSE, 6); - - data.progress = gtk_progress_bar_new (); - gtk_box_pack_start (GTK_BOX (content_area), data.progress, TRUE, FALSE, 6); - - data.label = gtk_label_new (_("No stations found")); - gtk_widget_set_halign (data.label, GTK_ALIGN_START); - gtk_box_pack_start (GTK_BOX (content_area), data.label, TRUE, FALSE, 6); - - gtk_widget_show_all(data.dialog); - - radio_mute(); - timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)initial_frequency_scan_cb, (gpointer)&data); - gtk_dialog_run(GTK_DIALOG(data.dialog)); - - radio_unmute(); - if (timeout_id) { - g_source_remove(timeout_id); - timeout_id = 0; - gtk_widget_destroy(data.dialog); - } else { - if (data.stations != NULL) { - gfloat f = *((gfloat*)data.stations->data); - gtk_adjustment_set_value(adj, f*STEPS); - radio_set_freq(f); - - GtkWidget *dialog; - GList *l; - - char *text = g_strdup_printf (ngettext ("%d station found.\n" - "Do you want to add it as preset?", - "%d stations found.\n" - "Do you want to add them as presets?", g_list_length (data.stations)), - g_list_length (data.stations)); - - dialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_QUESTION, - GTK_BUTTONS_YES_NO, "%s", text); - g_free(text); - - int response = gtk_dialog_run(GTK_DIALOG(dialog)); - gtk_widget_destroy(dialog); - - for (l = data.stations; l; l = l->next) { - if (response == GTK_RESPONSE_YES) { - preset *ps = g_malloc0(sizeof(preset)); - ps->title = g_strdup(_("unnamed")); - ps->freq = *((gfloat*) l->data); - settings.presets = g_list_prepend(settings.presets, ps); - } - g_free (l->data); - } - settings.presets = g_list_reverse(settings.presets); - } - } -} - -int gtk_volume_button_get_value (GtkWidget *button) -{ - return (int) (gtk_scale_button_get_value(GTK_SCALE_BUTTON(button)) * 100); -} - -void gtk_volume_button_set_value (GtkWidget *button, int value) -{ - gtk_scale_button_set_value(GTK_SCALE_BUTTON(button), (gdouble) value / 100); -} - -static void prefs_button_clicked_cb(GtkButton *button, gpointer app) -{ - GtkWidget* dialog; - gint choise; - - dialog = prefs_window(app); - - /* Michael Jochum proposed to not use gnome_dialog_set_parent() - but following instead. */ - gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(app)); - gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); - - /*gnome_dialog_set_parent(GNOME_DIALOG(dialog), GTK_WINDOW(app));*/ - - action_mode (mode); - - choise = GTK_RESPONSE_HELP; - while (choise == GTK_RESPONSE_HELP) - { - choise = gtk_dialog_run(GTK_DIALOG(dialog)); - switch (choise) - { - case GTK_RESPONSE_HELP: - display_help_cb("gnomeradio-settings"); - break; - default: - /* We need the hide signal to get the value of the device[mixer]_entry */ - gtk_widget_hide(dialog); - gtk_widget_destroy(dialog); - } - } -} - -void start_radio(gboolean restart, GtkWidget *app) -{ - DriverType driver = DRIVER_ANY; - if (restart) - radio_stop(); - - if (settings.driver) { - if (0 == strcmp(settings.driver, "v4l1")) - driver = DRIVER_V4L1; - if (0 == strcmp(settings.driver, "v4l2")) - driver = DRIVER_V4L2; - } - - autodetect = 0; - if (0 == strcmp(settings.device, "auto")) - autodetect = 1; - - if (settings.audio_loopback) { - if (0 == strcmp(settings.device, "")) - autodetect = 1; - alsa_loopback = 1; - } - - if (!radio_init(settings.device, driver)) { - char *caption, *detail; - - if (autodetect) { - caption = g_strdup_printf (_("Could not find any radio device!")); - detail = g_strdup_printf (_("Please ensure that you have a radio device connected to your computer.\n" - "You can also use the dmesg command: \"dmesg | grep radio\" to determine\n" - "whether device is properly detected.")); - } else { - caption = g_strdup_printf (_("Could not open radio device \"%s\"!"), settings.device); - detail = g_strdup_printf (_("You can auto detect radio device by typing \"auto\" in device settings.")); - } - - show_error_message(caption, detail); - g_free(caption); - g_free(detail); - - if (!restart) { - mode = RADIO_DEVICE; - prefs_button_clicked_cb(NULL, app); - mode = PRESETS; - } - } -} - -void start_mixer(gboolean restart, GtkWidget *app) -{ - gint vol; - - if (restart) - mixer->close_device(); - - if (!mixer_set_device(settings.mixer)) { - char *caption, *detail; - - caption = g_strdup_printf (_("Could not open mixer device and channel \"%s\"!"), settings.mixer); - detail = g_strdup_printf (_("You can use alsamixer to get information about sound device.\n" - "The format to set mixer to use: \"device/channel\" (e.g. hw:0/Line).")); - - show_error_message(caption, detail); - g_free(caption); - g_free(detail); - - gtk_widget_set_sensitive(volume_button, FALSE); - - if (!restart) { - mode = MIXER_DEVICE; - prefs_button_clicked_cb(NULL, app); - mode = PRESETS; - } - - } else { - vol = mixer->get_volume(); - if (vol >= 0) - gtk_volume_button_set_value(volume_button, vol); - gtk_widget_set_sensitive(volume_button, TRUE); - } -} - -static gboolean redraw_status_window(void) -{ - - GdkWindow *real_window; - cairo_t *cr; - int win_width; - int val, freq[5], signal_strength, is_stereo; - - val = (int)(rint(gtk_adjustment_get_value(adj)/STEPS * 100.0)); - - freq[0] = val / 10000; - freq[1] = (val % 10000) / 1000; - freq[2] = (val % 1000) / 100; - freq[3] = (val % 100) / 10; - freq[4] = val % 10; - - signal_strength = radio_get_signal(); - is_stereo = radio_get_stereo(); - - if (signal_strength > 3) signal_strength = 3; - if (signal_strength < 0) signal_strength = 0; - is_stereo = (is_stereo == 1) ? 1 : 0; - - real_window = gtk_widget_get_window(drawing_area); - if (real_window == NULL) - /* UI has not been realized yet */ - return TRUE; - /* gdk_drawable_get_size(real_window, &win_width, &win_height); */ - win_width = gdk_window_get_width (real_window); - - /* use doublebuffering to avoid flickering */ - /* window = gdk_pixmap_new(real_window, win_width, win_height, -1); */ - - cr = gdk_cairo_create (real_window); - cairo_set_source_rgb (cr, 0, 0, 0); - cairo_paint (cr); - - win_width -= 5; - - if (freq[0]) { - /* gdk_draw_drawable(window, gc, digits, freq[0] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*6 - freq[0] * DIGIT_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH); - cairo_fill (cr); - } else { - cairo_rectangle(cr, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH); - cairo_fill (cr); - } - - /* gdk_draw_drawable(window, gc, digits, freq[1] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*5, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*5 - freq[1] * DIGIT_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*5, 5, DIGIT_WIDTH, DIGIT_HEIGTH); - cairo_fill(cr); - /* gdk_draw_drawable(window, gc, digits, freq[2] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*4, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*4 - freq[2] * DIGIT_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*4, 5, DIGIT_WIDTH, DIGIT_HEIGTH); - cairo_fill(cr); - /* gdk_draw_drawable(window, gc, digits, 10 * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*3, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*3 - 10 * DIGIT_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*3, 5, DIGIT_WIDTH, DIGIT_HEIGTH); - cairo_fill(cr); - /* gdk_draw_drawable(window, gc, digits, freq[3] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*2, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*2 - freq[3] * DIGIT_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*2, 5, DIGIT_WIDTH, DIGIT_HEIGTH); - cairo_fill(cr); - /* gdk_draw_drawable(window, gc, digits, freq[4] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*1, 5, DIGIT_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, digits, win_width - DIGIT_WIDTH*1 - freq[4] * DIGIT_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*1, 5, DIGIT_WIDTH, DIGIT_HEIGTH); - cairo_fill(cr); - /* gdk_draw_drawable(window, gc, signal_s, signal_strength * SIGNAL_WIDTH, 0, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH, 5, SIGNAL_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, signal_s, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH - signal_strength * SIGNAL_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH, 5, SIGNAL_WIDTH, DIGIT_HEIGTH); - cairo_fill(cr); - /* gdk_draw_drawable(window, gc, stereo, is_stereo * STEREO_WIDTH, 0, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH, 5, STEREO_WIDTH, DIGIT_HEIGTH); */ - gdk_cairo_set_source_pixbuf (cr, stereo, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH - is_stereo * STEREO_WIDTH, 5); - cairo_rectangle (cr, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH, 5, STEREO_WIDTH, DIGIT_HEIGTH); - cairo_fill(cr); - - /* draw the pixmap to the real window */ - /* gdk_draw_drawable(real_window, gc, window, 0, 0, 0, 0, win_width + 5, win_height); */ - - cairo_destroy (cr); - /* g_object_unref(G_OBJECT(window)); */ - - return TRUE; -} - -static gboolean draw_cb(GtkWidget *widget, cairo_t *cr, gpointer data) -{ - redraw_status_window(); - return TRUE; -} - -void exit_gnome_radio(void) -{ - if (settings.mute_on_exit) - radio_stop(); - - mixer->close_device(); - save_settings(); - gtk_main_quit(); -} - -const char* get_preset(float freq, int *num) -{ - GList *node = settings.presets; - - int i = *num = -1; - for (;node;) - { - ++i; - preset *ps = (preset*)node->data; - if (fabs(ps->freq - freq) < 0.01) - { - *num = i; - return ps->title; - } - node = node->next; - } - return NULL; -} - -static void adj_value_changed_cb(GtkAdjustment* data, gpointer window) -{ - char *buffer; - float freq = rint(gtk_adjustment_get_value(adj))/STEPS; - const char *preset_title = get_preset(freq, &mom_ps); - - preset_combo_set_item(mom_ps); - - redraw_status_window(); - - if (preset_title) - buffer = g_strdup_printf(_("Gnomeradio - %s"), preset_title); - else - buffer = g_strdup_printf(_("Gnomeradio - %.2f MHz"), freq); - gtk_window_set_title(GTK_WINDOW(window), buffer); - if (tray_icon) gtk_status_icon_set_tooltip_text(GTK_STATUS_ICON(tray_icon), buffer); - g_free(buffer); - - buffer = g_strdup_printf(_("Frequency: %.2f MHz"), freq); - gtk_widget_set_tooltip_text(freq_scale, buffer); - g_free(buffer); - - radio_set_freq(gtk_adjustment_get_value(adj)/STEPS); -} - -static void volume_value_changed_cb(GtkVolumeButton *button, gpointer user_data) -{ - int vol = (int)(gtk_volume_button_get_value(volume_button) + 0.5f); - - mixer->set_volume(vol - mixer->get_volume()); - - if (tray_menu) { - g_signal_handler_block(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), vol == 0); - g_signal_handler_unblock(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id); - } -} - -#if 0 -static gboolean poll_volume_change(gpointer data) -{ - int vol; - if ((vol = mixer->get_volume()) < 0) - return FALSE; - - if (vol != (int)volume->value) - { - g_print("external volume change detected\n"); - gtk_adjustment_set_value(volume, (double)vol); - } - - return TRUE; -} -#endif - -static void change_frequency(gpointer data) -{ - gboolean increase = (gboolean) GPOINTER_TO_INT (data); - gint v = gtk_adjustment_get_value(adj); - - if (increase) - { - if (v >= FREQ_MAX*STEPS) - gtk_adjustment_set_value(adj, FREQ_MIN*STEPS); - else - gtk_adjustment_set_value(adj, v+1); - } - else - { - if (v <= FREQ_MIN*STEPS) - gtk_adjustment_set_value(adj, FREQ_MAX*STEPS); - else - gtk_adjustment_set_value(adj, v-1); - } -} - -static gboolean change_frequency_timeout(gpointer data) -{ - change_frequency(data); - if (bp_timeout_steps < 10) - { - g_source_remove(bp_timeout_id); - bp_timeout_id = g_timeout_add(200 - 20*bp_timeout_steps, - (GSourceFunc)change_frequency_timeout, data); - bp_timeout_steps++; - } - return TRUE; -} - -static void step_button_pressed_cb(GtkButton *button, gpointer data) -{ - bp_timeout_id = g_timeout_add(500, (GSourceFunc)change_frequency_timeout, data); -} - -static void step_button_clicked_cb(GtkButton *button, gpointer data) -{ - change_frequency(data); -} - -static void step_button_released_cb(GtkButton *button, gpointer data) -{ - if (bp_timeout_id > -1) - g_source_remove(bp_timeout_id); - bp_timeout_id = -1; - bp_timeout_steps = 0; -} - -static gboolean scan_freq(gpointer data) -{ - static gint start, mom, max; - gint dir = GPOINTER_TO_INT (data); - - if (!max) { - max = (FREQ_MAX - FREQ_MIN) * STEPS; - } - - if (radio_check_station(gtk_adjustment_get_value(adj)/STEPS) || (start > max)) { - start = mom = 0; - radio_unmute(); - timeout_id = 0; - return FALSE; - } - if (!mom) { - mom = gtk_adjustment_get_value(adj); - } - - if (mom > FREQ_MAX*STEPS) - mom = FREQ_MIN*STEPS; - else if (mom < FREQ_MIN*STEPS) - mom = FREQ_MAX*STEPS; - else - mom = mom + dir; - start += 1; - gtk_adjustment_set_value(adj, mom); - - return TRUE; -} - -void scfw_button_clicked_cb(GtkButton *button, gpointer data) -{ - if (timeout_id) { - g_source_remove(timeout_id); - timeout_id = 0; - radio_unmute(); - return; - } - radio_mute(); - timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)scan_freq, (gpointer)1); -} - -void scbw_button_clicked_cb(GtkButton *button, gpointer data) -{ - if (timeout_id) { - g_source_remove(timeout_id); - timeout_id = 0; - radio_unmute(); - return; - } - radio_mute(); - timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)scan_freq, (gpointer)(-1)); -} - -void preset_combo_set_item(gint i) -{ - if (i < -1) return; - if (preset_combo == NULL) return; - gtk_combo_box_set_active(GTK_COMBO_BOX(preset_combo), i + 1); -} - -static void preset_combo_change_cb(GtkWidget *combo, gpointer data) -{ - preset* ps; - mom_ps = gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) - 1; - - if (mom_ps < 0) return; - - ps = (preset*)g_list_nth_data(settings.presets, mom_ps); - gtk_adjustment_set_value(adj, ps->freq * STEPS); -} - -void change_preset(gboolean next) -{ - preset *ps; - int len = g_list_length(settings.presets); - if (len < 1) - return; - - if (next) - mom_ps = (mom_ps + 1) % len; - else - mom_ps = (mom_ps - 1 + len) % len; - - ps = g_list_nth_data(settings.presets, mom_ps); - gtk_adjustment_set_value(adj, ps->freq*STEPS); - preset_combo_set_item(mom_ps); -} - -void gnomeradio_switch_to_preset (gint index) -{ - if (0 <= index && index < g_list_length(settings.presets)) { - preset *ps = g_list_nth_data(settings.presets, index); - gtk_adjustment_set_value(adj, ps->freq*STEPS); - mom_ps = index; - preset_combo_set_item(mom_ps); - } -} - -static void quit_button_clicked_cb(GtkButton *button, gpointer data) -{ - exit_gnome_radio(); -} - -void tray_icon_items_set_sensible(gboolean sensible) -{ - GList* menuitems; - GtkWidget *menuitem; - int i, cnt = g_list_length(settings.presets); - - - menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); - - g_assert(cnt + 6 == g_list_length(menuitems)); - - /* Disable the presets */ - for (i = 0; i < cnt; i++) { - menuitem = g_list_nth_data(menuitems, i); - gtk_widget_set_sensitive(menuitem, sensible); - } - - /* Disable the mute button (separator => +1) */ - menuitem = g_list_nth_data(menuitems, cnt + 1); - gtk_widget_set_sensitive(menuitem, sensible); - - /* Disable the record button */ - menuitem = g_list_nth_data(menuitems, cnt + 2); - gtk_widget_set_sensitive(menuitem, sensible); - - /* Disable the quit button */ - menuitem = g_list_nth_data(menuitems, cnt + 5); - gtk_widget_set_sensitive(menuitem, sensible); -} - -void recording_set_sensible(gboolean sensible) -{ - /* Disable the presets */ - gtk_widget_set_sensitive(preset_combo, sensible); - - /* Disable the scan button */ - gtk_widget_set_sensitive(freq_scale, sensible); - gtk_widget_set_sensitive(scfw_button, sensible); - gtk_widget_set_sensitive(scbw_button, sensible); - gtk_widget_set_sensitive(stfw_button, sensible); - gtk_widget_set_sensitive(stbw_button, sensible); - - /* Disable the record button */ - gtk_widget_set_sensitive(rec_button, sensible); - - /* Disable the preferences button */ - gtk_widget_set_sensitive(prefs_button, sensible); -} - -static int start_recording(const gchar *destination, const char* station, const char* time) -{ - Recording* recording; - GFile *file; - GFileInfo *info; - gchar *caption, *detail; - - file = g_file_new_for_path (rec_settings.destination); - info = g_file_query_info (file, - G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, - G_FILE_QUERY_INFO_NONE, - NULL, - NULL); - - if (info != NULL) { - if (!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) { - caption = g_strdup_printf (_("Could not write file to \"%s\" location!"), rec_settings.destination); - detail = g_strdup_printf (_("Check your settings and make sure that you have write access to it.")); - show_error_message (caption, detail); - - g_free (caption); - g_free (detail); - - g_object_unref(info); - g_object_unref(file); - - return -1; - } - g_object_unref(info); - } - g_object_unref(file); - - if (rb_gst_check_missing_plugins (rb_gst_get_encoding_profile (rec_settings.profile), NULL, NULL)) { - gchar *extension, *format; - - extension = g_utf8_strup (rb_gst_media_type_to_extension (rec_settings.profile), -1); - format = g_strdup_printf ("%s", extension); - caption = g_strdup_printf (_("Could not write file in \"%s\" format!"), format); - detail = g_strdup_printf (_("You need to install additional software required to use this format.")); - show_error_message (caption, detail); - - g_free (extension); - g_free (format); - g_free (caption); - g_free (detail); - - return -1; - } - - /* You can translate the filename for a recording: - * args for this format are: path, station title, time - */ - char *filename = g_strdup_printf (_("%s/%s_%s"), destination, station, time); - recording = recording_start (filename); - g_free (filename); - - if (!recording) - return -1; - - tray_icon_items_set_sensible (FALSE); - recording_set_sensible (FALSE); - - recording->station = g_strdup (station); - record_status_window (recording); - - run_status_window (recording); - - return 1; -} - -void rec_button_clicked_cb(GtkButton *button, gpointer app) -{ - char *station; - char time_str[100]; - time_t t; - struct tm lt; - - t = time(NULL); - localtime_r(&t, <); - /* consult man strftime to translate this. This is a filename, so don't use "/" or ":", please */ - strftime(time_str, 100, _("%Y%m%d-%H%M%S"), <); - - if (mom_ps < 0) { - station = g_strdup_printf(_("%.2f MHz"), rint(gtk_adjustment_get_value(adj))/STEPS); - } else { - g_assert(mom_ps < g_list_length(settings.presets)); - preset* ps = g_list_nth_data(settings.presets, mom_ps); - g_assert(ps); - - station = g_strdup(ps->title); - } - -/* if (!check_filename(filename)) { - GtkWidget *errdialog; - errdialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - _("Error opening file '%s':\n%s"), filename, strerror(errno)); - gtk_dialog_run (GTK_DIALOG (errdialog)); - gtk_widget_destroy (errdialog); - } else */ - start_recording(rec_settings.destination, station, time_str); - g_free(station); -} - -void toggle_volume(void) -{ - static int old_vol; - int vol = mixer->get_volume(); - - if (vol) { - old_vol = vol; - vol = 0; - /* Stop/start the alsa stream on mute/unmute - * This fixes muting not working on cards without a mute control, or where - * the mute control does not work (such as on my card, where mute only influences - * the analog audio path and not the digital audio path used when streaming alsa - * sound) - */ - if (alsa_loopback) - alsa_thread_stop(); - } else { - vol = old_vol; - if (alsa_loopback) - alsa_thread_startup(alsa_playback, alsa_capture, - alsa_latency, stderr, alsa_debug); - } - mixer->set_volume(vol); - gtk_volume_button_set_value(volume_button, vol); - /*gtk_adjustment_set_value(volume, vol);*/ -} - -/* -static void volume_button_toggled_cb(GtkButton *button, gpointer data) -{ - if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(volume_button))) - { - gtk_widget_set_tooltip_text(volume_button, _("Unmute")); - } - else - { - gtk_widget_set_tooltip_text(volume_button, _("Mute")); - } - toggle_volume(); -} -*/ - -static char *get_license_text (void) -{ - const gchar *license[] = { - N_("Gnomeradio is free software; you can redistribute it and/or modify " - "it under the terms of the GNU General Public License as published by " - "the Free Software Foundation; either version 2 of the License, or " - "(at your option) any later version."), - N_("Gnomeradio is distributed in the hope that it will be useful, " - "but WITHOUT ANY WARRANTY; without even the implied warranty of " - "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the " - "GNU General Public License for more details."), - N_("You should have received a copy of the GNU General Public License " - "along with Gnomeradio; if not, write to the Free Software Foundation, " - "Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA") - }; - return g_strjoin ("\n\n", - _(license[0]), - _(license[1]), - _(license[2]), - NULL); -} - -static void about_button_clicked_cb(GtkButton *button, gpointer data) -{ - static GtkWidget *about; - const char *authors[] = {"J\xc3\xb6rgen Scheibengruber ", NULL}; - - /* Feel free to put your names here translators :-) */ - char *translators = _("TRANSLATORS"); - char *license = get_license_text (); - - if (about) - { - gtk_window_present (GTK_WINDOW (about)); - return; - } - - gtk_show_about_dialog (NULL, - "version", VERSION, - "copyright", _("Copyright \xc2\xa9 2001 - 2006 J\xc3\xb6rgen Scheibengruber"), - "comments", _("Listen to FM radio"), - "authors", authors, - "translator-credits", strcmp("TRANSLATORS", translators) ? translators : NULL, - "logo-icon-name", "gnomeradio", - "license", license, - "wrap-license", TRUE, - "website-label", _("Gnomeradio Website"), - "website", "http://www.gnome.org/projects/gnomeradio/", - NULL); - - g_free (license); - - /* about = gnome_about_new ("Gnomeradio", VERSION, "Copyright 2001 - 2006 Jörgen Scheibengruber", - text, (const char **) authors, NULL, - strcmp("TRANSLATORS", translators) ? translators : NULL, - app_icon); - - gtk_widget_show(about); - g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&about); - g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&app_icon); */ -} - -static gint delete_event_cb(GtkWidget* window, GdkEventAny* e, gpointer data) -{ - exit_gnome_radio(); - return TRUE; -} - -void display_help_cb(char *topic) -{ - GError *error = NULL; - - char *uri; - - if (topic) - uri = g_strdup_printf ("help:gnomeradio/%s", topic); - else - uri = g_strdup ("help:gnomeradio"); - - gtk_show_uri (NULL, uri, GDK_CURRENT_TIME, &error); - - if (error) - { - GtkWidget *dialog; - dialog = gtk_message_dialog_new (NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - _("Failed to open %s: %s"), uri, error->message); - gtk_dialog_run (GTK_DIALOG (dialog)); - gtk_widget_destroy (dialog); - g_error_free (error); - error = NULL; - } - - g_free (uri); -} - -void toggle_mainwindow_visibility(GtkWidget *app) -{ - static gint posx, posy; - if (gtk_widget_get_visible(app)) - { - gtk_window_get_position(GTK_WINDOW(app), &posx, &posy); - gtk_widget_hide(app); - } - else - { - if ((posx >= 0) && (posy >= 0)) - gtk_window_move(GTK_WINDOW(app), posx, posy); - gtk_window_present(GTK_WINDOW(app)); - } -} - -GtkWidget* gnome_radio_gui(void) -{ - GtkWidget *app; - GtkWidget *vbox; - GtkWidget *box; - GtkWidget *frame; - GtkWidget *menubox; - GtkWidget *label; - GtkWidget *pixmap; - GdkPixbuf *pixbuf; - GtkWidget *vseparator; - GtkWidget *about_button; -/* GtkWidget *quit_button; */ - GtkWidget *image; - gchar *text; - gboolean rtl; - - app = gtk_window_new(GTK_WINDOW_TOPLEVEL); - gtk_window_set_resizable(GTK_WINDOW(app), FALSE); - gtk_window_set_wmclass(GTK_WINDOW(app), "gnomeradio", "Gnomeradio"); - - gtk_widget_realize (app); - gtk_widget_get_window (app); - - vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); - gtk_container_set_border_width (GTK_CONTAINER(vbox), 3); - - box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - - frame = gtk_frame_new (NULL); - gtk_frame_set_shadow_type (GTK_FRAME(frame), GTK_SHADOW_IN); - gtk_container_set_border_width (GTK_CONTAINER (frame), 2); - - drawing_area = gtk_drawing_area_new(); - gtk_widget_set_size_request(drawing_area, DIGIT_WIDTH*6+10+SIGNAL_WIDTH+STEREO_WIDTH, DIGIT_HEIGTH+10); - - gtk_container_add (GTK_CONTAINER (frame), drawing_area); - - digits = gdk_pixbuf_new_from_xpm_data ((const char**) digits_xpm); - signal_s = gdk_pixbuf_new_from_xpm_data ((const char**) signal_xpm); - stereo = gdk_pixbuf_new_from_xpm_data ((const char**) stereo_xpm); - - menubox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); - - label = gtk_label_new (_("Presets:")); - - preset_combo = gtk_combo_box_text_new (); - gtk_widget_set_size_request (preset_combo, 10, -1); - - gtk_box_pack_start (GTK_BOX (box), frame, FALSE, FALSE, 3); - gtk_box_pack_start (GTK_BOX (box), menubox, TRUE, TRUE, 3); - gtk_box_pack_start (GTK_BOX (menubox), label, TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX (menubox), preset_combo, TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 4); - - box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - - pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**) freq_down_xpm); - pixmap = gtk_image_new_from_pixbuf (pixbuf); - - gtk_box_pack_start (GTK_BOX(box), pixmap, FALSE, FALSE, 2); - - adj = GTK_ADJUSTMENT (gtk_adjustment_new (SUNSHINE*STEPS, FREQ_MIN*STEPS, FREQ_MAX*STEPS+1, 1, STEPS, 1)); - freq_scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, adj); - gtk_scale_set_digits (GTK_SCALE (freq_scale), 0); - gtk_scale_set_draw_value (GTK_SCALE (freq_scale), FALSE); - - gtk_box_pack_start (GTK_BOX(box), freq_scale, TRUE, TRUE, 0); - - pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**) freq_up_xpm); - pixmap = gtk_image_new_from_pixbuf (pixbuf); - - gtk_box_pack_start (GTK_BOX (box), pixmap, FALSE, FALSE, 2); - gtk_box_pack_start (GTK_BOX (vbox), box, TRUE, TRUE, 2); - - box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - - rtl = gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL; - - scbw_button = gtk_button_new (); - image = gtk_image_new_from_icon_name (rtl ? "media-seek-backward-rtl" : "media-seek-backward", - GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (scbw_button), image); - - gtk_box_pack_start (GTK_BOX (box), scbw_button, FALSE, FALSE, 2); - - stbw_button = gtk_button_new (); - image = gtk_image_new_from_icon_name (rtl ? "media-skip-backward-rtl" : "media-skip-backward", - GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (stbw_button), image); - - gtk_box_pack_start (GTK_BOX (box), stbw_button, FALSE, FALSE, 2); - - stfw_button = gtk_button_new (); - image = gtk_image_new_from_icon_name (rtl ? "media-skip-forward-rtl" : "media-skip-forward", - GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (stfw_button), image); - - gtk_box_pack_start (GTK_BOX (box), stfw_button, FALSE, FALSE, 2); - - scfw_button = gtk_button_new (); - image = gtk_image_new_from_icon_name (rtl ? "media-seek-forward-rtl" : "media-seek-forward", - GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (scfw_button), image); - - gtk_box_pack_start (GTK_BOX (box), scfw_button, FALSE, FALSE, 2); - - vseparator = gtk_separator_new (GTK_ORIENTATION_VERTICAL); - - gtk_box_pack_start (GTK_BOX (box), vseparator, FALSE, FALSE, 2); - - volume_button = gtk_volume_button_new(); - gtk_button_set_relief(GTK_BUTTON(volume_button), GTK_RELIEF_NORMAL); - gtk_widget_set_sensitive(volume_button, FALSE); - - gtk_box_pack_start (GTK_BOX (box), volume_button, FALSE, FALSE, 2); - - rec_button = gtk_button_new (); - image = gtk_image_new_from_icon_name ("media-record", GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (rec_button), image); - - gtk_box_pack_start (GTK_BOX (box), rec_button, FALSE, FALSE, 2); - - vseparator = gtk_separator_new (GTK_ORIENTATION_VERTICAL); - - gtk_box_pack_start (GTK_BOX (box), vseparator, FALSE, FALSE, 2); - - prefs_button = gtk_button_new (); - image = gtk_image_new_from_icon_name ("document-properties", GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (prefs_button), image); - - gtk_box_pack_start (GTK_BOX (box), prefs_button, FALSE, FALSE, 2); - - about_button = gtk_button_new (); - image = gtk_image_new_from_icon_name ("help-about", GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (about_button), image); - - gtk_box_pack_start (GTK_BOX (box), about_button, FALSE, FALSE, 2); - -/* quit_button = gtk_button_new (); - image = gtk_image_new_from_icon_name ("application-exit", GTK_ICON_SIZE_LARGE_TOOLBAR); - gtk_button_set_image (GTK_BUTTON (quit_button), image); - gtk_box_pack_start (GTK_BOX (box), quit_button, FALSE, FALSE, 2); */ - - gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 4); - - g_signal_connect (G_OBJECT (app), "delete_event", G_CALLBACK (delete_event_cb), NULL); - g_signal_connect (G_OBJECT (drawing_area), "draw", G_CALLBACK (draw_cb), NULL); - g_signal_connect (G_OBJECT (preset_combo), "changed", G_CALLBACK (preset_combo_change_cb), NULL); - g_signal_connect (G_OBJECT (adj), "value-changed", G_CALLBACK (adj_value_changed_cb), (gpointer) app); - g_signal_connect (G_OBJECT (scbw_button), "clicked", G_CALLBACK (scbw_button_clicked_cb), NULL); - g_signal_connect (G_OBJECT (stbw_button), "pressed", G_CALLBACK (step_button_pressed_cb), (gpointer) FALSE); - g_signal_connect (G_OBJECT (stbw_button), "clicked", G_CALLBACK (step_button_clicked_cb), (gpointer) FALSE); - g_signal_connect (G_OBJECT (stbw_button), "released", G_CALLBACK (step_button_released_cb), NULL); - g_signal_connect (G_OBJECT (stfw_button), "pressed", G_CALLBACK (step_button_pressed_cb), (gpointer) TRUE); - g_signal_connect (G_OBJECT (stfw_button), "clicked", G_CALLBACK (step_button_clicked_cb), (gpointer) TRUE); - g_signal_connect (G_OBJECT (stfw_button), "released", G_CALLBACK (step_button_released_cb), NULL); - g_signal_connect (G_OBJECT (scfw_button), "clicked", G_CALLBACK (scfw_button_clicked_cb), NULL); - g_signal_connect (G_OBJECT (volume_button), "value-changed", G_CALLBACK (volume_value_changed_cb), NULL); - g_signal_connect (G_OBJECT (rec_button), "clicked", G_CALLBACK (rec_button_clicked_cb), (gpointer) app); - g_signal_connect (G_OBJECT (prefs_button), "clicked", G_CALLBACK (prefs_button_clicked_cb), (gpointer) app); - g_signal_connect (G_OBJECT (about_button), "clicked", G_CALLBACK (about_button_clicked_cb), NULL); -/* g_signal_connect (G_OBJECT (quit_button), "clicked", G_CALLBACK (quit_button_clicked_cb), NULL); */ - - gtk_widget_set_tooltip_text (scbw_button, _("Scan Backwards")); - gtk_widget_set_tooltip_text (stbw_button, _("0.05 MHz Backwards")); - gtk_widget_set_tooltip_text (stfw_button, _("0.05 MHz Forwards")); - gtk_widget_set_tooltip_text (scfw_button, _("Scan Forwards")); - gtk_widget_set_tooltip_text (volume_button, _("Adjust the Volume")); - gtk_widget_set_tooltip_text (rec_button, _("Record radio as MP3, OGG, FLAC or M4A")); - gtk_widget_set_tooltip_text (prefs_button, _("Preferences")); - gtk_widget_set_tooltip_text (about_button, _("About Gnomeradio")); -/* gtk_widget_set_tooltip_text (quit_button, _("Quit")); */ - - text = g_strdup_printf (_("Frequency: %.2f MHz"), gtk_adjustment_get_value (adj)/STEPS); - gtk_widget_set_tooltip_text (freq_scale, text); - g_free (text); - - gtk_container_add (GTK_CONTAINER (app), vbox); - gtk_widget_show_all (vbox); - - return app; -} - -static void -session_die_cb(void) -{ - if (settings.mute_on_exit) - radio_stop(); - - mixer->close_device(); - gtk_main_quit(); - exit (0); -} - -/* -static void -save_session_cb(gint phase, GnomeSaveStyle save_style, - gint is_shutdown, GnomeInteractStyle interact_style, - gint is_fast, gpointer client_data) -{ - save_settings(); -} -*/ - -static void -gconf_error_handler(GConfClient *client, GError *error) -{ - g_print("GConf error: %s\n", error->message); -} - -gboolean -key_press_event_cb(GtkWidget *app, GdkEventKey *event, gpointer data) -{ - int vol = (int)(gtk_volume_button_get_value(volume_button) + 0.5f); - - switch (event->keyval) - { - case GDK_KEY_F1: display_help_cb(NULL); - break; - case GDK_KEY_m: - toggle_volume(); - break; - case GDK_KEY_q: - exit_gnome_radio(); - break; - case GDK_KEY_r: - rec_button_clicked_cb(NULL, app); - break; - case GDK_KEY_s: - stop_rec_button_clicked_cb(NULL, data); - break; - case GDK_KEY_f: - scfw_button_clicked_cb(NULL, NULL); - break; - case GDK_KEY_b: - scbw_button_clicked_cb(NULL, NULL); - break; - case GDK_KEY_n: - change_preset(TRUE); - break; - case GDK_KEY_p: - change_preset(FALSE); - break; - case GDK_KEY_KP_Add: - case GDK_KEY_plus: - gtk_volume_button_set_value(volume_button, vol > 95 ? 100 : vol + 5); - /*gtk_adjustment_set_value(volume, (volume->value > 95) ? 100 : volume->value+5);*/ - break; - case GDK_KEY_minus: - case GDK_KEY_KP_Subtract: - gtk_volume_button_set_value(volume_button, vol < 5 ? 0 : vol - 5); - /*gtk_adjustment_set_value(volume,(volume->value < 5) ? 0 : volume->value-5);*/ - break; - } - return FALSE; -} - -enum -{ - ARG_ALSA_LOOPBACK, - ARG_ALSA_CAPTURE, - ARG_ALSA_PLAYBACK, - ARG_ALSA_LATENCY, - ARG_ALSA_DEBUG -}; - -static gboolean -parse_one_option (gint opt, const gchar * arg, GError ** err) -{ - switch (opt) { - case ARG_ALSA_LOOPBACK: - alsa_loopback = 1; - break; - case ARG_ALSA_CAPTURE: - if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); - break; - } else { - g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, - _("invalid argument name '%s', must be e.g. 'hw:1,0'"), arg); - return FALSE; - } - case ARG_ALSA_PLAYBACK: - if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); - break; - } else { - g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, - _("invalid argument name '%s', must be e.g. 'hw:0,0'"), arg); - return FALSE; - } - case ARG_ALSA_LATENCY: - alsa_latency = atoi (arg); - break; - case ARG_ALSA_DEBUG: - alsa_debug = 1; - break; - default: - g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION, - _("Unknown option")); - return FALSE; - } - - return TRUE; -} - -static gboolean -option_alsa_cb (const gchar * opt, - const gchar * arg, gpointer data, GError ** err) -{ - static const struct - { - const gchar *opt; - int val; - } options[] = { - { - "--alsa-loopback", ARG_ALSA_LOOPBACK}, { - "--alsa-capture", ARG_ALSA_CAPTURE}, { - "--alsa-playback", ARG_ALSA_PLAYBACK}, { - "--alsa-latency", ARG_ALSA_LATENCY}, { - "--alsa-debug", ARG_ALSA_DEBUG}, { - NULL} - }; - gint val = 0, n; - - for (n = 0; options[n].opt; n++) { - if (!strcmp (opt, options[n].opt)) { - val = options[n].val; - break; - } - } - - return parse_one_option (val, arg, err); -} - -static GOptionGroup * -alsa_get_option_group (void) -{ - GOptionGroup *group; - - static const GOptionEntry alsa_args[] = { - { "alsa-loopback", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Enable loopback digital audio from radio device"), NULL }, - { "alsa-capture", '\0', 0, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Set an capture device for loopback digital audio (default: auto)"), N_("DEVICE") }, - { "alsa-playback", '\0', 0, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Set an playback device for loopback digital audio (default: default)"), N_("DEVICE") }, - { "alsa-latency", '\0', 0, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Set a latency for loopback digital audio in ms (default: 500)"), N_("TIME") }, - { "alsa-debug", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, (gpointer) option_alsa_cb, N_("Enable debug output for loopback digital audio"), NULL }, - { NULL } - }; - - group = g_option_group_new ("alsa", _("Alsa Options"), - _("Show Alsa Options"), NULL, NULL); - g_option_group_add_entries (group, alsa_args); - - return group; -} - -G_GNUC_NORETURN static gboolean -option_version_cb (const gchar * opt, - const gchar * arg, gpointer data, GError ** err) -{ - g_print ("%s %s\n", PACKAGE, VERSION); - exit (0); -} - -int main(int argc, char* argv[]) -{ - GList *l; - DBusGProxy *proxy; - GError *err = NULL; - gboolean do_scan = FALSE; - GOptionContext *ctx; - const GOptionEntry entries[] = { - { "scan", '\0', 0, G_OPTION_ARG_NONE, &do_scan, N_("Scan for available stations"), NULL }, - { "version", 0, G_OPTION_FLAG_NO_ARG | G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_CALLBACK, option_version_cb, NULL, NULL }, - { NULL } - }; - - bindtextdomain(PACKAGE, GNOMELOCALEDIR); - bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); - textdomain(PACKAGE); - - g_set_application_name(_("Gnomeradio")); - g_setenv("PULSE_PROP_media.role", "production", TRUE); - - ctx = g_option_context_new("- Listen to FM radio"); - g_option_context_add_main_entries(ctx, entries, GETTEXT_PACKAGE); - g_option_context_add_group(ctx, alsa_get_option_group()); - g_option_context_add_group(ctx, gtk_get_option_group (TRUE)); - g_option_context_add_group(ctx, gst_init_get_option_group()); - if (g_option_context_parse(ctx, &argc, &argv, &err) == FALSE) { - g_print(_("%s\nRun '%s --help' to see a full list of available command line options.\n"), - err->message, argv[0]); - g_option_context_free(ctx); - g_error_free(err); - exit(1); - } - g_option_context_free(ctx); - - gtk_init(&argc, &argv); - gtk_window_set_default_icon_name("gnomeradio"); - /* Main app */ - main_visible = FALSE; - app = gnome_radio_gui(); - - /* Initizialize GStreamer */ - gst_init(&argc, &argv); - - rb_missing_plugins_init (GTK_WINDOW (app)); - - /* Initizialize Gconf */ - if (!gconf_init(argc, argv, &err)) { - char *details; - details = g_strdup_printf(_("%s\n\nChanges to the settings won't be saved."), err->message); - show_warning_message(_("Failed to init GConf!"), details); - g_error_free(err); - g_free(details); - err = NULL; - } else { - gconf_client_set_global_default_error_handler((GConfClientErrorHandlerFunc)gconf_error_handler); - gconf_client_set_error_handling(gconf_client_get_default(), GCONF_CLIENT_HANDLE_ALL); - } - - load_settings(); - - start_radio(FALSE, app); - start_mixer(FALSE, app); - if (is_first_start() || do_scan) { - if (!radio_is_init()) { - fprintf(stderr, "Could not scan. Radio is not initialized\n"); - } else { - initial_frequency_scan(app); - set_first_time_flag(); - } - } - create_tray_menu(app); - - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), _("manual")); - for (l = settings.presets; l; l = l->next) { - preset *ps = (preset*) l->data; - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), ps->title); - } - - preset_combo_set_item(mom_ps); - - gtk_widget_show_all(app); - main_visible = TRUE; - mode = PRESETS; - - /* Create an tray icon */ - create_tray_icon(app); - - adj_value_changed_cb(NULL, (gpointer) app); - /*volume_value_changed_cb(NULL, NULL);*/ - -#ifdef HAVE_LIRC - if(!my_lirc_init()) - { -/* GtkWidget *dialog; - dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, - _("Could not start lirc")); - gtk_dialog_run (GTK_DIALOG (dialog)); - gtk_widget_destroy (dialog); -*/ - fprintf(stderr, "Could not start lirc\n"); - } - else - start_lirc(); -#endif - -/* Connect the Session Management signals - */ - - proxy = connect_to_session (); - g_signal_connect(G_OBJECT(app), "key-press-event", - G_CALLBACK(key_press_event_cb), NULL); - - /* Redraw the status window every 3 seconds - * Necessary, because the mono/stereo reception - * needs some time to be correctly detected - */ - g_timeout_add_seconds(3, (GSourceFunc)redraw_status_window, NULL); - - /* Checks if the volume has been changed by an - * external app - */ - /*gtk_timeout_add(100, (GSourceFunc)poll_volume_change, NULL);*/ - - gtk_main(); - -#ifdef HAVE_LIRC - my_lirc_deinit(); -#endif - - if (proxy) { - DBusGConnection *conn; - conn = (DBusGConnection *)g_object_get_data (G_OBJECT (proxy), "connection"); - if (conn) - dbus_g_connection_unref (conn); - - g_object_unref (proxy); - } - - return 0; -} - -static DBusGProxy * connect_to_session (void) -{ - DBusGConnection *connection; - DBusGProxy *proxy; - GError *error = NULL; - - connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); - - if (error) { - g_warning ("Could not connect to system bus: %s", error->message); - g_error_free(error); - return NULL; - } - /* Get the current session object */ - proxy = dbus_g_proxy_new_for_name (connection, - "org.gnome.SessionManager", - "/org/gnome/SessionManager", - "org.gnome.SessionManager"); - - if (!proxy) { - g_warning ("Unable to get the SessionManager."); - dbus_g_connection_unref (connection); - return NULL; - } - - dbus_g_proxy_add_signal (proxy, "SessionOver", G_TYPE_INVALID, G_TYPE_INVALID); - dbus_g_proxy_connect_signal (proxy, "SessionOver", G_CALLBACK (session_die_cb), NULL, NULL); - - g_object_set_data (G_OBJECT (proxy), "connection", connection); - return proxy; -} - -static void show_message(GtkMessageType type, const char* text, const char* details) -{ - GtkWidget *dialog; - - g_assert(text); - - dialog = gtk_message_dialog_new (NULL, DIALOG_FLAGS, type, GTK_BUTTONS_CLOSE, - "%s", text); - if (details) { - gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), "%s", details); - } - gtk_dialog_run(GTK_DIALOG (dialog)); - gtk_widget_destroy(dialog); -} - -void show_error_message(const char* error, const char* details) -{ - show_message(GTK_MESSAGE_ERROR, error, details); -} - -void show_warning_message(const char* warning, const char* details) -{ - show_message(GTK_MESSAGE_WARNING, warning, details); -} === added file '.pc/gnomeradio-tray_menu.patch/src/gui.h' --- .pc/gnomeradio-tray_menu.patch/src/gui.h 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/gui.h 2013-10-03 19:38:23 +0000 @@ -0,0 +1,87 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef _GUI_H +#define _GUI_H + +#define FREQ_MAX 108 +#define FREQ_MIN 87.5 +#define STEPS 20 +#define SUNSHINE 106.15 + +#define DIALOG_FLAGS (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT) + +typedef struct Gnomeradio_Settings gnomeradio_settings; +typedef struct Preset preset; + +struct Gnomeradio_Settings +{ + gchar *device; + gchar *mixer; + gboolean audio_loopback; + gboolean mute_on_exit; + gchar *driver; + + GList *presets; +}; + +struct Preset +{ + gchar* title; + gfloat freq; +}; + +void start_radio(gboolean restart, GtkWidget *app); + +void start_mixer(gboolean restart, GtkWidget *app); + +void exit_gnome_radio(void); + +void scfw_button_clicked_cb(GtkButton *button, gpointer data); + +void scbw_button_clicked_cb(GtkButton *button, gpointer data); + +void rec_button_clicked_cb(GtkButton *button, gpointer app); + +int gtk_volume_button_get_value (GtkWidget *button); + +void gtk_volume_button_set_value (GtkWidget *button, int value); + +void toggle_volume(void); + +void toggle_mainwindow_visibility(GtkWidget *app); + +void preset_combo_set_item(gint i); + +void preset_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data); + +void tray_icon_items_set_sensible(gboolean sensible); + +gboolean +key_press_event_cb(GtkWidget *app, GdkEventKey *event, gpointer data); + +void recording_set_sensible(gboolean sensible); + +void display_help_cb(char *topic); + +void change_preset(gboolean next); + +void gnomeradio_switch_to_preset (gint index); + +void show_error_message(const char* error, const char* details); +void show_warning_message(const char* warning, const char* details); + +#endif === removed file '.pc/gnomeradio-tray_menu.patch/src/gui.h' --- .pc/gnomeradio-tray_menu.patch/src/gui.h 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/gui.h 1970-01-01 00:00:00 +0000 @@ -1,87 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Library General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#ifndef _GUI_H -#define _GUI_H - -#define FREQ_MAX 108 -#define FREQ_MIN 87.5 -#define STEPS 20 -#define SUNSHINE 106.15 - -#define DIALOG_FLAGS (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT) - -typedef struct Gnomeradio_Settings gnomeradio_settings; -typedef struct Preset preset; - -struct Gnomeradio_Settings -{ - gchar *device; - gchar *mixer; - gboolean audio_loopback; - gboolean mute_on_exit; - gchar *driver; - - GList *presets; -}; - -struct Preset -{ - gchar* title; - gfloat freq; -}; - -void start_radio(gboolean restart, GtkWidget *app); - -void start_mixer(gboolean restart, GtkWidget *app); - -void exit_gnome_radio(void); - -void scfw_button_clicked_cb(GtkButton *button, gpointer data); - -void scbw_button_clicked_cb(GtkButton *button, gpointer data); - -void rec_button_clicked_cb(GtkButton *button, gpointer app); - -int gtk_volume_button_get_value (GtkWidget *button); - -void gtk_volume_button_set_value (GtkWidget *button, int value); - -void toggle_volume(void); - -void toggle_mainwindow_visibility(GtkWidget *app); - -void preset_combo_set_item(gint i); - -void preset_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data); - -void tray_icon_items_set_sensible(gboolean sensible); - -gboolean -key_press_event_cb(GtkWidget *app, GdkEventKey *event, gpointer data); - -void recording_set_sensible(gboolean sensible); - -void display_help_cb(char *topic); - -void change_preset(gboolean next); - -void gnomeradio_switch_to_preset (gint index); - -void show_error_message(const char* error, const char* details); -void show_warning_message(const char* warning, const char* details); - -#endif === added file '.pc/gnomeradio-tray_menu.patch/src/prefs.c' --- .pc/gnomeradio-tray_menu.patch/src/prefs.c 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/prefs.c 2013-10-03 19:38:23 +0000 @@ -0,0 +1,1549 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "config.h" +#include "prefs.h" +#include "trayicon.h" +#include "gui.h" +#include "rec_tech.h" +#include "rb_gst_media_types.h" +#include "rb_missing_plugins.h" + +extern int autodetect; +extern int can_capture; +extern int alsa_loopback; + +extern GtkWidget *preset_combo; +extern GtkAdjustment *adj; + +extern int mom_ps; +extern gnomeradio_settings settings; + +extern gboolean main_visible; + +static GtkWidget *device_entry; +static GtkWidget *mixer_entry; +static GtkWidget *audio_box; +static GtkWidget *audio_switch; +static GtkWidget *mute_on_exit; +static GtkWidget *list_view; +static GtkListStore *list_store; +static GtkTreeSelection *selection; +static GtkWidget *save_button; +static GtkWidget *move_up_button; +static GtkWidget *move_down_button; +static GtkWidget *add_button; +static GtkWidget *remove_button; +static GtkWidget *audio_profile_combo; +static GtkWidget *install_button; + +gboolean save_settings(void) +{ + gint i, count; + gchar *buffer; + preset *ps; + GConfClient* client = NULL; + + if (!gconf_is_initialized()) + return FALSE; + + client = gconf_client_get_default(); + if (!client) + return FALSE; + + /* Store general settings */ + if (autodetect) + gconf_client_set_string(client, "/apps/gnomeradio/device", "auto", NULL); + else + gconf_client_set_string(client, "/apps/gnomeradio/device", settings.device, NULL); + gconf_client_set_string(client, "/apps/gnomeradio/driver", settings.driver, NULL); + gconf_client_set_string(client, "/apps/gnomeradio/mixer", settings.mixer, NULL); + gconf_client_set_bool(client, "/apps/gnomeradio/audio-loopback", settings.audio_loopback , NULL); + gconf_client_set_bool(client, "/apps/gnomeradio/mute-on-exit", settings.mute_on_exit, NULL); + /*gconf_client_set_float(client, "/apps/gnomeradio/volume", volume->value, NULL);*/ + gconf_client_set_float(client, "/apps/gnomeradio/last-freq", gtk_adjustment_get_value(adj)/STEPS, NULL); + + /* Store recording settings */ +/* gconf_client_set_string(client, "/apps/gnomeradio/recording/audiodevice", rec_settings.audiodevice, NULL); + gconf_client_set_bool(client, "/apps/gnomeradio/recording/record-as-mp3", rec_settings.mp3, NULL); + gconf_client_set_string(client, "/apps/gnomeradio/recording/sample-rate", rec_settings.rate, NULL); + gconf_client_set_string(client, "/apps/gnomeradio/recording/sample-format", rec_settings.sample, NULL); + gconf_client_set_bool(client, "/apps/gnomeradio/recording/record-in-stereo", rec_settings.stereo, NULL); + gconf_client_set_string(client, "/apps/gnomeradio/recording/encoder", rec_settings.encoder, NULL); + gconf_client_set_string(client, "/apps/gnomeradio/recording/bitrate", rec_settings.bitrate, NULL); +*/ + + gconf_client_set_string(client, "/apps/gnomeradio/recording/destination", rec_settings.destination, NULL); + gconf_client_set_string(client, "/apps/gnomeradio/recording/profile", rec_settings.profile, NULL); + + /* Store the presets */ + count = g_list_length(settings.presets); + gconf_client_set_int(client, "/apps/gnomeradio/presets/presets", count, NULL); + for (i = 0; i < count; i++) + { + ps = g_list_nth_data(settings.presets, i); + buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/name", i); + gconf_client_set_string(client, buffer, ps->title, NULL); + g_free(buffer); + buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/freqency", i); + gconf_client_set_float(client, buffer, ps->freq, NULL); + g_free(buffer); + } + gconf_client_set_int(client, "/apps/gnomeradio/presets/last", mom_ps, NULL); + /*g_print("Storing Settings in GConf database\n");*/ + + g_object_unref (client); + + return TRUE; +} + +gboolean load_settings(void) +{ + gint i, count; + gchar *buffer; + preset *ps; + GConfClient *client = NULL; + double freq; + + settings.presets = NULL; + + if (!gconf_is_initialized()) + return FALSE; + + client = gconf_client_get_default(); + if (!client) + return FALSE; + + /* Load general settings */ + settings.device = gconf_client_get_string(client, "/apps/gnomeradio/device", NULL); + if (!settings.device) + settings.device = g_strdup("auto"); + settings.driver = gconf_client_get_string(client, "/apps/gnomeradio/driver", NULL); + if (!settings.driver) + settings.driver = g_strdup("any"); + settings.mixer = gconf_client_get_string(client, "/apps/gnomeradio/mixer", NULL); + if (!settings.mixer) + settings.mixer = g_strdup("hw:0/Line"); + settings.audio_loopback = gconf_client_get_bool(client, "/apps/gnomeradio/audio-loopback", NULL); + settings.mute_on_exit = gconf_client_get_bool(client, "/apps/gnomeradio/mute-on-exit", NULL); + /*volume->value = gconf_client_get_float(client, "/apps/gnomeradio/volume", NULL);*/ + freq = gconf_client_get_float(client, "/apps/gnomeradio/last-freq", NULL); + if ((freq < FREQ_MIN) || (freq > FREQ_MAX)) + gtk_adjustment_set_value(adj, FREQ_MIN * STEPS); + else + gtk_adjustment_set_value(adj, freq * STEPS); + + /* Load recording settings */ +/* rec_settings.audiodevice = gconf_client_get_string(client, "/apps/gnomeradio/recording/audiodevice", NULL); + if (!rec_settings.audiodevice) + rec_settings.audiodevice = g_strdup("/dev/audio"); + rec_settings.mp3 = gconf_client_get_bool(client, "/apps/gnomeradio/recording/record-as-mp3", NULL); + rec_settings.rate = gconf_client_get_string(client, "/apps/gnomeradio/recording/sample-rate", NULL); + if (!rec_settings.rate) + rec_settings.rate = g_strdup("44100"); + rec_settings.sample = gconf_client_get_string(client, "/apps/gnomeradio/recording/sample-format", NULL); + if (!rec_settings.sample) + rec_settings.sample = g_strdup("16"); + rec_settings.stereo = gconf_client_get_bool(client, "/apps/gnomeradio/recording/record-in-stereo", NULL); + rec_settings.encoder = gconf_client_get_string(client, "/apps/gnomeradio/recording/encoder", NULL); + if (!rec_settings.encoder) + rec_settings.encoder = g_strdup("oggenc"); + rec_settings.bitrate = gconf_client_get_string(client, "/apps/gnomeradio/recording/bitrate", NULL); + if (!rec_settings.bitrate) + rec_settings.bitrate = g_strdup("192");*/ + + rec_settings.destination = gconf_client_get_string(client, "/apps/gnomeradio/recording/destination", NULL); + if (!rec_settings.destination) + rec_settings.destination = g_strdup(g_get_home_dir()); + rec_settings.profile = gconf_client_get_string(client, "/apps/gnomeradio/recording/profile", NULL); + if (!rec_settings.profile) + rec_settings.profile = g_strdup("audio/x-vorbis"); + + /* Load the presets */ + count = gconf_client_get_int(client, "/apps/gnomeradio/presets/presets", NULL); + for (i = 0; i < count; i++) + { + ps = malloc(sizeof(preset)); + buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/name", i); + ps->title = gconf_client_get_string(client, buffer, NULL); + g_free(buffer); + if (!ps->title) + ps->title = g_strdup(_("unnamed")); + buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/freqency", i); + freq = gconf_client_get_float(client, buffer, NULL); + if ((freq < FREQ_MIN) || (freq > FREQ_MAX)) + ps->freq = FREQ_MIN; + else + ps->freq = freq; + g_free(buffer); + settings.presets = g_list_prepend(settings.presets, (gpointer)ps); + } + settings.presets = g_list_reverse(settings.presets); + + mom_ps = gconf_client_get_int(client, "/apps/gnomeradio/presets/last", NULL); + if (mom_ps >= count) + mom_ps = -1; + + g_object_unref (client); + + return TRUE; +} + +static void mute_on_exit_toggled_cb(GtkWidget* widget, gpointer data) +{ + settings.mute_on_exit = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mute_on_exit)); +} + +gboolean audio_box_set_visible (gboolean visible) +{ + gtk_widget_hide (audio_box); + gtk_widget_set_no_show_all (audio_box, !visible); + if (visible) + gtk_widget_show_all (audio_box); +} + +static void audio_switch_activate_cb (GtkWidget* widget, gpointer data) +{ + settings.audio_loopback = gtk_switch_get_active (GTK_SWITCH (audio_switch)); + + start_radio(TRUE, data); + + if (settings.audio_loopback) + alsa_loopback = 1; + else + alsa_loopback = 0; + + audio_box_set_visible (can_capture); +} + +static gboolean device_entry_activate_cb(GtkWidget *widget, gpointer data) +{ + const gchar *text; + + text = gtk_entry_get_text(GTK_ENTRY(device_entry)); + + if (!strcmp(settings.device, text) || (text[0] == '\0')) + return FALSE; + + if (settings.device) + g_free(settings.device); + + settings.device = g_strdup(text); + + start_radio(TRUE, data); + + audio_box_set_visible (can_capture); + + return FALSE; +} + +static void +device_entry_auto_activate_cb(GtkEntry* entry, const gchar* text, gpointer data) +{ + GtkEditable *editable; + + editable = GTK_EDITABLE (entry); + + text = gtk_entry_get_text(GTK_ENTRY(device_entry)); + + autodetect = 0; + if (0 == strcmp(text, "auto")) { + g_signal_emit_by_name(G_OBJECT (editable), "activate"); + autodetect = 1; + + gtk_widget_grab_focus(add_button); + } +} + +static gboolean mixer_entry_activate_cb(GtkWidget *widget, gpointer data) +{ + const gchar *text; + + text = gtk_entry_get_text(GTK_ENTRY(mixer_entry)); + + if (!strcmp(settings.mixer, text) || (text[0] == '\0')) + return FALSE; + + if (settings.mixer) + g_free(settings.mixer); + + settings.mixer = g_strdup(text); + + start_mixer(TRUE, data); + + return FALSE; +} + +/*static gboolean bitrate_combo_change_cb(GtkComboBox *combo, gpointer data) +{ + GList *bitrates; + gint active; + gchar *bitrate; + + g_assert(combo); + bitrates = g_object_get_data(G_OBJECT(combo), "bitrates"); + active = gtk_combo_box_get_active(combo); + g_assert(active > -1); + + bitrate = (gchar*)g_list_nth_data(bitrates, active); + g_assert(bitrate); + + if (rec_settings.bitrate) g_free(rec_settings.bitrate); + rec_settings.bitrate = g_strdup(bitrate); + + return FALSE; +}*/ + +/*static gboolean encoder_combo_change_cb(GtkComboBox *combo, gpointer bitrate_combo) +{ + GList *encoders; + gint active; + gchar *encoder; + + g_assert(combo); + encoders = g_object_get_data(G_OBJECT(combo), "encoders"); + active = gtk_combo_box_get_active(combo); + g_assert(active > -1); + + encoder = (gchar*)g_list_nth_data(encoders, active); + g_assert(encoder); + + if (g_str_equal(encoder, _("Wave file"))) rec_settings.mp3 = FALSE; + else { + rec_settings.mp3 = TRUE; + if (rec_settings.encoder) g_free(rec_settings.encoder); + rec_settings.encoder = g_strdup(encoder); + } + gtk_widget_set_sensitive(bitrate_combo, rec_settings.mp3); + + return FALSE; +}*/ + +static void audio_profile_combo_change_cb(GtkWidget *widget, gpointer user_data) +{ + GtkTreeModel *model; + GtkTreeIter iter; + char *media_type = NULL; + GstEncodingProfile *profile; + + model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); + /* get selected media type */ + if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter) == FALSE) + return; + gtk_tree_model_get (GTK_TREE_MODEL (model), + &iter, + 0, &media_type, + 2, &profile, + -1); + + rec_settings.profile = g_strdup(media_type); + + /* indicate whether additional plugins are required to encode in this format */ + if (rb_gst_check_missing_plugins (profile, NULL, NULL)) { + gtk_widget_set_visible (install_button, TRUE); + + gtk_widget_set_sensitive (install_button, + gst_install_plugins_supported ()); + } else { + gtk_widget_set_visible (install_button, FALSE); + } + g_free (media_type); +} + +static void +audio_profile_chooser_set_active(GtkWidget *widget, const char *profile) +{ + GtkTreeIter iter; + GtkTreeModel *model; + gboolean done; + + done = FALSE; + model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); + if (gtk_tree_model_get_iter_first(model, &iter)) { + do { + char *media_type; + + gtk_tree_model_get(model, &iter, 0, &media_type, -1); + if (g_strcmp0(media_type, profile) == 0) { + gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), &iter); + done = TRUE; + } + g_free (media_type); + } while (done == FALSE && gtk_tree_model_iter_next(model, &iter)); + } + + if (done == FALSE) { + gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), NULL); + } +} + +static GtkWidget *audio_profile_choose_new(void) +{ + GstEncodingTarget *target; + const GList *p; + GtkWidget *combo; + GtkCellRenderer *renderer; + GtkTreeModel *model; + + model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER)); + + target = rb_gst_get_default_encoding_target(); + for (p = gst_encoding_target_get_profiles(target); p != NULL; p = p->next) { + GstEncodingProfile *profile = GST_ENCODING_PROFILE (p->data); + char *media_type; + + media_type = rb_gst_encoding_profile_get_media_type(profile); + if (media_type == NULL) { + continue; + } + gtk_tree_store_insert_with_values(GTK_TREE_STORE(model), + NULL, NULL, -1, + 0, media_type, + 1, gst_encoding_profile_get_description(profile), + 2, profile, -1); + g_free(media_type); + } + + combo = gtk_combo_box_new_with_model(model); + renderer = gtk_cell_renderer_text_new(); + gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE); + gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", 1, NULL); + + return GTK_WIDGET(combo); +} + +static void +audio_plugin_install_done_cb (gpointer inst, gboolean retry, gpointer user_data) +{ + audio_profile_combo_change_cb (audio_profile_combo, user_data); +} + +static void +audio_profile_install_plugins_cb (GtkWidget *widget, gpointer user_data) +{ + GstEncodingProfile *profile; + char **details; + GClosure *closure; + + /* get profile */ + profile = rb_gst_get_encoding_profile (rec_settings.profile); + if (profile == NULL) { + g_free (rec_settings.profile); + return; + } + g_free (rec_settings.profile); + + /* get plugin details */ + if (rb_gst_check_missing_plugins (profile, &details, NULL) == FALSE) { + return; + } + + /* attempt installation */ + closure = g_cclosure_new ((GCallback) audio_plugin_install_done_cb, + g_object_ref (audio_profile_combo), + (GClosureNotify) g_object_unref); + g_closure_set_marshal (closure, g_cclosure_marshal_VOID__BOOLEAN); + + rb_missing_plugins_install ((const char **)details, TRUE, closure); + + g_closure_sink (closure); + g_strfreev (details); +} + +static void add_button_clicked_cb(GtkWidget *widget, gpointer data) +{ + preset *ps; + gchar *buffer; + GtkTreeIter iter = {0}; + GtkAdjustment* v_scb; + GtkTreePath *path = NULL; + GtkWidget *menuitem; + + ps = malloc(sizeof(preset)); + ps->title = g_strdup(_("unnamed")); + ps->freq = rint(gtk_adjustment_get_value(adj)) / STEPS; + settings.presets = g_list_append(settings.presets, (gpointer) ps); + buffer = g_strdup_printf("%.2f", ps->freq); + + gtk_list_store_append(list_store, &iter); + gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, ps->title, 1, buffer, -1); + + g_free(buffer); + gtk_tree_selection_unselect_all(selection); + + v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); + gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); + + if (main_visible) { + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), ps->title); + mom_ps = g_list_length(settings.presets) - 1; + preset_combo_set_item(mom_ps); + + menuitem = gtk_menu_item_new_with_label(ps->title); + + gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, mom_ps); + g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); + gtk_widget_show(menuitem); + } + + buffer = g_strdup_printf("%d", g_list_length(settings.presets) - 1); + path = gtk_tree_path_new_from_string(buffer); + g_free(buffer); + gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); + gtk_tree_path_free(path); + + gtk_widget_set_sensitive(save_button, TRUE); +} + +static void remove_button_clicked_cb(GtkWidget *widget, gpointer data) +{ + GtkTreePath *path = NULL; + GtkTreeViewColumn *focus_column = NULL; + GtkTreeIter iter; + preset *ps; + int *row; + GList* menuitems; + GtkWidget *menuitem; + + gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); + + if (!path) return; + + row = gtk_tree_path_get_indices(path); + g_assert(row); + g_assert(*row < g_list_length(settings.presets)); + + ps = g_list_nth_data(settings.presets, *row); + g_assert(ps); + settings.presets = g_list_remove(settings.presets, (gpointer)ps); + g_free(ps->title); + g_free(ps); + + gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path); + gtk_list_store_remove(list_store, &iter); + + if (main_visible) { + gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); + if (--mom_ps < 0) mom_ps = 0; + if (settings.presets == NULL) mom_ps = -1; + preset_combo_set_item(mom_ps); + + menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); + g_assert(*row < g_list_length(menuitems)); + menuitem = g_list_nth_data(menuitems, *row); + gtk_widget_destroy(menuitem); + } + + gtk_tree_path_prev(path); + gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); + gtk_tree_path_free(path); + + if (settings.presets == NULL) { + gtk_widget_set_sensitive(save_button, FALSE); + } else { + gtk_widget_set_sensitive(save_button, TRUE); + } +} + +static void move_up_button_clicked_cb(GtkWidget * widget, gpointer data) +{ + GtkTreeIter iter, iter2; + GtkTreePath *path, *path2; + gint pos; + preset *ps; + int *row; + GList* menuitems; + GtkWidget *menuitem; + + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); + gtk_tree_selection_get_selected(selection, NULL, &iter); + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + + path2 = path; + gtk_tree_path_prev(path2); + + if (gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter2, path2)) { + // we have a previous entry... + gtk_list_store_swap(GTK_LIST_STORE(GTK_TREE_MODEL(list_store)), &iter, &iter2); + } + + row = gtk_tree_path_get_indices(path); + g_assert(row); + g_assert(*row < g_list_length(settings.presets)); + + ps = g_list_nth_data(settings.presets, *row); + g_assert(ps); + pos = g_list_index(settings.presets, (gpointer)ps); + pos++; + + settings.presets = g_list_remove(settings.presets, (gpointer)ps); + settings.presets = g_list_insert(settings.presets, (gpointer)ps, pos); + + if (main_visible) { + gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); + gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(preset_combo), *row + 2, ps->title); + mom_ps = *row; + preset_combo_set_item(mom_ps); + + menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); + g_assert(mom_ps < g_list_length(menuitems)); + menuitem = g_list_nth_data(menuitems, mom_ps); + gtk_widget_destroy(menuitem); + menuitem = gtk_menu_item_new_with_label(ps->title); + + gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, *row + 1); + g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); + gtk_widget_show(menuitem); + } + + gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); + gtk_tree_path_free(path); + + if (pos - 1 <= 0) { + gtk_widget_set_sensitive(move_up_button, FALSE); + } else { + gtk_widget_set_sensitive(move_up_button, TRUE); + } + gtk_widget_set_sensitive(move_down_button, TRUE); +} + +static void move_down_button_clicked_cb(GtkWidget * widget, gpointer data) +{ + GtkTreeIter iter, iter2; + GtkTreePath *path, *path2; + gint pos, count; + preset *ps; + int *row; + GList* menuitems; + GtkWidget *menuitem; + + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); + gtk_tree_selection_get_selected(selection, NULL, &iter); + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + + path2 = path; + gtk_tree_path_next(path2); + + if (gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter2, path2)) { + // we have a next entry... + gtk_list_store_swap(GTK_LIST_STORE(GTK_TREE_MODEL(list_store)), &iter, &iter2); + } + + row = gtk_tree_path_get_indices(path); + g_assert(row); + g_assert(*row < g_list_length(settings.presets)); + + ps = g_list_nth_data(settings.presets, *row); + g_assert(ps); + + count = g_list_length(settings.presets); + pos = g_list_index(settings.presets, (gpointer)ps); + pos--; + if (pos == count) + pos = 0; + + settings.presets = g_list_remove(settings.presets, (gpointer)ps); + settings.presets = g_list_insert(settings.presets, (gpointer)ps, pos); + + if (main_visible) { + gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); + gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(preset_combo), *row, ps->title); + mom_ps = *row; + preset_combo_set_item(mom_ps); + + menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); + g_assert(mom_ps < g_list_length(menuitems)); + menuitem = g_list_nth_data(menuitems, mom_ps); + gtk_widget_destroy(menuitem); + menuitem = gtk_menu_item_new_with_label(ps->title); + + gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, *row - 1); + g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); + gtk_widget_show(menuitem); + } + + gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); + gtk_tree_path_free(path); + + if (pos + 2 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) { + gtk_widget_set_sensitive(move_down_button, FALSE); + } else { + gtk_widget_set_sensitive(move_down_button, TRUE); + } + gtk_widget_set_sensitive(move_up_button, TRUE); +} + +static void destination_button_clicked_cb(GtkWidget *button, gpointer data) +{ + if (rec_settings.destination) + { + g_free(rec_settings.destination); + } + rec_settings.destination = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(button)); +} + +static gboolean list_view_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data) +{ + if (event->keyval == GDK_KEY_Delete) + remove_button_clicked_cb(widget, user_data); + if (event->keyval == GDK_KEY_Insert) + add_button_clicked_cb(widget, user_data); + + return FALSE; +} + +static gboolean button_release_cb(GtkWidget *widget, GdkEvent *event, gpointer data) +{ + GtkTreePath *path; + gint pos; + GdkEventButton *event_button; + gchar *buffer; + + event_button = (GdkEventButton *) event; + + gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(list_view), event_button->x, event_button->y, &path, NULL, NULL, NULL); + if (path != NULL) { + buffer = gtk_tree_path_to_string(path); + pos = (gint) g_strtod(buffer, NULL); + g_free(buffer); + gtk_tree_path_free(path); + + if (pos == 0) { + gtk_widget_set_sensitive(move_up_button, FALSE); + } else { + gtk_widget_set_sensitive(move_up_button, TRUE); + } + + if (pos + 1 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) { + gtk_widget_set_sensitive(move_down_button, FALSE); + } else { + gtk_widget_set_sensitive(move_down_button, TRUE); + } + } + return FALSE; +} + +static void name_cell_edited_cb(GtkCellRendererText *cellrenderertext, gchar *path_str, gchar *new_val, gpointer user_data) +{ + GtkTreePath *path = NULL; + GtkTreeIter iter; + preset *ps; + int *row; + GList* menuitems; + GtkWidget *menuitem; + + path = gtk_tree_path_new_from_string(path_str); + + row = gtk_tree_path_get_indices(path); + g_assert(row); + g_assert(*row < g_list_length(settings.presets)); + + ps = g_list_nth_data(settings.presets, *row); + g_assert(ps); + if (ps->title) g_free(ps->title); + ps->title = g_strdup(new_val); + + if (main_visible) { + gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); + gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1, ps->title); + mom_ps = *row; + preset_combo_set_item(mom_ps); + + menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); + g_assert(mom_ps < g_list_length(menuitems)); + menuitem = g_list_nth_data(menuitems, mom_ps); + gtk_widget_destroy(menuitem); + menuitem = gtk_menu_item_new_with_label(ps->title); + + gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, *row); + g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); + gtk_widget_show(menuitem); + } + + gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path); + gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, new_val, -1); + gtk_tree_path_free(path); +} + +static void freq_cell_edited_cb(GtkCellRendererText *cellrenderertext, gchar *path_str, gchar *new_val, gpointer user_data) +{ + GtkTreePath *path = NULL; + GtkTreeIter iter; + preset *ps; + int *row; + double value; + gchar *freq_str; + + if (sscanf(new_val, "%lf", &value) != 1) return; + + if (value < FREQ_MIN) value = FREQ_MIN; + if (value > FREQ_MAX) value = FREQ_MAX; + value = rint(value * STEPS) / STEPS; + + freq_str = g_strdup_printf("%.2f", value); + + path = gtk_tree_path_new_from_string(path_str); + + row = gtk_tree_path_get_indices(path); + g_assert(row); + g_assert(*row < g_list_length(settings.presets)); + + ps = g_list_nth_data(settings.presets, *row); + g_assert(ps); + ps->freq = value; + + gtk_adjustment_set_value(adj, value * STEPS); + mom_ps = *row; + preset_combo_set_item(mom_ps); + + gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path); + gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 1, freq_str, -1); + g_free(freq_str); + gtk_tree_path_free(path); +} + +static void list_view_cursor_changed_cb(GtkWidget *widget, gpointer data) +{ + int *row; + preset *ps; + gint pos; + GtkTreePath *path = NULL; + GtkTreeViewColumn *focus_column = NULL; + + if (settings.presets == NULL) + return; + + gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); + + if (!path) + return; + + row = gtk_tree_path_get_indices(path); + g_assert(row); + + mom_ps = *row; + preset_combo_set_item(mom_ps); + + ps = g_list_nth_data(settings.presets, *row); + g_assert(ps); + + pos = g_list_index(settings.presets, (gpointer)ps); + + if (pos == 0) { + gtk_widget_set_sensitive(move_up_button, FALSE); + } else { + gtk_widget_set_sensitive(move_up_button, TRUE); + } + + if (pos + 1 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) { + gtk_widget_set_sensitive(move_down_button, FALSE); + } else { + gtk_widget_set_sensitive(move_down_button, TRUE); + } + gtk_tree_path_free(path); + return; +} + +static void list_view_selection_changed_cb(GtkWidget *widget, gpointer data) +{ + gboolean sel; + + sel = gtk_tree_selection_get_selected(selection, NULL, NULL); + + gtk_widget_set_sensitive(remove_button, sel); + gtk_widget_set_sensitive(save_button, sel); +} + +static void list_view_scroll_to_active_preset_cb(GtkWidget *widget, gpointer data) +{ + GtkTreePath *path = NULL; + GtkTreeIter iter; + gint active; + + if (settings.presets == NULL) { + gtk_widget_grab_focus(add_button); + return; + } + + active = gtk_combo_box_get_active(GTK_COMBO_BOX(preset_combo)) - 1; + + if (active < 0) { + gtk_widget_grab_focus(add_button); + return; + } + + if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, active)) + return; + + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + + gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list_view), path, NULL, FALSE, 0, 0); + gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); + gtk_tree_path_free(path); + + gtk_widget_grab_focus(list_view); +} + +static void free_presets_list (gpointer data) +{ + preset *ps = (preset *) data; + g_free (ps->title); + g_free (ps); +} + +/* Go through each row and add its data to the xmlDocPtr */ +static gboolean save_to_file_foreach(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, xmlNodePtr root, gpointer user_data) +{ + gchar *title, *freq, *position; + xmlNodePtr current; + + /* get the data stored in the model... */ + gtk_tree_model_get(model, iter, 0, &title, 1, &freq, -1); + /* ...and get the path of the current row */ + position = gtk_tree_path_to_string(path); + /* create a new child of the root node... */ + /* (note that I'm using a (guchar*) cast; this is because it's the same thing as + * an (xmlChar*) cast, but easier to type) */ + current = xmlNewChild(root, NULL, (guchar*)"station", NULL); + /* ...and set some properties */ + xmlSetProp(current, (guchar*)"name", (guchar*)title); + xmlSetProp(current, (guchar*)"freq", (guchar*)freq); + xmlSetProp(current, (guchar*)"position", (guchar*)position); + /* free our data we retrieved from the model */ + g_free(title); + g_free(freq); + g_free(position); + + /* return FALSE to keep iterating */ + return FALSE; +} + +/* Function handle saving an xml file; calls save_to_file_foreach */ +static void save_to_file(gchar *filename) +{ + GtkTreeModel *model; + xmlDocPtr doc; + xmlNodePtr root; + + /* create a new doc node */ + doc = xmlNewDoc((guchar*)"1.0"); + /* create a new root element. */ + root = xmlNewDocNode(doc, NULL, (guchar*)"gnomeradio", NULL); + /* set it as the root element */ + xmlDocSetRootElement(doc, root); + /* get the tree view's model... */ + model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); + /* ...and go through it with a foreach */ + gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc)save_to_file_foreach, (gpointer)root); + /* save the actual file */ + xmlSaveFile(filename, doc); + /* free the doc node */ + xmlFreeDoc(doc); +} + +/* Callback for the "Save to file" button; calls save_to_file */ +static void save_to_file_cb(GtkWidget *button, gpointer data) +{ + GtkWidget *dialog; + GtkFileFilter *file_filter_all; + GtkFileFilter *file_filter_xml; + gchar *filename; + + dialog = gtk_file_chooser_dialog_new (_("Select file name\xE2\x80\xA6"), NULL, + GTK_FILE_CHOOSER_ACTION_SAVE, + _("_Save"), GTK_RESPONSE_ACCEPT, + _("_Cancel"), GTK_RESPONSE_CANCEL, + NULL); + + file_filter_all = gtk_file_filter_new(); + gtk_file_filter_set_name(file_filter_all, _("All Files")); + gtk_file_filter_add_pattern(file_filter_all, "*"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_all); + + file_filter_xml = gtk_file_filter_new(); + gtk_file_filter_set_name(file_filter_xml, _("XML Files (*.xml)")); + gtk_file_filter_add_pattern(file_filter_xml, "*.xml"); + gtk_file_filter_add_pattern(file_filter_xml, "*.XML"); + gtk_file_filter_add_mime_type(file_filter_xml, "text/xml"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); + + gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); + gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); + gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "gnomeradio.xml"); + + if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + /* Check if .xml extension is added, if not add */ + if (!g_str_has_suffix(filename, ".xml")) { + char *tmp_file; + /* create copy of filename to release it and create a new one, using old name */ + tmp_file = g_strdup(filename); + g_free(filename); + filename = g_strdup_printf("%s.xml", tmp_file); + g_free(tmp_file); + } + save_to_file(filename); + g_free(filename); + } + gtk_widget_destroy(dialog); +} + +/* Gets the parent of a path string. +* passing "0:1:2" would return "0:1", +* passing "0:1" would return "0", +* passing "0" would return NULL */ +gchar *gtk_tree_path_string_get_parent(gchar *path) +{ + gchar *colon; + + g_return_val_if_fail(path != NULL, NULL); + + colon = g_strrstr(path, ":"); + if (colon == NULL) + return NULL; + + return g_strndup(path, colon - path); +} + +/* Make sure that path exists within model */ +static void gtk_tree_model_generate_path(GtkTreeModel *model, gchar *path) +{ + GtkTreeIter iter, parent; + gchar *temp; + + while (TRUE) { + /* if this returns TRUE, then this path exists and we're fine */ + if (gtk_tree_model_get_iter_from_string(model, &iter, path)) + break; + + temp = path; + path = gtk_tree_path_string_get_parent(path); + /* if there's no parent, then it's toplevel */ + if (path == NULL) { + if (GTK_IS_TREE_STORE(model)) + gtk_tree_store_append(GTK_TREE_STORE(model), &parent, NULL); + else + gtk_list_store_append(GTK_LIST_STORE(model), &parent); + gtk_tree_model_generate_path(model, temp); + break; + } + if (GTK_IS_TREE_STORE(model)) { + gtk_tree_model_generate_path(model, path); + gtk_tree_model_get_iter_from_string(model, &parent, path); + gtk_tree_store_append(GTK_TREE_STORE(model), &iter, &parent); + } + } +} + +/* Function to load from an xml file */ +static void load_from_file(gchar *filename) +{ + xmlDocPtr doc; + xmlNodePtr current; + xmlChar *title, *freq, *position; + GtkTreeModel *model; + GtkTreePath *path = NULL; + GtkTreeIter iter; + GtkAdjustment* v_scb; + GList* menuitems; + GtkWidget *menuitem; + + /* load the file */ + doc = xmlParseFile(filename); + /* get the root item */ + if (doc == NULL) + return; + + current = xmlDocGetRootElement(doc); + if (current == NULL) { + xmlFreeDoc(doc); + return; + } + + if (xmlStrcmp(current->name, (guchar*)"gnomeradio")) { + xmlFreeDoc(doc); + return; + } + + /* remove previous presets */ + if (settings.presets != NULL) { + if (main_visible) { + gint i, count; + + count = g_list_length (settings.presets); + for (i = 0; i < count; i++) + gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), 1); + + menuitems = gtk_container_get_children (GTK_CONTAINER (tray_menu)); + + count = g_list_length (menuitems); + for (i = 0; i < count - 6; i++) { + menuitem = g_list_nth_data (menuitems, i); + gtk_widget_destroy (menuitem); + } + } + + gtk_list_store_clear(GTK_LIST_STORE(list_store)); + + g_list_free_full (settings.presets, free_presets_list); + settings.presets = NULL; + } + + /* get the tree view's model */ + model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); + + /* iterate through the root's children items */ + current = current->xmlChildrenNode; + while (current) { + if(!xmlIsBlankNode(current)) { + /* check for the proper element name */ + if (!xmlStrcmp(current->name, (guchar*)"station")) { + /* get the saved properties */ + title = xmlGetProp(current, (guchar*)"name"); + freq = xmlGetProp(current, (guchar*)"freq"); + position = xmlGetProp(current, (guchar*)"position"); + + if( title && freq && position ) { + preset *ps = g_malloc0(sizeof(preset)); + ps->title = g_strdup((gchar*)title); + ps->freq = atof((gchar*)freq); + + settings.presets = g_list_append(settings.presets, ps); + + /* make sure that the path exists */ + gtk_tree_model_generate_path(model, (gchar*)position); + /* get an iter to the path */ + gtk_tree_model_get_iter_from_string(model, &iter, (gchar*)position); + /* set the data */ + gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, title, 1, freq, -1); + + gtk_tree_selection_unselect_all(selection); + + v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); + gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); + + if (main_visible) { + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), ps->title); + mom_ps = g_list_length(settings.presets) - 1; + preset_combo_set_item(mom_ps); + + menuitem = gtk_menu_item_new_with_label(ps->title); + + gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, mom_ps); + g_signal_connect(G_OBJECT(menuitem), "activate", + (GCallback)preset_menuitem_activate_cb, + GINT_TO_POINTER (mom_ps)); + gtk_widget_show(menuitem); + } + } + /* free the data */ + xmlFree(title); + xmlFree(freq); + xmlFree(position); + } + current = current->next; + } + } + /* free the doc node */ + xmlFreeDoc(doc); + + if (settings.presets == NULL) + return; + + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + + gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); + gtk_tree_path_free(path); + + gtk_widget_grab_focus(list_view); + + list_view_cursor_changed_cb(list_view, NULL); + gtk_widget_set_sensitive(save_button, TRUE); + gtk_widget_set_sensitive(remove_button, TRUE); +} + +/* Callback for the "Load from file" button; calls load_from_file */ +static void load_from_file_cb(GtkWidget *button, gpointer data) +{ + GtkWidget *dialog; + GtkFileFilter *file_filter_all; + GtkFileFilter *file_filter_xml; + gchar *filename; + + dialog = gtk_file_chooser_dialog_new (_("Select file name\xE2\x80\xA6"), NULL, + GTK_FILE_CHOOSER_ACTION_OPEN, + _("_Open"), GTK_RESPONSE_ACCEPT, + _("_Cancel"), GTK_RESPONSE_CANCEL, + NULL); + + file_filter_all = gtk_file_filter_new(); + gtk_file_filter_set_name(file_filter_all, _("All Files")); + gtk_file_filter_add_pattern(file_filter_all, "*"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_all); + + file_filter_xml = gtk_file_filter_new(); + gtk_file_filter_set_name(file_filter_xml, _("XML Files")); + gtk_file_filter_add_pattern(file_filter_xml, "*.xml"); + gtk_file_filter_add_pattern(file_filter_xml, "*.XML"); + gtk_file_filter_add_mime_type(file_filter_xml, "text/xml"); + gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); + + gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); + + if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { + filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + load_from_file(filename); + g_free(filename); + } + gtk_widget_destroy(dialog); +} + +gboolean action_mode (gint mode) +{ + switch (mode) { + case RADIO_DEVICE: + gtk_widget_grab_focus (device_entry); + break; + case MIXER_DEVICE: + gtk_widget_grab_focus (mixer_entry); + break; + case PRESETS: + list_view_scroll_to_active_preset_cb(list_view, NULL); + break; + default: + break; + } + + return TRUE; +} + +GtkWidget* prefs_window(GtkWidget *app) +{ + GtkWidget *dialog; + GtkWidget *content_area; + GtkWidget *box; + GtkWidget *grid; + GtkWidget *label; + GtkWidget *scrolled_window; + GtkCellRenderer *cellrenderer; + GtkTreeViewColumn *list_column; + GtkWidget *button_box; + GtkWidget *open_button; + GtkWidget *destination_button; + GtkWidget *image; + + GstEncodingProfile *profile; + + gint i; + gchar *markup; + preset* ps; + GList *l; + + dialog = gtk_dialog_new_with_buttons (_("Gnomeradio Settings"), GTK_WINDOW (app), + GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, + _("_Close"), GTK_RESPONSE_CLOSE, + _("_Help"), GTK_RESPONSE_HELP, + NULL); + + gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); + gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); + + content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog)); + + box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); + gtk_container_set_border_width(GTK_CONTAINER(box), 10); + gtk_box_pack_start (GTK_BOX (content_area), box, TRUE, TRUE, 0); + + grid = gtk_grid_new(); + gtk_grid_set_row_spacing(GTK_GRID(grid), 5); + gtk_grid_set_column_spacing(GTK_GRID(grid), 65); + gtk_box_pack_start(GTK_BOX(box), grid, TRUE, TRUE, 0); + + /* The general settings part */ + label = gtk_label_new (NULL); + gtk_widget_set_halign (label, GTK_ALIGN_START); + markup = g_strdup_printf ("%s", _("General Settings")); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (markup); + gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1); + + label = gtk_label_new (_("Radio device:")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); + + device_entry = gtk_entry_new(); + + if (autodetect) + gtk_entry_set_placeholder_text(GTK_ENTRY(device_entry), "auto"); + else + gtk_entry_set_text(GTK_ENTRY(device_entry), settings.device); + + gtk_grid_attach(GTK_GRID(grid), device_entry, 1, 1, 1, 1); + + label = gtk_label_new (_("Mixer source:")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); + + mixer_entry = gtk_entry_new(); + gtk_entry_set_text(GTK_ENTRY(mixer_entry), settings.mixer); + gtk_grid_attach(GTK_GRID(grid), mixer_entry, 1, 2, 1, 1); + + audio_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_widget_set_no_show_all (audio_box, TRUE); + + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + + label = gtk_label_new (_("Loopback mode")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + + audio_switch = gtk_switch_new (); + + gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); + gtk_box_pack_end (GTK_BOX (box), audio_switch, FALSE, FALSE, 0); + + label = gtk_label_new (NULL); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_valign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + markup = g_strdup_printf ("%s", _("(audio streaming between radio device and audio output device)")); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (markup); + + gtk_box_pack_start (GTK_BOX (audio_box), box, FALSE, FALSE, 0); + gtk_box_pack_end (GTK_BOX (audio_box), label, FALSE, FALSE, 0); + gtk_grid_attach(GTK_GRID(grid), audio_box, 0, 3, 2, 1); + + /* Enabled audio loopback from switch|commandline */ + if (settings.audio_loopback || alsa_loopback) + gtk_switch_set_active (GTK_SWITCH (audio_switch), TRUE); + else + gtk_switch_set_active (GTK_SWITCH (audio_switch), FALSE); + + audio_box_set_visible (can_capture); + + mute_on_exit = gtk_check_button_new_with_label(_("Mute on exit")); + gtk_widget_set_margin_left (mute_on_exit, 10); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mute_on_exit), settings.mute_on_exit); + gtk_grid_attach(GTK_GRID(grid), mute_on_exit, 0, 4, 2, 1); + + g_signal_connect(G_OBJECT(device_entry), "hide", G_CALLBACK(device_entry_activate_cb), app); + g_signal_connect(G_OBJECT(device_entry), "activate", G_CALLBACK(device_entry_activate_cb), NULL); + g_signal_connect(G_OBJECT(device_entry), "changed", G_CALLBACK(device_entry_auto_activate_cb), NULL); + g_signal_connect(G_OBJECT(mixer_entry), "hide", G_CALLBACK(mixer_entry_activate_cb), app); + g_signal_connect(G_OBJECT(mixer_entry), "activate", G_CALLBACK(mixer_entry_activate_cb), NULL); + g_signal_connect(G_OBJECT(audio_switch), "notify::active", G_CALLBACK(audio_switch_activate_cb), NULL); + g_signal_connect(G_OBJECT(mute_on_exit), "toggled", G_CALLBACK(mute_on_exit_toggled_cb), NULL); + + gtk_widget_set_tooltip_text(device_entry, _("The radio device to use (e.g. /dev/radio0)")); + gtk_widget_set_tooltip_text(mixer_entry, _("The mixer device and channel to use (e.g. hw:0/Line)")); + gtk_widget_set_tooltip_text(mute_on_exit, _("Mute radio device on exit")); + + /* The presets part */ + label = gtk_label_new (NULL); + gtk_widget_set_halign (label, GTK_ALIGN_START); + markup = g_strdup_printf ("%s", _("Presets")); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (markup); + gtk_grid_attach(GTK_GRID(grid), label, 0, 5, 1, 1); + + scrolled_window = gtk_scrolled_window_new(NULL, NULL); + gtk_widget_set_margin_left (scrolled_window, 10); + gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled_window), 75); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + + list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); + list_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); + gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(list_view), TRUE); + gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list_view), FALSE); + + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); + gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); + gtk_container_add(GTK_CONTAINER(scrolled_window), list_view); + + g_signal_connect(G_OBJECT(list_view), "button-release-event", G_CALLBACK(button_release_cb), NULL); + g_signal_connect(G_OBJECT(list_view), "key-press-event", G_CALLBACK(list_view_key_press_event_cb), NULL); + g_signal_connect(G_OBJECT(list_view), "cursor-changed", G_CALLBACK(list_view_cursor_changed_cb), NULL); + + g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(list_view_selection_changed_cb), list_view); + + /*gtk_tree_selection_select_path(selection, gtk_tree_path_new_from_string("0")); + gtk_tree_selection_set_select_function(selection, (GtkTreeSelectionFunc)list_view_select_cb, NULL, NULL);*/ + + cellrenderer = gtk_cell_renderer_text_new(); + g_object_set(G_OBJECT(cellrenderer), "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL); + g_object_set(G_OBJECT(GTK_CELL_RENDERER_TEXT(cellrenderer)), "editable", TRUE, NULL); + list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 0, NULL); + gtk_tree_view_column_set_reorderable(list_column, TRUE); + gtk_tree_view_column_set_expand(list_column, TRUE); + gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); + + g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(name_cell_edited_cb), NULL); + + cellrenderer = gtk_cell_renderer_text_new(); + g_object_set(G_OBJECT(cellrenderer), "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL); + g_object_set(G_OBJECT(cellrenderer), "xalign", 1.0, NULL); + g_object_set(G_OBJECT(GTK_CELL_RENDERER_TEXT(cellrenderer)), "editable", TRUE, NULL); + list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 1, NULL); + gtk_tree_view_column_set_reorderable(list_column, TRUE); + gtk_tree_view_column_set_expand(list_column, FALSE); + gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); + + g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(freq_cell_edited_cb), NULL); + + i = 0; + for (l = settings.presets; l != NULL; l = l->next) { + GtkTreeIter iter = {0}; + char *buffer; + ps = l->data; + buffer = g_strdup_printf("%0.2f", ps->freq); + gtk_list_store_append(list_store, &iter); + gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, ps->title, 1, buffer, -1); + g_free(buffer); + i++; + } + + gtk_grid_attach(GTK_GRID(grid), scrolled_window, 0, 6, 2, 1); + + button_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); + + move_up_button = gtk_button_new(); + image = gtk_image_new_from_icon_name ("go-up", GTK_ICON_SIZE_MENU); + gtk_button_set_image (GTK_BUTTON (move_up_button), image); + gtk_button_set_relief (GTK_BUTTON (move_up_button), GTK_RELIEF_NONE); + gtk_widget_set_sensitive(move_up_button, FALSE); + gtk_widget_set_tooltip_text(move_up_button, _("Move preset up")); + + g_signal_connect(G_OBJECT(move_up_button), "clicked", G_CALLBACK(move_up_button_clicked_cb), NULL); + + move_down_button = gtk_button_new(); + image = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_MENU); + gtk_button_set_image (GTK_BUTTON (move_down_button), image); + gtk_button_set_relief (GTK_BUTTON (move_down_button), GTK_RELIEF_NONE); + gtk_widget_set_sensitive(move_down_button, FALSE); + gtk_widget_set_tooltip_text(move_down_button, _("Move preset down")); + + g_signal_connect(G_OBJECT(move_down_button), "clicked", G_CALLBACK(move_down_button_clicked_cb), NULL); + + add_button = gtk_button_new(); + image = gtk_image_new_from_icon_name ("list-add", GTK_ICON_SIZE_MENU); + gtk_button_set_image (GTK_BUTTON(add_button), image); + gtk_button_set_relief (GTK_BUTTON (add_button), GTK_RELIEF_NONE); + gtk_widget_set_tooltip_text(add_button, _("Add preset")); + + g_signal_connect(G_OBJECT(add_button), "clicked", G_CALLBACK(add_button_clicked_cb), NULL); + + remove_button = gtk_button_new(); + image = gtk_image_new_from_icon_name ("list-remove", GTK_ICON_SIZE_MENU); + gtk_button_set_image (GTK_BUTTON (remove_button), image); + gtk_button_set_relief (GTK_BUTTON (remove_button), GTK_RELIEF_NONE); + gtk_widget_set_tooltip_text(remove_button, _("Remove preset")); + gtk_widget_set_sensitive(remove_button, FALSE); + + g_signal_connect(G_OBJECT(remove_button), "clicked", G_CALLBACK(remove_button_clicked_cb), NULL); + + save_button = gtk_button_new(); + image = gtk_image_new_from_icon_name ("document-save", GTK_ICON_SIZE_MENU); + gtk_button_set_image (GTK_BUTTON (save_button), image); + gtk_button_set_relief (GTK_BUTTON (save_button), GTK_RELIEF_NONE); + gtk_widget_set_tooltip_text(save_button, _("Save to file\xE2\x80\xA6")); + + if (settings.presets == NULL) + gtk_widget_set_sensitive (save_button, FALSE); + else + gtk_widget_set_sensitive (save_button, TRUE); + + g_signal_connect(G_OBJECT(save_button), "clicked", G_CALLBACK(save_to_file_cb), NULL); + + open_button = gtk_button_new(); + image = gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_MENU); + gtk_button_set_image (GTK_BUTTON(open_button), image); + gtk_button_set_relief (GTK_BUTTON (open_button), GTK_RELIEF_NONE); + gtk_widget_set_tooltip_text(open_button, _("Load from file\xE2\x80\xA6")); + gtk_widget_set_sensitive(open_button, TRUE); + + g_signal_connect(G_OBJECT(open_button), "clicked", G_CALLBACK(load_from_file_cb), NULL); + + gtk_box_pack_end(GTK_BOX(button_box), move_down_button, FALSE, FALSE, 0); + gtk_box_pack_end(GTK_BOX(button_box), move_up_button, FALSE, FALSE, 0); + gtk_box_pack_end(GTK_BOX(button_box), remove_button, FALSE, FALSE, 0); + gtk_box_pack_end(GTK_BOX(button_box), add_button, FALSE, FALSE, 0); + gtk_box_pack_end(GTK_BOX(button_box), save_button, FALSE, FALSE, 0); + gtk_box_pack_end(GTK_BOX(button_box), open_button, FALSE, FALSE, 0); + + gtk_grid_attach(GTK_GRID(grid), button_box, 1, 7, 1, 1); + + /* The record settings part */ + label = gtk_label_new (NULL); + gtk_widget_set_halign (label, GTK_ALIGN_START); + markup = g_strdup_printf ("%s", _("Record Settings")); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (markup); + gtk_grid_attach (GTK_GRID (grid), label, 0, 8, 1, 1); + + label = gtk_label_new (_("Destination:")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + gtk_grid_attach(GTK_GRID(grid), label, 0, 9, 1, 1); + + destination_button = gtk_file_chooser_button_new (_("Select a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); + gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(destination_button), rec_settings.destination); + gtk_grid_attach(GTK_GRID(grid), destination_button, 1, 9, 1, 1); + + label = gtk_label_new (_("Output format:")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + gtk_grid_attach (GTK_GRID (grid), label, 0, 10, 1, 1); + + audio_profile_combo = audio_profile_choose_new(); + audio_profile_chooser_set_active(audio_profile_combo, rec_settings.profile); + gtk_grid_attach (GTK_GRID (grid), audio_profile_combo, 1, 10, 1, 1); + + install_button = gtk_button_new_with_label(_("Install additional software required to use this format")); + gtk_widget_set_no_show_all (install_button, TRUE); + gtk_grid_attach (GTK_GRID (grid), install_button, 1, 11, 1, 1); + + profile = rb_gst_get_encoding_profile (rec_settings.profile); + if (rb_gst_check_missing_plugins (profile, NULL, NULL)) { + gtk_widget_set_visible (install_button, TRUE); + gtk_widget_set_sensitive (install_button, + gst_install_plugins_supported ()); + } else { + gtk_widget_set_visible (install_button, FALSE); + } + + g_signal_connect(GTK_FILE_CHOOSER(destination_button), "selection-changed", G_CALLBACK(destination_button_clicked_cb), NULL); + g_signal_connect(G_OBJECT(audio_profile_combo), "changed", G_CALLBACK(audio_profile_combo_change_cb), NULL); + g_signal_connect(G_OBJECT(install_button), "clicked", G_CALLBACK(audio_profile_install_plugins_cb), NULL); + + gtk_widget_set_tooltip_text(destination_button, _("Select a location where to save recorded file.")); + gtk_widget_set_tooltip_text(audio_profile_combo, _("Choose the format that should be used for recording.")); + + gtk_widget_show_all(dialog); + + return dialog; +} === removed file '.pc/gnomeradio-tray_menu.patch/src/prefs.c' --- .pc/gnomeradio-tray_menu.patch/src/prefs.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/prefs.c 1970-01-01 00:00:00 +0000 @@ -1,1543 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Library General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include "config.h" -#include "prefs.h" -#include "trayicon.h" -#include "gui.h" -#include "rec_tech.h" -#include "rb_gst_media_types.h" -#include "rb_missing_plugins.h" -#include "alsa_stream.h" - -extern int autodetect; -extern int alsa_loopback; - -extern GtkWidget *preset_combo; -extern GtkAdjustment *adj; - -extern int mom_ps; -extern gnomeradio_settings settings; - -extern gboolean main_visible; - -static GtkWidget *device_entry; -static GtkWidget *mixer_entry; -static GtkWidget *audio_label; -static GtkWidget *enabled; -static GtkWidget *disabled; -static GtkWidget *mute_on_exit; -static GtkWidget *list_view; -static GtkListStore *list_store; -static GtkTreeSelection *selection; -static GtkWidget *save_button; -static GtkWidget *move_up_button; -static GtkWidget *move_down_button; -static GtkWidget *add_button; -static GtkWidget *remove_button; -static GtkWidget *audio_profile_combo; -static GtkWidget *install_button; - -gboolean save_settings(void) -{ - gint i, count; - gchar *buffer; - preset *ps; - GConfClient* client = NULL; - - if (!gconf_is_initialized()) - return FALSE; - - client = gconf_client_get_default(); - if (!client) - return FALSE; - - /* Store general settings */ - if (autodetect) - gconf_client_set_string(client, "/apps/gnomeradio/device", "auto", NULL); - else - gconf_client_set_string(client, "/apps/gnomeradio/device", settings.device, NULL); - gconf_client_set_string(client, "/apps/gnomeradio/driver", settings.driver, NULL); - gconf_client_set_string(client, "/apps/gnomeradio/mixer", settings.mixer, NULL); - gconf_client_set_bool(client, "/apps/gnomeradio/audio-loopback", settings.audio_loopback , NULL); - gconf_client_set_bool(client, "/apps/gnomeradio/mute-on-exit", settings.mute_on_exit, NULL); - /*gconf_client_set_float(client, "/apps/gnomeradio/volume", volume->value, NULL);*/ - gconf_client_set_float(client, "/apps/gnomeradio/last-freq", gtk_adjustment_get_value(adj)/STEPS, NULL); - - /* Store recording settings */ -/* gconf_client_set_string(client, "/apps/gnomeradio/recording/audiodevice", rec_settings.audiodevice, NULL); - gconf_client_set_bool(client, "/apps/gnomeradio/recording/record-as-mp3", rec_settings.mp3, NULL); - gconf_client_set_string(client, "/apps/gnomeradio/recording/sample-rate", rec_settings.rate, NULL); - gconf_client_set_string(client, "/apps/gnomeradio/recording/sample-format", rec_settings.sample, NULL); - gconf_client_set_bool(client, "/apps/gnomeradio/recording/record-in-stereo", rec_settings.stereo, NULL); - gconf_client_set_string(client, "/apps/gnomeradio/recording/encoder", rec_settings.encoder, NULL); - gconf_client_set_string(client, "/apps/gnomeradio/recording/bitrate", rec_settings.bitrate, NULL); -*/ - - gconf_client_set_string(client, "/apps/gnomeradio/recording/destination", rec_settings.destination, NULL); - gconf_client_set_string(client, "/apps/gnomeradio/recording/profile", rec_settings.profile, NULL); - - /* Store the presets */ - count = g_list_length(settings.presets); - gconf_client_set_int(client, "/apps/gnomeradio/presets/presets", count, NULL); - for (i = 0; i < count; i++) - { - ps = g_list_nth_data(settings.presets, i); - buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/name", i); - gconf_client_set_string(client, buffer, ps->title, NULL); - g_free(buffer); - buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/freqency", i); - gconf_client_set_float(client, buffer, ps->freq, NULL); - g_free(buffer); - } - gconf_client_set_int(client, "/apps/gnomeradio/presets/last", mom_ps, NULL); - /*g_print("Storing Settings in GConf database\n");*/ - - return TRUE; -} - -gboolean load_settings(void) -{ - gint i, count; - gchar *buffer; - preset *ps; - GConfClient *client = NULL; - double freq; - - settings.presets = NULL; - - if (!gconf_is_initialized()) - return FALSE; - - client = gconf_client_get_default(); - if (!client) - return FALSE; - - /* Load general settings */ - settings.device = gconf_client_get_string(client, "/apps/gnomeradio/device", NULL); - if (!settings.device) - settings.device = g_strdup("auto"); - settings.driver = gconf_client_get_string(client, "/apps/gnomeradio/driver", NULL); - if (!settings.driver) - settings.driver = g_strdup("any"); - settings.mixer = gconf_client_get_string(client, "/apps/gnomeradio/mixer", NULL); - if (!settings.mixer) - settings.mixer = g_strdup("hw:0/Line"); - settings.audio_loopback = gconf_client_get_bool(client, "/apps/gnomeradio/audio-loopback", NULL); - settings.mute_on_exit = gconf_client_get_bool(client, "/apps/gnomeradio/mute-on-exit", NULL); - /*volume->value = gconf_client_get_float(client, "/apps/gnomeradio/volume", NULL);*/ - freq = gconf_client_get_float(client, "/apps/gnomeradio/last-freq", NULL); - if ((freq < FREQ_MIN) || (freq > FREQ_MAX)) - gtk_adjustment_set_value(adj, FREQ_MIN * STEPS); - else - gtk_adjustment_set_value(adj, freq * STEPS); - - /* Load recording settings */ -/* rec_settings.audiodevice = gconf_client_get_string(client, "/apps/gnomeradio/recording/audiodevice", NULL); - if (!rec_settings.audiodevice) - rec_settings.audiodevice = g_strdup("/dev/audio"); - rec_settings.mp3 = gconf_client_get_bool(client, "/apps/gnomeradio/recording/record-as-mp3", NULL); - rec_settings.rate = gconf_client_get_string(client, "/apps/gnomeradio/recording/sample-rate", NULL); - if (!rec_settings.rate) - rec_settings.rate = g_strdup("44100"); - rec_settings.sample = gconf_client_get_string(client, "/apps/gnomeradio/recording/sample-format", NULL); - if (!rec_settings.sample) - rec_settings.sample = g_strdup("16"); - rec_settings.stereo = gconf_client_get_bool(client, "/apps/gnomeradio/recording/record-in-stereo", NULL); - rec_settings.encoder = gconf_client_get_string(client, "/apps/gnomeradio/recording/encoder", NULL); - if (!rec_settings.encoder) - rec_settings.encoder = g_strdup("oggenc"); - rec_settings.bitrate = gconf_client_get_string(client, "/apps/gnomeradio/recording/bitrate", NULL); - if (!rec_settings.bitrate) - rec_settings.bitrate = g_strdup("192");*/ - - rec_settings.destination = gconf_client_get_string(client, "/apps/gnomeradio/recording/destination", NULL); - if (!rec_settings.destination) - rec_settings.destination = g_strdup(g_get_home_dir()); - rec_settings.profile = gconf_client_get_string(client, "/apps/gnomeradio/recording/profile", NULL); - if (!rec_settings.profile) - rec_settings.profile = g_strdup("audio/x-vorbis"); - - /* Load the presets */ - count = gconf_client_get_int(client, "/apps/gnomeradio/presets/presets", NULL); - for (i = 0; i < count; i++) - { - ps = malloc(sizeof(preset)); - buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/name", i); - ps->title = gconf_client_get_string(client, buffer, NULL); - g_free(buffer); - if (!ps->title) - ps->title = g_strdup(_("unnamed")); - buffer = g_strdup_printf("/apps/gnomeradio/presets/%d/freqency", i); - freq = gconf_client_get_float(client, buffer, NULL); - if ((freq < FREQ_MIN) || (freq > FREQ_MAX)) - ps->freq = FREQ_MIN; - else - ps->freq = freq; - g_free(buffer); - settings.presets = g_list_prepend(settings.presets, (gpointer)ps); - } - settings.presets = g_list_reverse(settings.presets); - - mom_ps = gconf_client_get_int(client, "/apps/gnomeradio/presets/last", NULL); - if (mom_ps >= count) - mom_ps = -1; - - return TRUE; -} - -static void mute_on_exit_toggled_cb(GtkWidget* widget, gpointer data) -{ - settings.mute_on_exit = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mute_on_exit)); -} - -static void audio_loopback_set_visible (gboolean visible) -{ - gtk_widget_set_visible (audio_label, visible); - gtk_widget_set_visible (enabled, visible); - gtk_widget_set_visible (disabled, visible); -} - -static void audio_loopback_toggled_cb (GtkWidget* widget, gpointer data) -{ - settings.audio_loopback = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)); - - if (settings.audio_loopback) - start_radio(TRUE, data); - else - alsa_thread_stop(); -} - -static gboolean device_entry_activate_cb(GtkWidget *widget, gpointer data) -{ - const gchar *text; - - text = gtk_entry_get_text(GTK_ENTRY(device_entry)); - - if (!strcmp(settings.device, text) || (text[0] == '\0')) - return FALSE; - - if (settings.device) - g_free(settings.device); - - settings.device = g_strdup(text); - - start_radio(TRUE, data); - - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)) || - gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (disabled))) - audio_loopback_set_visible (radio_is_init()); - - return FALSE; -} - -static void -device_entry_auto_activate_cb(GtkEntry* entry, const gchar* text, gpointer data) -{ - GtkEditable *editable; - - editable = GTK_EDITABLE (entry); - - text = gtk_entry_get_text(GTK_ENTRY(device_entry)); - - autodetect = 0; - if (0 == strcmp(text, "auto")) { - g_signal_emit_by_name(G_OBJECT (editable), "activate"); - autodetect = 1; - - gtk_widget_grab_focus(add_button); - } -} - -static gboolean mixer_entry_activate_cb(GtkWidget *widget, gpointer data) -{ - const gchar *text; - - text = gtk_entry_get_text(GTK_ENTRY(mixer_entry)); - - if (!strcmp(settings.mixer, text) || (text[0] == '\0')) - return FALSE; - - if (settings.mixer) - g_free(settings.mixer); - - settings.mixer = g_strdup(text); - - start_mixer(TRUE, data); - - return FALSE; -} - -/*static gboolean bitrate_combo_change_cb(GtkComboBox *combo, gpointer data) -{ - GList *bitrates; - gint active; - gchar *bitrate; - - g_assert(combo); - bitrates = g_object_get_data(G_OBJECT(combo), "bitrates"); - active = gtk_combo_box_get_active(combo); - g_assert(active > -1); - - bitrate = (gchar*)g_list_nth_data(bitrates, active); - g_assert(bitrate); - - if (rec_settings.bitrate) g_free(rec_settings.bitrate); - rec_settings.bitrate = g_strdup(bitrate); - - return FALSE; -}*/ - -/*static gboolean encoder_combo_change_cb(GtkComboBox *combo, gpointer bitrate_combo) -{ - GList *encoders; - gint active; - gchar *encoder; - - g_assert(combo); - encoders = g_object_get_data(G_OBJECT(combo), "encoders"); - active = gtk_combo_box_get_active(combo); - g_assert(active > -1); - - encoder = (gchar*)g_list_nth_data(encoders, active); - g_assert(encoder); - - if (g_str_equal(encoder, _("Wave file"))) rec_settings.mp3 = FALSE; - else { - rec_settings.mp3 = TRUE; - if (rec_settings.encoder) g_free(rec_settings.encoder); - rec_settings.encoder = g_strdup(encoder); - } - gtk_widget_set_sensitive(bitrate_combo, rec_settings.mp3); - - return FALSE; -}*/ - -static void audio_profile_combo_change_cb(GtkWidget *widget, gpointer user_data) -{ - GtkTreeModel *model; - GtkTreeIter iter; - char *media_type = NULL; - GstEncodingProfile *profile; - - model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); - /* get selected media type */ - if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (widget), &iter) == FALSE) - return; - gtk_tree_model_get (GTK_TREE_MODEL (model), - &iter, - 0, &media_type, - 2, &profile, - -1); - - rec_settings.profile = g_strdup(media_type); - - /* indicate whether additional plugins are required to encode in this format */ - if (rb_gst_check_missing_plugins (profile, NULL, NULL)) { - gtk_widget_set_visible (install_button, TRUE); - - gtk_widget_set_sensitive (install_button, - gst_install_plugins_supported ()); - } else { - gtk_widget_set_visible (install_button, FALSE); - } - g_free (media_type); -} - -static void -audio_profile_chooser_set_active(GtkWidget *widget, const char *profile) -{ - GtkTreeIter iter; - GtkTreeModel *model; - gboolean done; - - done = FALSE; - model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); - if (gtk_tree_model_get_iter_first(model, &iter)) { - do { - char *media_type; - - gtk_tree_model_get(model, &iter, 0, &media_type, -1); - if (g_strcmp0(media_type, profile) == 0) { - gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), &iter); - done = TRUE; - } - g_free (media_type); - } while (done == FALSE && gtk_tree_model_iter_next(model, &iter)); - } - - if (done == FALSE) { - gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), NULL); - } -} - -static GtkWidget *audio_profile_choose_new(void) -{ - GstEncodingTarget *target; - const GList *p; - GtkWidget *combo; - GtkCellRenderer *renderer; - GtkTreeModel *model; - - model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER)); - - target = rb_gst_get_default_encoding_target(); - for (p = gst_encoding_target_get_profiles(target); p != NULL; p = p->next) { - GstEncodingProfile *profile = GST_ENCODING_PROFILE (p->data); - char *media_type; - - media_type = rb_gst_encoding_profile_get_media_type(profile); - if (media_type == NULL) { - continue; - } - gtk_tree_store_insert_with_values(GTK_TREE_STORE(model), - NULL, NULL, -1, - 0, media_type, - 1, gst_encoding_profile_get_description(profile), - 2, profile, -1); - g_free(media_type); - } - - combo = gtk_combo_box_new_with_model(model); - renderer = gtk_cell_renderer_text_new(); - gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE); - gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", 1, NULL); - - return GTK_WIDGET(combo); -} - -static void -audio_plugin_install_done_cb (gpointer inst, gboolean retry, gpointer user_data) -{ - audio_profile_combo_change_cb (audio_profile_combo, user_data); -} - -static void -audio_profile_install_plugins_cb (GtkWidget *widget, gpointer user_data) -{ - GstEncodingProfile *profile; - char **details; - GClosure *closure; - - /* get profile */ - profile = rb_gst_get_encoding_profile (rec_settings.profile); - if (profile == NULL) { - g_free (rec_settings.profile); - return; - } - g_free (rec_settings.profile); - - /* get plugin details */ - if (rb_gst_check_missing_plugins (profile, &details, NULL) == FALSE) { - return; - } - - /* attempt installation */ - closure = g_cclosure_new ((GCallback) audio_plugin_install_done_cb, - g_object_ref (audio_profile_combo), - (GClosureNotify) g_object_unref); - g_closure_set_marshal (closure, g_cclosure_marshal_VOID__BOOLEAN); - - rb_missing_plugins_install ((const char **)details, TRUE, closure); - - g_closure_sink (closure); - g_strfreev (details); -} - -static void add_button_clicked_cb(GtkWidget *widget, gpointer data) -{ - preset *ps; - gchar *buffer; - GtkTreeIter iter = {0}; - GtkAdjustment* v_scb; - GtkTreePath *path = NULL; - GtkWidget *menuitem; - - ps = malloc(sizeof(preset)); - ps->title = g_strdup(_("unnamed")); - ps->freq = rint(gtk_adjustment_get_value(adj)) / STEPS; - settings.presets = g_list_append(settings.presets, (gpointer) ps); - buffer = g_strdup_printf("%.2f", ps->freq); - - gtk_list_store_append(list_store, &iter); - gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, ps->title, 1, buffer, -1); - - g_free(buffer); - gtk_tree_selection_unselect_all(selection); - - v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); - gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); - - if (main_visible) { - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), ps->title); - mom_ps = g_list_length(settings.presets) - 1; - preset_combo_set_item(mom_ps); - - menuitem = gtk_menu_item_new_with_label(ps->title); - - gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, mom_ps); - g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); - gtk_widget_show(menuitem); - } - - buffer = g_strdup_printf("%d", g_list_length(settings.presets) - 1); - path = gtk_tree_path_new_from_string(buffer); - g_free(buffer); - gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); - gtk_tree_path_free(path); - - gtk_widget_set_sensitive(save_button, TRUE); -} - -static void remove_button_clicked_cb(GtkWidget *widget, gpointer data) -{ - GtkTreePath *path = NULL; - GtkTreeViewColumn *focus_column = NULL; - GtkTreeIter iter; - preset *ps; - int *row; - GList* menuitems; - GtkWidget *menuitem; - - gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); - - if (!path) return; - - row = gtk_tree_path_get_indices(path); - g_assert(row); - g_assert(*row < g_list_length(settings.presets)); - - ps = g_list_nth_data(settings.presets, *row); - g_assert(ps); - settings.presets = g_list_remove(settings.presets, (gpointer)ps); - g_free(ps->title); - g_free(ps); - - gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path); - gtk_list_store_remove(list_store, &iter); - - if (main_visible) { - gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); - if (--mom_ps < 0) mom_ps = 0; - if (settings.presets == NULL) mom_ps = -1; - preset_combo_set_item(mom_ps); - - menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); - g_assert(*row < g_list_length(menuitems)); - menuitem = g_list_nth_data(menuitems, *row); - gtk_widget_destroy(menuitem); - } - - gtk_tree_path_prev(path); - gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); - gtk_tree_path_free(path); - - if (settings.presets == NULL) { - gtk_widget_set_sensitive(save_button, FALSE); - } else { - gtk_widget_set_sensitive(save_button, TRUE); - } -} - -static void move_up_button_clicked_cb(GtkWidget * widget, gpointer data) -{ - GtkTreeIter iter, iter2; - GtkTreePath *path, *path2; - gint pos; - preset *ps; - int *row; - GList* menuitems; - GtkWidget *menuitem; - - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); - gtk_tree_selection_get_selected(selection, NULL, &iter); - path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); - - path2 = path; - gtk_tree_path_prev(path2); - - if (gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter2, path2)) { - // we have a previous entry... - gtk_list_store_swap(GTK_LIST_STORE(GTK_TREE_MODEL(list_store)), &iter, &iter2); - } - - row = gtk_tree_path_get_indices(path); - g_assert(row); - g_assert(*row < g_list_length(settings.presets)); - - ps = g_list_nth_data(settings.presets, *row); - g_assert(ps); - pos = g_list_index(settings.presets, (gpointer)ps); - pos++; - - settings.presets = g_list_remove(settings.presets, (gpointer)ps); - settings.presets = g_list_insert(settings.presets, (gpointer)ps, pos); - - if (main_visible) { - gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); - gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(preset_combo), *row + 2, ps->title); - mom_ps = *row; - preset_combo_set_item(mom_ps); - - menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); - g_assert(mom_ps < g_list_length(menuitems)); - menuitem = g_list_nth_data(menuitems, mom_ps); - gtk_widget_destroy(menuitem); - menuitem = gtk_menu_item_new_with_label(ps->title); - - gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, *row + 1); - g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); - gtk_widget_show(menuitem); - } - - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); - gtk_tree_path_free(path); - - if (pos - 1 <= 0) { - gtk_widget_set_sensitive(move_up_button, FALSE); - } else { - gtk_widget_set_sensitive(move_up_button, TRUE); - } - gtk_widget_set_sensitive(move_down_button, TRUE); -} - -static void move_down_button_clicked_cb(GtkWidget * widget, gpointer data) -{ - GtkTreeIter iter, iter2; - GtkTreePath *path, *path2; - gint pos, count; - preset *ps; - int *row; - GList* menuitems; - GtkWidget *menuitem; - - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); - gtk_tree_selection_get_selected(selection, NULL, &iter); - path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); - - path2 = path; - gtk_tree_path_next(path2); - - if (gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter2, path2)) { - // we have a next entry... - gtk_list_store_swap(GTK_LIST_STORE(GTK_TREE_MODEL(list_store)), &iter, &iter2); - } - - row = gtk_tree_path_get_indices(path); - g_assert(row); - g_assert(*row < g_list_length(settings.presets)); - - ps = g_list_nth_data(settings.presets, *row); - g_assert(ps); - - count = g_list_length(settings.presets); - pos = g_list_index(settings.presets, (gpointer)ps); - pos--; - if (pos == count) - pos = 0; - - settings.presets = g_list_remove(settings.presets, (gpointer)ps); - settings.presets = g_list_insert(settings.presets, (gpointer)ps, pos); - - if (main_visible) { - gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); - gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(preset_combo), *row, ps->title); - mom_ps = *row; - preset_combo_set_item(mom_ps); - - menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); - g_assert(mom_ps < g_list_length(menuitems)); - menuitem = g_list_nth_data(menuitems, mom_ps); - gtk_widget_destroy(menuitem); - menuitem = gtk_menu_item_new_with_label(ps->title); - - gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, *row - 1); - g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); - gtk_widget_show(menuitem); - } - - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); - gtk_tree_path_free(path); - - if (pos + 2 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) { - gtk_widget_set_sensitive(move_down_button, FALSE); - } else { - gtk_widget_set_sensitive(move_down_button, TRUE); - } - gtk_widget_set_sensitive(move_up_button, TRUE); -} - -static void destination_button_clicked_cb(GtkWidget *button, gpointer data) -{ - if (rec_settings.destination) - { - g_free(rec_settings.destination); - } - rec_settings.destination = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(button)); -} - -static gboolean list_view_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data) -{ - if (event->keyval == GDK_KEY_Delete) - remove_button_clicked_cb(widget, user_data); - if (event->keyval == GDK_KEY_Insert) - add_button_clicked_cb(widget, user_data); - - return FALSE; -} - -static gboolean button_release_cb(GtkWidget *widget, GdkEvent *event, gpointer data) -{ - GtkTreePath *path; - gint pos; - GdkEventButton *event_button; - gchar *buffer; - - event_button = (GdkEventButton *) event; - - gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(list_view), event_button->x, event_button->y, &path, NULL, NULL, NULL); - if (path != NULL) { - buffer = gtk_tree_path_to_string(path); - pos = (gint) g_strtod(buffer, NULL); - g_free(buffer); - gtk_tree_path_free(path); - - if (pos == 0) { - gtk_widget_set_sensitive(move_up_button, FALSE); - } else { - gtk_widget_set_sensitive(move_up_button, TRUE); - } - - if (pos + 1 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) { - gtk_widget_set_sensitive(move_down_button, FALSE); - } else { - gtk_widget_set_sensitive(move_down_button, TRUE); - } - } - return FALSE; -} - -static void name_cell_edited_cb(GtkCellRendererText *cellrenderertext, gchar *path_str, gchar *new_val, gpointer user_data) -{ - GtkTreePath *path = NULL; - GtkTreeIter iter; - preset *ps; - int *row; - GList* menuitems; - GtkWidget *menuitem; - - path = gtk_tree_path_new_from_string(path_str); - - row = gtk_tree_path_get_indices(path); - g_assert(row); - g_assert(*row < g_list_length(settings.presets)); - - ps = g_list_nth_data(settings.presets, *row); - g_assert(ps); - if (ps->title) g_free(ps->title); - ps->title = g_strdup(new_val); - - if (main_visible) { - gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1); - gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(preset_combo), *row + 1, ps->title); - mom_ps = *row; - preset_combo_set_item(mom_ps); - - menuitems = gtk_container_get_children(GTK_CONTAINER(tray_menu)); - g_assert(mom_ps < g_list_length(menuitems)); - menuitem = g_list_nth_data(menuitems, mom_ps); - gtk_widget_destroy(menuitem); - menuitem = gtk_menu_item_new_with_label(ps->title); - - gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, *row); - g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (mom_ps)); - gtk_widget_show(menuitem); - } - - gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path); - gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, new_val, -1); - gtk_tree_path_free(path); -} - -static void freq_cell_edited_cb(GtkCellRendererText *cellrenderertext, gchar *path_str, gchar *new_val, gpointer user_data) -{ - GtkTreePath *path = NULL; - GtkTreeIter iter; - preset *ps; - int *row; - double value; - gchar *freq_str; - - if (sscanf(new_val, "%lf", &value) != 1) return; - - if (value < FREQ_MIN) value = FREQ_MIN; - if (value > FREQ_MAX) value = FREQ_MAX; - value = rint(value * STEPS) / STEPS; - - freq_str = g_strdup_printf("%.2f", value); - - path = gtk_tree_path_new_from_string(path_str); - - row = gtk_tree_path_get_indices(path); - g_assert(row); - g_assert(*row < g_list_length(settings.presets)); - - ps = g_list_nth_data(settings.presets, *row); - g_assert(ps); - ps->freq = value; - - gtk_adjustment_set_value(adj, value * STEPS); - mom_ps = *row; - preset_combo_set_item(mom_ps); - - gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path); - gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 1, freq_str, -1); - g_free(freq_str); - gtk_tree_path_free(path); -} - -static void list_view_cursor_changed_cb(GtkWidget *widget, gpointer data) -{ - int *row; - preset *ps; - gint pos; - GtkTreePath *path = NULL; - GtkTreeViewColumn *focus_column = NULL; - - if (settings.presets == NULL) - return; - - gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); - - if (!path) - return; - - row = gtk_tree_path_get_indices(path); - g_assert(row); - - mom_ps = *row; - preset_combo_set_item(mom_ps); - - ps = g_list_nth_data(settings.presets, *row); - g_assert(ps); - - pos = g_list_index(settings.presets, (gpointer)ps); - - if (pos == 0) { - gtk_widget_set_sensitive(move_up_button, FALSE); - } else { - gtk_widget_set_sensitive(move_up_button, TRUE); - } - - if (pos + 1 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) { - gtk_widget_set_sensitive(move_down_button, FALSE); - } else { - gtk_widget_set_sensitive(move_down_button, TRUE); - } - gtk_tree_path_free(path); - return; -} - -static void list_view_selection_changed_cb(GtkWidget *widget, gpointer data) -{ - gboolean sel; - - sel = gtk_tree_selection_get_selected(selection, NULL, NULL); - - gtk_widget_set_sensitive(remove_button, sel); - gtk_widget_set_sensitive(save_button, sel); -} - -static void list_view_scroll_to_active_preset_cb(GtkWidget *widget, gpointer data) -{ - GtkTreePath *path = NULL; - GtkTreeIter iter; - gint active; - - if (settings.presets == NULL) { - gtk_widget_grab_focus(add_button); - return; - } - - active = gtk_combo_box_get_active(GTK_COMBO_BOX(preset_combo)) - 1; - - if (active < 0) { - gtk_widget_grab_focus(add_button); - return; - } - - if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, active)) - return; - - path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); - - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list_view), path, NULL, FALSE, 0, 0); - gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); - gtk_tree_path_free(path); - - gtk_widget_grab_focus(list_view); -} - -static void free_presets_list (gpointer data) -{ - preset *ps = (preset *) data; - g_free (ps->title); - g_free (ps); -} - -/* Go through each row and add its data to the xmlDocPtr */ -static gboolean save_to_file_foreach(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, xmlNodePtr root, gpointer user_data) -{ - gchar *title, *freq, *position; - xmlNodePtr current; - - /* get the data stored in the model... */ - gtk_tree_model_get(model, iter, 0, &title, 1, &freq, -1); - /* ...and get the path of the current row */ - position = gtk_tree_path_to_string(path); - /* create a new child of the root node... */ - /* (note that I'm using a (guchar*) cast; this is because it's the same thing as - * an (xmlChar*) cast, but easier to type) */ - current = xmlNewChild(root, NULL, (guchar*)"station", NULL); - /* ...and set some properties */ - xmlSetProp(current, (guchar*)"name", (guchar*)title); - xmlSetProp(current, (guchar*)"freq", (guchar*)freq); - xmlSetProp(current, (guchar*)"position", (guchar*)position); - /* free our data we retrieved from the model */ - g_free(title); - g_free(freq); - g_free(position); - - /* return FALSE to keep iterating */ - return FALSE; -} - -/* Function handle saving an xml file; calls save_to_file_foreach */ -static void save_to_file(gchar *filename) -{ - GtkTreeModel *model; - xmlDocPtr doc; - xmlNodePtr root; - - /* create a new doc node */ - doc = xmlNewDoc((guchar*)"1.0"); - /* create a new root element. */ - root = xmlNewDocNode(doc, NULL, (guchar*)"gnomeradio", NULL); - /* set it as the root element */ - xmlDocSetRootElement(doc, root); - /* get the tree view's model... */ - model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); - /* ...and go through it with a foreach */ - gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc)save_to_file_foreach, (gpointer)root); - /* save the actual file */ - xmlSaveFile(filename, doc); - /* free the doc node */ - xmlFreeDoc(doc); -} - -/* Callback for the "Save to file" button; calls save_to_file */ -static void save_to_file_cb(GtkWidget *button, gpointer data) -{ - GtkWidget *dialog; - GtkFileFilter *file_filter_all; - GtkFileFilter *file_filter_xml; - gchar *filename; - - dialog = gtk_file_chooser_dialog_new (_("Select file name\xE2\x80\xA6"), NULL, - GTK_FILE_CHOOSER_ACTION_SAVE, - _("_Save"), GTK_RESPONSE_ACCEPT, - _("_Cancel"), GTK_RESPONSE_CANCEL, - NULL); - - file_filter_all = gtk_file_filter_new(); - gtk_file_filter_set_name(file_filter_all, _("All Files")); - gtk_file_filter_add_pattern(file_filter_all, "*"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_all); - - file_filter_xml = gtk_file_filter_new(); - gtk_file_filter_set_name(file_filter_xml, _("XML Files (*.xml)")); - gtk_file_filter_add_pattern(file_filter_xml, "*.xml"); - gtk_file_filter_add_pattern(file_filter_xml, "*.XML"); - gtk_file_filter_add_mime_type(file_filter_xml, "text/xml"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); - - gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE); - gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); - gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "gnomeradio.xml"); - - if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { - filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); - /* Check if .xml extension is added, if not add */ - if (!g_str_has_suffix(filename, ".xml")) { - char *tmp_file; - /* create copy of filename to release it and create a new one, using old name */ - tmp_file = g_strdup(filename); - g_free(filename); - filename = g_strdup_printf("%s.xml", tmp_file); - g_free(tmp_file); - } - save_to_file(filename); - g_free(filename); - } - gtk_widget_destroy(dialog); -} - -/* Gets the parent of a path string. -* passing "0:1:2" would return "0:1", -* passing "0:1" would return "0", -* passing "0" would return NULL */ -gchar *gtk_tree_path_string_get_parent(gchar *path) -{ - gchar *colon; - - g_return_val_if_fail(path != NULL, NULL); - - colon = g_strrstr(path, ":"); - if (colon == NULL) - return NULL; - - return g_strndup(path, colon - path); -} - -/* Make sure that path exists within model */ -static void gtk_tree_model_generate_path(GtkTreeModel *model, gchar *path) -{ - GtkTreeIter iter, parent; - gchar *temp; - - while (TRUE) { - /* if this returns TRUE, then this path exists and we're fine */ - if (gtk_tree_model_get_iter_from_string(model, &iter, path)) - break; - - temp = path; - path = gtk_tree_path_string_get_parent(path); - /* if there's no parent, then it's toplevel */ - if (path == NULL) { - if (GTK_IS_TREE_STORE(model)) - gtk_tree_store_append(GTK_TREE_STORE(model), &parent, NULL); - else - gtk_list_store_append(GTK_LIST_STORE(model), &parent); - gtk_tree_model_generate_path(model, temp); - break; - } - if (GTK_IS_TREE_STORE(model)) { - gtk_tree_model_generate_path(model, path); - gtk_tree_model_get_iter_from_string(model, &parent, path); - gtk_tree_store_append(GTK_TREE_STORE(model), &iter, &parent); - } - } -} - -/* Function to load from an xml file */ -static void load_from_file(gchar *filename) -{ - xmlDocPtr doc; - xmlNodePtr current; - xmlChar *title, *freq, *position; - GtkTreeModel *model; - GtkTreePath *path = NULL; - GtkTreeIter iter; - GtkAdjustment* v_scb; - GList* menuitems; - GtkWidget *menuitem; - - /* load the file */ - doc = xmlParseFile(filename); - /* get the root item */ - if (doc == NULL) - return; - - current = xmlDocGetRootElement(doc); - if (current == NULL) { - xmlFreeDoc(doc); - return; - } - - if (xmlStrcmp(current->name, (guchar*)"gnomeradio")) { - xmlFreeDoc(doc); - return; - } - - /* remove previous presets */ - if (settings.presets != NULL) { - if (main_visible) { - gint i, count; - - count = g_list_length (settings.presets); - for (i = 0; i < count; i++) - gtk_combo_box_text_remove(GTK_COMBO_BOX_TEXT(preset_combo), 1); - - menuitems = gtk_container_get_children (GTK_CONTAINER (tray_menu)); - - count = g_list_length (menuitems); - for (i = 0; i < count - 6; i++) { - menuitem = g_list_nth_data (menuitems, i); - gtk_widget_destroy (menuitem); - } - } - - gtk_list_store_clear(GTK_LIST_STORE(list_store)); - - g_list_free_full (settings.presets, free_presets_list); - settings.presets = NULL; - } - - /* get the tree view's model */ - model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); - - /* iterate through the root's children items */ - current = current->xmlChildrenNode; - while (current) { - if(!xmlIsBlankNode(current)) { - /* check for the proper element name */ - if (!xmlStrcmp(current->name, (guchar*)"station")) { - /* get the saved properties */ - title = xmlGetProp(current, (guchar*)"name"); - freq = xmlGetProp(current, (guchar*)"freq"); - position = xmlGetProp(current, (guchar*)"position"); - - if( title && freq && position ) { - preset *ps = g_malloc0(sizeof(preset)); - ps->title = g_strdup((gchar*)title); - ps->freq = atof((gchar*)freq); - - settings.presets = g_list_append(settings.presets, ps); - - /* make sure that the path exists */ - gtk_tree_model_generate_path(model, (gchar*)position); - /* get an iter to the path */ - gtk_tree_model_get_iter_from_string(model, &iter, (gchar*)position); - /* set the data */ - gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, title, 1, freq, -1); - - gtk_tree_selection_unselect_all(selection); - - v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); - gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); - - if (main_visible) { - gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(preset_combo), ps->title); - mom_ps = g_list_length(settings.presets) - 1; - preset_combo_set_item(mom_ps); - - menuitem = gtk_menu_item_new_with_label(ps->title); - - gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, mom_ps); - g_signal_connect(G_OBJECT(menuitem), "activate", - (GCallback)preset_menuitem_activate_cb, - GINT_TO_POINTER (mom_ps)); - gtk_widget_show(menuitem); - } - } - /* free the data */ - xmlFree(title); - xmlFree(freq); - xmlFree(position); - } - current = current->next; - } - } - /* free the doc node */ - xmlFreeDoc(doc); - - if (settings.presets == NULL) - return; - - path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); - - gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); - gtk_tree_path_free(path); - - gtk_widget_grab_focus(list_view); - - list_view_cursor_changed_cb(list_view, NULL); - gtk_widget_set_sensitive(save_button, TRUE); - gtk_widget_set_sensitive(remove_button, TRUE); -} - -/* Callback for the "Load from file" button; calls load_from_file */ -static void load_from_file_cb(GtkWidget *button, gpointer data) -{ - GtkWidget *dialog; - GtkFileFilter *file_filter_all; - GtkFileFilter *file_filter_xml; - gchar *filename; - - dialog = gtk_file_chooser_dialog_new (_("Select file name\xE2\x80\xA6"), NULL, - GTK_FILE_CHOOSER_ACTION_OPEN, - _("_Open"), GTK_RESPONSE_ACCEPT, - _("_Cancel"), GTK_RESPONSE_CANCEL, - NULL); - - file_filter_all = gtk_file_filter_new(); - gtk_file_filter_set_name(file_filter_all, _("All Files")); - gtk_file_filter_add_pattern(file_filter_all, "*"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_all); - - file_filter_xml = gtk_file_filter_new(); - gtk_file_filter_set_name(file_filter_xml, _("XML Files")); - gtk_file_filter_add_pattern(file_filter_xml, "*.xml"); - gtk_file_filter_add_pattern(file_filter_xml, "*.XML"); - gtk_file_filter_add_mime_type(file_filter_xml, "text/xml"); - gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); - - gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), file_filter_xml); - - if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { - filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); - load_from_file(filename); - g_free(filename); - } - gtk_widget_destroy(dialog); -} - -gboolean action_mode (gint mode) -{ - switch (mode) { - case RADIO_DEVICE: - gtk_widget_grab_focus (device_entry); - break; - case MIXER_DEVICE: - gtk_widget_grab_focus (mixer_entry); - break; - case PRESETS: - list_view_scroll_to_active_preset_cb(list_view, NULL); - break; - default: - break; - } - - return TRUE; -} - -GtkWidget* prefs_window(GtkWidget *app) -{ - GtkWidget *dialog; - GtkWidget *content_area; - GtkWidget *box; - GtkWidget *grid; - GtkWidget *label; - GtkWidget *scrolled_window; - GtkCellRenderer *cellrenderer; - GtkTreeViewColumn *list_column; - GtkWidget *button_box; - GtkWidget *open_button; - GtkWidget *destination_button; - GtkWidget *image; - - GstEncodingProfile *profile; - - gint i; - gchar *markup; - preset* ps; - GList *l; - - dialog = gtk_dialog_new_with_buttons (_("Gnomeradio Settings"), GTK_WINDOW (app), - GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, - _("_Close"), GTK_RESPONSE_CLOSE, - _("_Help"), GTK_RESPONSE_HELP, - NULL); - - gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); - gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); - - content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog)); - - box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); - gtk_container_set_border_width(GTK_CONTAINER(box), 10); - gtk_box_pack_start (GTK_BOX (content_area), box, TRUE, TRUE, 0); - - grid = gtk_grid_new(); - gtk_grid_set_row_spacing(GTK_GRID(grid), 5); - gtk_grid_set_column_spacing(GTK_GRID(grid), 40); - gtk_box_pack_start(GTK_BOX(box), grid, TRUE, TRUE, 0); - - /* The general settings part */ - label = gtk_label_new (NULL); - gtk_widget_set_halign (label, GTK_ALIGN_START); - markup = g_strdup_printf ("%s", _("General Settings")); - gtk_label_set_markup (GTK_LABEL (label), markup); - g_free (markup); - gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 1, 1); - - label = gtk_label_new (_("Radio device:")); - gtk_widget_set_halign (label, GTK_ALIGN_START); - gtk_widget_set_margin_left (label, 10); - gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); - - device_entry = gtk_entry_new(); - - if (autodetect) - gtk_entry_set_placeholder_text(GTK_ENTRY(device_entry), "auto"); - else - gtk_entry_set_text(GTK_ENTRY(device_entry), settings.device); - - gtk_grid_attach(GTK_GRID(grid), device_entry, 1, 1, 1, 1); - - label = gtk_label_new (_("Mixer source:")); - gtk_widget_set_halign (label, GTK_ALIGN_START); - gtk_widget_set_margin_left (label, 10); - gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); - - mixer_entry = gtk_entry_new(); - gtk_entry_set_text(GTK_ENTRY(mixer_entry), settings.mixer); - gtk_grid_attach(GTK_GRID(grid), mixer_entry, 1, 2, 1, 1); - - audio_label = gtk_label_new (_("Audio Loopback mode")); - gtk_widget_set_no_show_all (audio_label, TRUE); - gtk_widget_set_halign (audio_label, GTK_ALIGN_START); - gtk_widget_set_margin_left (audio_label, 10); - gtk_grid_attach (GTK_GRID (grid), audio_label, 0, 3, 1, 1); - - box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - - enabled = gtk_radio_button_new_with_label (NULL, _("Enabled")); - gtk_widget_set_no_show_all (enabled, TRUE); - disabled = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (enabled), _("Disabled")); - gtk_widget_set_no_show_all (disabled, TRUE); - gtk_box_pack_start (GTK_BOX (box), enabled, TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX (box), disabled, TRUE, TRUE, 0); - gtk_grid_attach(GTK_GRID(grid), box, 1, 3, 1, 1); - - /* Enabled from radio button or else from command line */ - if (settings.audio_loopback || alsa_loopback) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enabled), TRUE); - else - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (disabled), TRUE); - - if (settings.audio_loopback) - if (alsa_loopback) - audio_loopback_set_visible (TRUE); - else - audio_loopback_set_visible (FALSE); - else - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)) || - gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (disabled))) - audio_loopback_set_visible (radio_is_init()); - - mute_on_exit = gtk_check_button_new_with_label(_("Mute on exit")); - gtk_widget_set_margin_left (mute_on_exit, 10); - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mute_on_exit), settings.mute_on_exit); - gtk_grid_attach(GTK_GRID(grid), mute_on_exit, 0, 4, 2, 1); - - g_signal_connect(G_OBJECT(device_entry), "hide", G_CALLBACK(device_entry_activate_cb), app); - g_signal_connect(G_OBJECT(device_entry), "activate", G_CALLBACK(device_entry_activate_cb), NULL); - g_signal_connect(G_OBJECT(device_entry), "changed", G_CALLBACK(device_entry_auto_activate_cb), NULL); - g_signal_connect(G_OBJECT(mixer_entry), "hide", G_CALLBACK(mixer_entry_activate_cb), app); - g_signal_connect(G_OBJECT(mixer_entry), "activate", G_CALLBACK(mixer_entry_activate_cb), NULL); - g_signal_connect(G_OBJECT(enabled), "toggled", G_CALLBACK(audio_loopback_toggled_cb), NULL); - g_signal_connect(G_OBJECT(mute_on_exit), "toggled", G_CALLBACK(mute_on_exit_toggled_cb), NULL); - - gtk_widget_set_tooltip_text(device_entry, _("The radio device to use (e.g. /dev/radio0)")); - gtk_widget_set_tooltip_text(mixer_entry, _("The mixer device and channel to use (e.g. hw:0/Line)")); - gtk_widget_set_tooltip_text(disabled, _("Stop audio streaming between the radio device and the audio output device")); - gtk_widget_set_tooltip_text(enabled, _("Start an audio streaming between the radio device and the audio output device")); - gtk_widget_set_tooltip_text(mute_on_exit, _("Mute radio device on exit")); - - /* The presets part */ - label = gtk_label_new (NULL); - gtk_widget_set_halign (label, GTK_ALIGN_START); - markup = g_strdup_printf ("%s", _("Presets")); - gtk_label_set_markup (GTK_LABEL (label), markup); - g_free (markup); - gtk_grid_attach(GTK_GRID(grid), label, 0, 5, 1, 1); - - scrolled_window = gtk_scrolled_window_new(NULL, NULL); - gtk_widget_set_margin_left (scrolled_window, 10); - gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled_window), 75); - gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); - - list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); - list_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); - gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(list_view), TRUE); - gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list_view), FALSE); - - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); - gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); - gtk_container_add(GTK_CONTAINER(scrolled_window), list_view); - - g_signal_connect(G_OBJECT(list_view), "button-release-event", G_CALLBACK(button_release_cb), NULL); - g_signal_connect(G_OBJECT(list_view), "key-press-event", G_CALLBACK(list_view_key_press_event_cb), NULL); - g_signal_connect(G_OBJECT(list_view), "cursor-changed", G_CALLBACK(list_view_cursor_changed_cb), NULL); - - g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(list_view_selection_changed_cb), list_view); - - /*gtk_tree_selection_select_path(selection, gtk_tree_path_new_from_string("0")); - gtk_tree_selection_set_select_function(selection, (GtkTreeSelectionFunc)list_view_select_cb, NULL, NULL);*/ - - cellrenderer = gtk_cell_renderer_text_new(); - g_object_set(G_OBJECT(cellrenderer), "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL); - g_object_set(G_OBJECT(GTK_CELL_RENDERER_TEXT(cellrenderer)), "editable", TRUE, NULL); - list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 0, NULL); - gtk_tree_view_column_set_reorderable(list_column, TRUE); - gtk_tree_view_column_set_expand(list_column, TRUE); - gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); - - g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(name_cell_edited_cb), NULL); - - cellrenderer = gtk_cell_renderer_text_new(); - g_object_set(G_OBJECT(cellrenderer), "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL); - g_object_set(G_OBJECT(cellrenderer), "xalign", 1.0, NULL); - g_object_set(G_OBJECT(GTK_CELL_RENDERER_TEXT(cellrenderer)), "editable", TRUE, NULL); - list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 1, NULL); - gtk_tree_view_column_set_reorderable(list_column, TRUE); - gtk_tree_view_column_set_expand(list_column, FALSE); - gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); - - g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(freq_cell_edited_cb), NULL); - - i = 0; - for (l = settings.presets; l != NULL; l = l->next) { - GtkTreeIter iter = {0}; - char *buffer; - ps = l->data; - buffer = g_strdup_printf("%0.2f", ps->freq); - gtk_list_store_append(list_store, &iter); - gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0, ps->title, 1, buffer, -1); - g_free(buffer); - i++; - } - - gtk_grid_attach(GTK_GRID(grid), scrolled_window, 0, 6, 2, 1); - - button_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); - - move_up_button = gtk_button_new(); - image = gtk_image_new_from_icon_name ("go-up", GTK_ICON_SIZE_MENU); - gtk_button_set_image (GTK_BUTTON (move_up_button), image); - gtk_button_set_relief (GTK_BUTTON (move_up_button), GTK_RELIEF_NONE); - gtk_widget_set_sensitive(move_up_button, FALSE); - gtk_widget_set_tooltip_text(move_up_button, _("Move preset up")); - - g_signal_connect(G_OBJECT(move_up_button), "clicked", G_CALLBACK(move_up_button_clicked_cb), NULL); - - move_down_button = gtk_button_new(); - image = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_MENU); - gtk_button_set_image (GTK_BUTTON (move_down_button), image); - gtk_button_set_relief (GTK_BUTTON (move_down_button), GTK_RELIEF_NONE); - gtk_widget_set_sensitive(move_down_button, FALSE); - gtk_widget_set_tooltip_text(move_down_button, _("Move preset down")); - - g_signal_connect(G_OBJECT(move_down_button), "clicked", G_CALLBACK(move_down_button_clicked_cb), NULL); - - add_button = gtk_button_new(); - image = gtk_image_new_from_icon_name ("list-add", GTK_ICON_SIZE_MENU); - gtk_button_set_image (GTK_BUTTON(add_button), image); - gtk_button_set_relief (GTK_BUTTON (add_button), GTK_RELIEF_NONE); - gtk_widget_set_tooltip_text(add_button, _("Add preset")); - - g_signal_connect(G_OBJECT(add_button), "clicked", G_CALLBACK(add_button_clicked_cb), NULL); - - remove_button = gtk_button_new(); - image = gtk_image_new_from_icon_name ("list-remove", GTK_ICON_SIZE_MENU); - gtk_button_set_image (GTK_BUTTON (remove_button), image); - gtk_button_set_relief (GTK_BUTTON (remove_button), GTK_RELIEF_NONE); - gtk_widget_set_tooltip_text(remove_button, _("Remove preset")); - gtk_widget_set_sensitive(remove_button, FALSE); - - g_signal_connect(G_OBJECT(remove_button), "clicked", G_CALLBACK(remove_button_clicked_cb), NULL); - - save_button = gtk_button_new(); - image = gtk_image_new_from_icon_name ("document-save", GTK_ICON_SIZE_MENU); - gtk_button_set_image (GTK_BUTTON (save_button), image); - gtk_button_set_relief (GTK_BUTTON (save_button), GTK_RELIEF_NONE); - gtk_widget_set_tooltip_text(save_button, _("Save to file\xE2\x80\xA6")); - - if (settings.presets == NULL) - gtk_widget_set_sensitive (save_button, FALSE); - else - gtk_widget_set_sensitive (save_button, TRUE); - - g_signal_connect(G_OBJECT(save_button), "clicked", G_CALLBACK(save_to_file_cb), NULL); - - open_button = gtk_button_new(); - image = gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_MENU); - gtk_button_set_image (GTK_BUTTON(open_button), image); - gtk_button_set_relief (GTK_BUTTON (open_button), GTK_RELIEF_NONE); - gtk_widget_set_tooltip_text(open_button, _("Load from file\xE2\x80\xA6")); - gtk_widget_set_sensitive(open_button, TRUE); - - g_signal_connect(G_OBJECT(open_button), "clicked", G_CALLBACK(load_from_file_cb), NULL); - - gtk_box_pack_end(GTK_BOX(button_box), move_down_button, FALSE, FALSE, 0); - gtk_box_pack_end(GTK_BOX(button_box), move_up_button, FALSE, FALSE, 0); - gtk_box_pack_end(GTK_BOX(button_box), remove_button, FALSE, FALSE, 0); - gtk_box_pack_end(GTK_BOX(button_box), add_button, FALSE, FALSE, 0); - gtk_box_pack_end(GTK_BOX(button_box), save_button, FALSE, FALSE, 0); - gtk_box_pack_end(GTK_BOX(button_box), open_button, FALSE, FALSE, 0); - - gtk_grid_attach(GTK_GRID(grid), button_box, 1, 7, 1, 1); - - /* The record settings part */ - label = gtk_label_new (NULL); - gtk_widget_set_halign (label, GTK_ALIGN_START); - markup = g_strdup_printf ("%s", _("Record Settings")); - gtk_label_set_markup (GTK_LABEL (label), markup); - g_free (markup); - gtk_grid_attach (GTK_GRID (grid), label, 0, 8, 1, 1); - - label = gtk_label_new (_("Destination:")); - gtk_widget_set_halign (label, GTK_ALIGN_START); - gtk_widget_set_margin_left (label, 10); - gtk_grid_attach(GTK_GRID(grid), label, 0, 9, 1, 1); - - destination_button = gtk_file_chooser_button_new (_("Select a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); - gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(destination_button), rec_settings.destination); - gtk_grid_attach(GTK_GRID(grid), destination_button, 1, 9, 1, 1); - - label = gtk_label_new (_("Output format:")); - gtk_widget_set_halign (label, GTK_ALIGN_START); - gtk_widget_set_margin_left (label, 10); - gtk_grid_attach (GTK_GRID (grid), label, 0, 10, 1, 1); - - audio_profile_combo = audio_profile_choose_new(); - audio_profile_chooser_set_active(audio_profile_combo, rec_settings.profile); - gtk_grid_attach (GTK_GRID (grid), audio_profile_combo, 1, 10, 1, 1); - - install_button = gtk_button_new_with_label(_("Install additional software required to use this format")); - gtk_widget_set_no_show_all (install_button, TRUE); - gtk_grid_attach (GTK_GRID (grid), install_button, 1, 11, 1, 1); - - profile = rb_gst_get_encoding_profile (rec_settings.profile); - if (rb_gst_check_missing_plugins (profile, NULL, NULL)) { - gtk_widget_set_visible (install_button, TRUE); - gtk_widget_set_sensitive (install_button, - gst_install_plugins_supported ()); - } else { - gtk_widget_set_visible (install_button, FALSE); - } - - g_signal_connect(GTK_FILE_CHOOSER(destination_button), "selection-changed", G_CALLBACK(destination_button_clicked_cb), NULL); - g_signal_connect(G_OBJECT(audio_profile_combo), "changed", G_CALLBACK(audio_profile_combo_change_cb), NULL); - g_signal_connect(G_OBJECT(install_button), "clicked", G_CALLBACK(audio_profile_install_plugins_cb), NULL); - - gtk_widget_set_tooltip_text(destination_button, _("Select a location where to save recorded file.")); - gtk_widget_set_tooltip_text(audio_profile_combo, _("Choose the format that should be used for recording.")); - - gtk_widget_show_all(dialog); - - return dialog; -} === added file '.pc/gnomeradio-tray_menu.patch/src/prefs.h' --- .pc/gnomeradio-tray_menu.patch/src/prefs.h 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/prefs.h 2013-10-03 19:38:23 +0000 @@ -0,0 +1,39 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef _PREFS_H +#define _PREFS_H + +#include + +gboolean save_settings(void); + +gboolean load_settings(void); + +gboolean audio_box_set_visible (gboolean visible); + +enum +{ + RADIO_DEVICE, + MIXER_DEVICE, + PRESETS +}; + +gboolean action_mode (gint mode); + +GtkWidget* prefs_window(GtkWidget *app); + +#endif === removed file '.pc/gnomeradio-tray_menu.patch/src/prefs.h' --- .pc/gnomeradio-tray_menu.patch/src/prefs.h 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/prefs.h 1970-01-01 00:00:00 +0000 @@ -1,36 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Library General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#ifndef _PREFS_H -#define _PREFS_H - -#include - -gboolean save_settings(void); -gboolean load_settings(void); - -enum -{ - RADIO_DEVICE, - MIXER_DEVICE, - PRESETS -}; - -gboolean action_mode (gint mode); - -GtkWidget* prefs_window(GtkWidget *app); - -#endif === added file '.pc/gnomeradio-tray_menu.patch/src/record.c' --- .pc/gnomeradio-tray_menu.patch/src/record.c 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/record.c 2013-10-03 19:38:23 +0000 @@ -0,0 +1,317 @@ +/* record.c + * + * Copyright (C) 2001 Jörgen Scheibengruber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + +/*** the recording functionality */ + +#include + +#include +#include +#include +#include +#include "gui.h" +#include "rec_tech.h" +#include "prefs.h" + +extern GtkWidget *level; + +static GtkWidget *status_dialog; +static GtkWidget *file_lbl; +static GtkWidget *type_lbl; +static GtkWidget *size_lbl; +static GtkWidget *length_lbl; + +static int timeout_id = -1; + +void close_status_window(void) +{ + if (timeout_id >= 0) { + g_source_remove (timeout_id); + timeout_id = -1; + } + + if (status_dialog) + gtk_widget_destroy(GTK_WIDGET(status_dialog)); + status_dialog = NULL; + + tray_icon_items_set_sensible(TRUE); + recording_set_sensible(TRUE); +} + +static char *seconds_to_full_string (guint seconds) +{ + long days, hours, minutes; + char *time = NULL; + const char *minutefmt; + const char *hourfmt; + const char *secondfmt; + + days = seconds / (60 * 60 * 24); + hours = (seconds / (60 * 60)); + minutes = (seconds / 60) - ((days * 24 * 60) + (hours * 60)); + seconds = seconds % 60; + + minutefmt = ngettext ("%ld minute", "%ld minutes", minutes); + hourfmt = ngettext ("%ld hour", "%ld hours", hours); + secondfmt = ngettext ("%ld second", "%ld seconds", seconds); + + if (hours > 0) { + if (minutes > 0) + if (seconds > 0) { + char *fmt; + /* Translators: the format is "X hours X minutes X seconds" */ + fmt = g_strdup_printf (_("%s %s %s"), hourfmt, minutefmt, secondfmt); + time = g_strdup_printf (fmt, hours, minutes, seconds); + g_free (fmt); + } else { + char *fmt; + /* Translators: the format is "X hours X minutes" */ + fmt = g_strdup_printf (_("%s %s"), hourfmt, minutefmt); + time = g_strdup_printf (fmt, hours, minutes); + g_free (fmt); + } + else + if (seconds > 0) { + char *fmt; + /* Translators: the format is "X minutes X seconds" */ + fmt = g_strdup_printf (_("%s %s"), minutefmt, secondfmt); + time = g_strdup_printf (fmt, minutes, seconds); + g_free (fmt); + } else { + time = g_strdup_printf (minutefmt, minutes); + } + } else { + if (minutes > 0) { + if (seconds > 0) { + char *fmt; + /* Translators: the format is "X minutes X seconds" */ + fmt = g_strdup_printf (_("%s %s"), minutefmt, secondfmt); + time = g_strdup_printf (fmt, minutes, seconds); + g_free (fmt); + } else { + time = g_strdup_printf (minutefmt, minutes); + } + + } else { + time = g_strdup_printf (secondfmt, seconds); + } + } + + return time; +} + +static gboolean timeout_cb (gpointer data) +{ + Recording *recording = data; + + g_assert (recording); + + if (!gtk_widget_get_visible (status_dialog)) + gtk_widget_show_all (status_dialog); + + GFileInfo *info; + + info = g_file_query_info (recording->file, + G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," + G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "," + G_FILE_ATTRIBUTE_STANDARD_SIZE, + G_FILE_QUERY_INFO_NONE, + NULL, + NULL); + + if (info != NULL) { + const gchar *display_name, *content_type; + gchar *description, *mime, *type, *size; + gint64 file_size; + + display_name = g_file_info_get_display_name (info); + + gtk_label_set_text (GTK_LABEL (file_lbl), display_name); + + content_type = g_file_info_get_content_type (info); + description = g_content_type_get_description (content_type); + mime = g_content_type_get_mime_type (content_type); + type = g_strdup_printf ("%s (%s)", description, mime); + + gtk_label_set_text (GTK_LABEL (type_lbl), type); + + g_free (description); + g_free (mime); + g_free (type); + + file_size = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE); + + size = g_format_size_full (file_size, G_FORMAT_SIZE_LONG_FORMAT); + gtk_label_set_text (GTK_LABEL (size_lbl), size); + + g_free (size); + + g_object_unref (info); + + gint64 position; + + if (gst_element_query_position (recording->pipeline, GST_FORMAT_TIME, &position)) { + gchar* length; + gint secs; + + secs = position / GST_SECOND; + length = seconds_to_full_string (secs); + + gtk_label_set_text (GTK_LABEL (length_lbl), length); + + g_free (length); + } + } + + return TRUE; +} + +void run_status_window(Recording *recording) +{ + timeout_id = g_timeout_add(500, (GSourceFunc) timeout_cb, recording); +} + +void stop_rec_button_clicked_cb(GtkButton *button, gpointer data) +{ + Recording *recording = data; + close_status_window(); + recording_stop(recording); +} + +static gint delete_event_cb(GtkWidget* window, GdkEventAny* e, gpointer data) +{ + stop_rec_button_clicked_cb(NULL, data); + return TRUE; +} + +GtkWidget* record_status_window(Recording *recording) +{ + GtkWidget *vbox; + GtkWidget *grid; + GtkWidget *image; + GtkWidget *box; + GtkWidget *label; + GtkWidget *expander; + GtkWidget *button; + gchar *text, *markup; + + status_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_title(GTK_WINDOW(status_dialog),_("Gnomeradio recording status")); + gtk_window_set_resizable(GTK_WINDOW(status_dialog), FALSE); + + vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12); + gtk_container_set_border_width(GTK_CONTAINER(vbox), 8); + + grid = gtk_grid_new(); + gtk_grid_set_row_spacing(GTK_GRID(grid), 5); + gtk_grid_set_column_spacing(GTK_GRID(grid), 15); + gtk_container_set_border_width(GTK_CONTAINER(grid), 5); + + image = gtk_image_new_from_icon_name("gnomeradio", GTK_ICON_SIZE_DIALOG); + gtk_image_set_pixel_size(GTK_IMAGE(image), 42); + gtk_widget_set_valign(image, GTK_ALIGN_START); + gtk_grid_attach(GTK_GRID(grid), image, 0, 0, 1, 3); + + label = gtk_label_new (NULL); + gtk_widget_set_halign (label, GTK_ALIGN_START); + text = g_markup_printf_escaped (_("Recording from station %s"), recording->station); + markup = g_strdup_printf ("%s", text); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (text); + g_free (markup); + gtk_grid_attach(GTK_GRID(grid), label, 1, 0, 1, 1); + + box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + level = gtk_progress_bar_new(); + gtk_box_pack_start (GTK_BOX (box), level, FALSE, TRUE, 0); + gtk_grid_attach (GTK_GRID (grid), box, 1, 1, 1, 1); + + expander = gtk_expander_new(_("Details")); + gtk_grid_attach(GTK_GRID(grid), expander, 1, 2, 1, 1); + + gtk_box_pack_start (GTK_BOX(vbox), grid, TRUE, TRUE, 0); + + grid = gtk_grid_new (); + gtk_grid_set_row_spacing (GTK_GRID (grid), 5); + gtk_grid_set_column_spacing (GTK_GRID (grid), 15); + gtk_container_set_border_width (GTK_CONTAINER (grid), 5); + + label = gtk_label_new (_("Name:")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); + + label = gtk_label_new (_("Type:")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); + + label = gtk_label_new (_("Size:")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); + + label = gtk_label_new (_("Length:")); + gtk_widget_set_halign(label, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); + + file_lbl = gtk_label_new(NULL); + gtk_label_set_ellipsize(GTK_LABEL(file_lbl), PANGO_ELLIPSIZE_START); + gtk_widget_set_halign(file_lbl, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), file_lbl, 1, 0, 1, 1); + + type_lbl = gtk_label_new(NULL); + gtk_widget_set_halign(type_lbl, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), type_lbl, 1, 1, 1, 1); + + size_lbl = gtk_label_new(NULL); + gtk_widget_set_halign(size_lbl, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), size_lbl, 1, 2, 1, 1); + + length_lbl = gtk_label_new(NULL); + gtk_widget_set_halign(length_lbl, GTK_ALIGN_START); + gtk_grid_attach (GTK_GRID (grid), length_lbl, 1, 3, 1, 1); + + gtk_container_add (GTK_CONTAINER (expander), grid); + + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + + button = gtk_button_new (); + label = gtk_label_new (_("Stop Recording")); + image = gtk_image_new_from_icon_name ("process-stop", GTK_ICON_SIZE_BUTTON); + + gtk_box_pack_start (GTK_BOX(box), image, FALSE, FALSE, 2); + gtk_box_pack_start (GTK_BOX(box), label, FALSE, FALSE, 2); + + gtk_container_add(GTK_CONTAINER(button), box); + + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); + + gtk_box_pack_end (GTK_BOX (box), button, TRUE, FALSE, 0); + gtk_box_pack_start (GTK_BOX(vbox), box, FALSE, FALSE, 0); + + gtk_container_add(GTK_CONTAINER(status_dialog), vbox); + gtk_widget_grab_focus (button); + + g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(stop_rec_button_clicked_cb), recording); + g_signal_connect(G_OBJECT(status_dialog), "delete_event", G_CALLBACK(delete_event_cb), recording); + g_signal_connect(G_OBJECT(status_dialog), "key-press-event", G_CALLBACK(key_press_event_cb), recording); + + gtk_window_set_position(GTK_WINDOW(status_dialog), GTK_WIN_POS_CENTER); + + return status_dialog; +} === removed file '.pc/gnomeradio-tray_menu.patch/src/record.c' --- .pc/gnomeradio-tray_menu.patch/src/record.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/record.c 1970-01-01 00:00:00 +0000 @@ -1,317 +0,0 @@ -/* record.c - * - * Copyright (C) 2001 Jörgen Scheibengruber - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA - */ - -/*** the recording functionality */ - -#include - -#include -#include -#include -#include -#include "gui.h" -#include "rec_tech.h" -#include "prefs.h" - -extern GtkWidget *level; - -static GtkWidget *status_dialog; -static GtkWidget *file_lbl; -static GtkWidget *type_lbl; -static GtkWidget *size_lbl; -static GtkWidget *length_lbl; - -static int timeout_id = -1; - -void close_status_window(void) -{ - if (timeout_id >= 0) { - g_source_remove (timeout_id); - timeout_id = -1; - } - - if (status_dialog) - gtk_widget_destroy(GTK_WIDGET(status_dialog)); - status_dialog = NULL; - - tray_icon_items_set_sensible(TRUE); - recording_set_sensible(TRUE); -} - -static char *seconds_to_full_string (guint seconds) -{ - long days, hours, minutes; - char *time = NULL; - const char *minutefmt; - const char *hourfmt; - const char *secondfmt; - - days = seconds / (60 * 60 * 24); - hours = (seconds / (60 * 60)); - minutes = (seconds / 60) - ((days * 24 * 60) + (hours * 60)); - seconds = seconds % 60; - - minutefmt = ngettext ("%ld minute", "%ld minutes", minutes); - hourfmt = ngettext ("%ld hour", "%ld hours", hours); - secondfmt = ngettext ("%ld second", "%ld seconds", seconds); - - if (hours > 0) { - if (minutes > 0) - if (seconds > 0) { - char *fmt; - /* Translators: the format is "X hours X minutes X seconds" */ - fmt = g_strdup_printf (_("%s %s %s"), hourfmt, minutefmt, secondfmt); - time = g_strdup_printf (fmt, hours, minutes, seconds); - g_free (fmt); - } else { - char *fmt; - /* Translators: the format is "X hours X minutes" */ - fmt = g_strdup_printf (_("%s %s"), hourfmt, minutefmt); - time = g_strdup_printf (fmt, hours, minutes); - g_free (fmt); - } - else - if (seconds > 0) { - char *fmt; - /* Translators: the format is "X minutes X seconds" */ - fmt = g_strdup_printf (_("%s %s"), minutefmt, secondfmt); - time = g_strdup_printf (fmt, minutes, seconds); - g_free (fmt); - } else { - time = g_strdup_printf (minutefmt, minutes); - } - } else { - if (minutes > 0) { - if (seconds > 0) { - char *fmt; - /* Translators: the format is "X minutes X seconds" */ - fmt = g_strdup_printf (_("%s %s"), minutefmt, secondfmt); - time = g_strdup_printf (fmt, minutes, seconds); - g_free (fmt); - } else { - time = g_strdup_printf (minutefmt, minutes); - } - - } else { - time = g_strdup_printf (secondfmt, seconds); - } - } - - return time; -} - -static gboolean timeout_cb (gpointer data) -{ - Recording *recording = data; - - g_assert (recording); - - if (!gtk_widget_get_visible (status_dialog)) - gtk_widget_show_all (status_dialog); - - GFileInfo *info; - - info = g_file_query_info (recording->file, - G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," - G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "," - G_FILE_ATTRIBUTE_STANDARD_SIZE, - G_FILE_QUERY_INFO_NONE, - NULL, - NULL); - - if (info != NULL) { - const gchar *display_name, *content_type; - gchar *description, *mime, *type, *size; - gint64 file_size; - - display_name = g_file_info_get_display_name (info); - - gtk_label_set_text (GTK_LABEL (file_lbl), display_name); - - content_type = g_file_info_get_content_type (info); - description = g_content_type_get_description (content_type); - mime = g_content_type_get_mime_type (content_type); - type = g_strdup_printf ("%s (%s)", description, mime); - - gtk_label_set_text (GTK_LABEL (type_lbl), type); - - g_free (description); - g_free (mime); - g_free (type); - - file_size = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_STANDARD_SIZE); - - size = g_format_size_full (file_size, G_FORMAT_SIZE_LONG_FORMAT); - gtk_label_set_text (GTK_LABEL (size_lbl), size); - - g_free (size); - - g_object_unref (info); - - gint64 position; - - if (gst_element_query_position (recording->pipeline, GST_FORMAT_TIME, &position)) { - gchar* length; - gint secs; - - secs = position / GST_SECOND; - length = seconds_to_full_string (secs); - - gtk_label_set_text (GTK_LABEL (length_lbl), length); - - g_free (length); - } - } - - return TRUE; -} - -void run_status_window(Recording *recording) -{ - timeout_id = g_timeout_add(500, (GSourceFunc) timeout_cb, recording); -} - -void stop_rec_button_clicked_cb(GtkButton *button, gpointer data) -{ - Recording *recording = data; - close_status_window(); - recording_stop(recording); -} - -static gint delete_event_cb(GtkWidget* window, GdkEventAny* e, gpointer data) -{ - stop_rec_button_clicked_cb(NULL, data); - return TRUE; -} - -GtkWidget* record_status_window(Recording *recording) -{ - GtkWidget *vbox; - GtkWidget *grid; - GtkWidget *image; - GtkWidget *box; - GtkWidget *label; - GtkWidget *expander; - GtkWidget *button; - gchar *text, *markup; - - status_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); - gtk_window_set_title(GTK_WINDOW(status_dialog),_("Gnomeradio recording status")); - gtk_window_set_resizable(GTK_WINDOW(status_dialog), FALSE); - - vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 12); - gtk_container_set_border_width(GTK_CONTAINER(vbox), 8); - - grid = gtk_grid_new(); - gtk_grid_set_row_spacing(GTK_GRID(grid), 5); - gtk_grid_set_column_spacing(GTK_GRID(grid), 15); - gtk_container_set_border_width(GTK_CONTAINER(grid), 5); - - image = gtk_image_new_from_icon_name("gnomeradio", GTK_ICON_SIZE_DIALOG); - gtk_image_set_pixel_size(GTK_IMAGE(image), 42); - gtk_widget_set_valign(image, GTK_ALIGN_START); - gtk_grid_attach(GTK_GRID(grid), image, 0, 0, 1, 3); - - label = gtk_label_new (NULL); - gtk_widget_set_halign (label, GTK_ALIGN_START); - text = g_markup_printf_escaped (_("Recording from station %s"), recording->station); - markup = g_strdup_printf ("%s", text); - gtk_label_set_markup (GTK_LABEL (label), markup); - g_free (text); - g_free (markup); - gtk_grid_attach(GTK_GRID(grid), label, 1, 0, 1, 1); - - box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); - level = gtk_progress_bar_new(); - gtk_box_pack_start (GTK_BOX (box), level, FALSE, TRUE, 0); - gtk_grid_attach (GTK_GRID (grid), box, 1, 1, 1, 1); - - expander = gtk_expander_new(_("Details")); - gtk_grid_attach(GTK_GRID(grid), expander, 1, 2, 1, 1); - - gtk_box_pack_start (GTK_BOX(vbox), grid, TRUE, TRUE, 0); - - grid = gtk_grid_new (); - gtk_grid_set_row_spacing (GTK_GRID (grid), 5); - gtk_grid_set_column_spacing (GTK_GRID (grid), 15); - gtk_container_set_border_width (GTK_CONTAINER (grid), 5); - - label = gtk_label_new (_("Name:")); - gtk_widget_set_halign (label, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); - - label = gtk_label_new (_("Type:")); - gtk_widget_set_halign (label, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); - - label = gtk_label_new (_("Size:")); - gtk_widget_set_halign (label, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); - - label = gtk_label_new (_("Length:")); - gtk_widget_set_halign(label, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); - - file_lbl = gtk_label_new(NULL); - gtk_label_set_ellipsize(GTK_LABEL(file_lbl), PANGO_ELLIPSIZE_START); - gtk_widget_set_halign(file_lbl, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), file_lbl, 1, 0, 1, 1); - - type_lbl = gtk_label_new(NULL); - gtk_widget_set_halign(type_lbl, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), type_lbl, 1, 1, 1, 1); - - size_lbl = gtk_label_new(NULL); - gtk_widget_set_halign(size_lbl, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), size_lbl, 1, 2, 1, 1); - - length_lbl = gtk_label_new(NULL); - gtk_widget_set_halign(length_lbl, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (grid), length_lbl, 1, 3, 1, 1); - - gtk_container_add (GTK_CONTAINER (expander), grid); - - box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - - button = gtk_button_new (); - label = gtk_label_new (_("Stop Recording")); - image = gtk_image_new_from_icon_name ("process-stop", GTK_ICON_SIZE_BUTTON); - - gtk_box_pack_start (GTK_BOX(box), image, FALSE, FALSE, 2); - gtk_box_pack_start (GTK_BOX(box), label, FALSE, FALSE, 2); - - gtk_container_add(GTK_CONTAINER(button), box); - - box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - - gtk_box_pack_end (GTK_BOX (box), button, TRUE, FALSE, 0); - gtk_box_pack_start (GTK_BOX(vbox), box, FALSE, FALSE, 0); - - gtk_container_add(GTK_CONTAINER(status_dialog), vbox); - gtk_widget_grab_focus (button); - - g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(stop_rec_button_clicked_cb), recording); - g_signal_connect(G_OBJECT(status_dialog), "delete_event", G_CALLBACK(delete_event_cb), recording); - g_signal_connect(G_OBJECT(status_dialog), "key-press-event", G_CALLBACK(key_press_event_cb), recording); - - gtk_window_set_position(GTK_WINDOW(status_dialog), GTK_WIN_POS_CENTER); - - return status_dialog; -} === added file '.pc/gnomeradio-tray_menu.patch/src/trayicon.c' --- .pc/gnomeradio-tray_menu.patch/src/trayicon.c 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/trayicon.c 2013-10-03 19:38:23 +0000 @@ -0,0 +1,145 @@ +/* trayicon.c + * + * Copyright (C) 2006 Jörgen Scheibengruber + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + +#include +#include +#include +#include "gui.h" +#include "trayicon.h" +#include "mixer.h" + +extern GtkAdjustment *adj; + +extern int mom_ps; +extern gnomeradio_settings settings; + +static GtkWidget *showwindow_menuitem; + +static void mute_menuitem_toggled_cb(GtkCheckMenuItem *checkmenuitem, gpointer user_data) +{ + toggle_volume(); +} + +static void record_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) +{ + rec_button_clicked_cb(NULL, user_data); +} + +static void showwindow_menuitem_toggled_cb(GtkCheckMenuItem *checkmenuitem, gpointer user_data) +{ + GtkWidget* app = GTK_WIDGET(user_data); + toggle_mainwindow_visibility(app); +} + +static void quit_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) +{ + exit_gnome_radio(); +} + +void preset_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) +{ + preset* ps; + mom_ps = GPOINTER_TO_INT (user_data); + + g_assert(mom_ps >= 0 && mom_ps < g_list_length(settings.presets)); + + ps = (preset*)g_list_nth_data(settings.presets, mom_ps); + gtk_adjustment_set_value(adj, ps->freq * STEPS); +} + +void create_tray_menu(GtkWidget *app) { + GtkWidget *menuitem; + GList *node = settings.presets; + int i; + + tray_menu = gtk_menu_new(); + + for (i = 0; node; i++, node = node->next) + { + preset *ps = (preset*)node->data; + menuitem = gtk_menu_item_new_with_label(ps->title); + + gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, i); + g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (i)); + gtk_widget_show(menuitem); + } + + gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new()); + + mute_menuitem = gtk_check_menu_item_new_with_label(_("Muted")); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), mixer->get_volume() == 0); + gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), mute_menuitem); + mute_menuitem_toggled_cb_id = + g_signal_connect(G_OBJECT(mute_menuitem), "toggled", (GCallback)mute_menuitem_toggled_cb, (gpointer)app); + gtk_widget_show(mute_menuitem); + + menuitem = gtk_menu_item_new_with_mnemonic (_("_Record")); + gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), menuitem); + g_signal_connect (G_OBJECT (menuitem), "activate", (GCallback)record_menuitem_activate_cb, app); + gtk_widget_show (menuitem); + + gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new()); + + showwindow_menuitem = gtk_check_menu_item_new_with_label(_("Show Window")); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem), TRUE); + /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem), GTK_WIDGET_VISIBLE(app));*/ + gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), showwindow_menuitem); + g_signal_connect(G_OBJECT(showwindow_menuitem), "activate", (GCallback)showwindow_menuitem_toggled_cb, (gpointer)app); + gtk_widget_show(showwindow_menuitem); + + menuitem = gtk_menu_item_new_with_mnemonic (_("_Quit")); + gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), menuitem); + g_signal_connect (G_OBJECT (menuitem), "activate", (GCallback)quit_menuitem_activate_cb, NULL); + gtk_widget_show (menuitem); + + gtk_widget_show_all(tray_menu); +} + +static void tray_activate_cb(GtkStatusIcon* icon, gpointer data) +{ + gboolean active; + active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem)); + gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem), !active); +} + +static void tray_popup_menu (GtkStatusIcon* icon, guint button, guint32 time, gpointer data) +{ + gtk_menu_popup(GTK_MENU(tray_menu), NULL, NULL, NULL, icon, button, time); +} + +void create_tray_icon(GtkWidget *app) +{ + GdkPixbuf *pixbuf; + GtkIconTheme *icontheme; + char *text; + + icontheme = gtk_icon_theme_get_default(); + pixbuf = gtk_icon_theme_load_icon(icontheme, "gnomeradio", 22, 0, NULL); + g_return_if_fail(pixbuf); + tray_icon = G_OBJECT(gtk_status_icon_new_from_pixbuf(pixbuf)); + g_object_unref(pixbuf); + + g_signal_connect (G_OBJECT(tray_icon), "activate", G_CALLBACK (tray_activate_cb), (gpointer)app); + g_signal_connect (G_OBJECT(tray_icon), "popup-menu", G_CALLBACK (tray_popup_menu), (gpointer)app); + + text = g_strdup_printf(_("Gnomeradio - %.2f MHz"), gtk_adjustment_get_value(adj)/STEPS); + gtk_status_icon_set_tooltip_text(GTK_STATUS_ICON(tray_icon), text); + g_free(text); +} === removed file '.pc/gnomeradio-tray_menu.patch/src/trayicon.c' --- .pc/gnomeradio-tray_menu.patch/src/trayicon.c 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/trayicon.c 1970-01-01 00:00:00 +0000 @@ -1,145 +0,0 @@ -/* trayicon.c - * - * Copyright (C) 2006 Jörgen Scheibengruber - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 - * USA - */ - -#include -#include -#include -#include "gui.h" -#include "trayicon.h" -#include "mixer.h" - -extern GtkAdjustment *adj; - -extern int mom_ps; -extern gnomeradio_settings settings; - -static GtkWidget *showwindow_menuitem; - -static void mute_menuitem_toggled_cb(GtkCheckMenuItem *checkmenuitem, gpointer user_data) -{ - toggle_volume(); -} - -static void record_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) -{ - rec_button_clicked_cb(NULL, user_data); -} - -static void showwindow_menuitem_toggled_cb(GtkCheckMenuItem *checkmenuitem, gpointer user_data) -{ - GtkWidget* app = GTK_WIDGET(user_data); - toggle_mainwindow_visibility(app); -} - -static void quit_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) -{ - exit_gnome_radio(); -} - -void preset_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) -{ - preset* ps; - mom_ps = GPOINTER_TO_INT (user_data); - - g_assert(mom_ps >= 0 && mom_ps < g_list_length(settings.presets)); - - ps = (preset*)g_list_nth_data(settings.presets, mom_ps); - gtk_adjustment_set_value(adj, ps->freq * STEPS); -} - -void create_tray_menu(GtkWidget *app) { - GtkWidget *menuitem; - GList *node = settings.presets; - int i; - - tray_menu = gtk_menu_new(); - - for (i = 0; node; i++, node = node->next) - { - preset *ps = (preset*)node->data; - menuitem = gtk_menu_item_new_with_label(ps->title); - - gtk_menu_shell_insert(GTK_MENU_SHELL(tray_menu), menuitem, i); - g_signal_connect(G_OBJECT(menuitem), "activate", (GCallback)preset_menuitem_activate_cb, GINT_TO_POINTER (i)); - gtk_widget_show(menuitem); - } - - gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new()); - - mute_menuitem = gtk_check_menu_item_new_with_label(_("Muted")); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), mixer->get_volume() == 0); - gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), mute_menuitem); - mute_menuitem_toggled_cb_id = - g_signal_connect(G_OBJECT(mute_menuitem), "toggled", (GCallback)mute_menuitem_toggled_cb, (gpointer)app); - gtk_widget_show(mute_menuitem); - - menuitem = gtk_menu_item_new_with_mnemonic (_("_Record")); - gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), menuitem); - g_signal_connect (G_OBJECT (menuitem), "activate", (GCallback)record_menuitem_activate_cb, app); - gtk_widget_show (menuitem); - - gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), gtk_separator_menu_item_new()); - - showwindow_menuitem = gtk_check_menu_item_new_with_label(_("Show Window")); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem), TRUE); - /*gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem), GTK_WIDGET_VISIBLE(app));*/ - gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), showwindow_menuitem); - g_signal_connect(G_OBJECT(showwindow_menuitem), "activate", (GCallback)showwindow_menuitem_toggled_cb, (gpointer)app); - gtk_widget_show(showwindow_menuitem); - - menuitem = gtk_menu_item_new_with_mnemonic (_("_Quit")); - gtk_menu_shell_append (GTK_MENU_SHELL (tray_menu), menuitem); - g_signal_connect (G_OBJECT (menuitem), "activate", (GCallback)quit_menuitem_activate_cb, NULL); - gtk_widget_show (menuitem); - - gtk_widget_show_all(tray_menu); -} - -static void tray_activate_cb(GtkStatusIcon* icon, gpointer data) -{ - gboolean active; - active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem)); - gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(showwindow_menuitem), !active); -} - -static void tray_popup_menu (GtkStatusIcon* icon, guint button, guint32 time, gpointer data) -{ - gtk_menu_popup(GTK_MENU(tray_menu), NULL, NULL, NULL, icon, button, time); -} - -void create_tray_icon(GtkWidget *app) -{ - GdkPixbuf *pixbuf; - GtkIconTheme *icontheme; - char *text; - - icontheme = gtk_icon_theme_get_default(); - pixbuf = gtk_icon_theme_load_icon(icontheme, "gnomeradio", 22, 0, NULL); - g_return_if_fail(pixbuf); - tray_icon = G_OBJECT(gtk_status_icon_new_from_pixbuf(pixbuf)); - g_object_unref(pixbuf); - - g_signal_connect (G_OBJECT(tray_icon), "activate", G_CALLBACK (tray_activate_cb), (gpointer)app); - g_signal_connect (G_OBJECT(tray_icon), "popup-menu", G_CALLBACK (tray_popup_menu), (gpointer)app); - - text = g_strdup_printf(_("Gnomeradio - %.2f MHz"), gtk_adjustment_get_value(adj)/STEPS); - gtk_status_icon_set_tooltip_text(GTK_STATUS_ICON(tray_icon), text); - g_free(text); -} === added file '.pc/gnomeradio-tray_menu.patch/src/trayicon.h' --- .pc/gnomeradio-tray_menu.patch/src/trayicon.h 1970-01-01 00:00:00 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/trayicon.h 2013-10-03 19:38:23 +0000 @@ -0,0 +1,32 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef _TRAYICON_H +#define _TRAYICON_H + +GtkWidget *tray_menu; +GObject *tray_icon; +GtkWidget *mute_menuitem; + +int mute_menuitem_toggled_cb_id; + +void tray_icon_items_set_sensible(gboolean sensible); + +void create_tray_icon(GtkWidget *app); + +void create_tray_menu(GtkWidget *app); + +#endif === removed file '.pc/gnomeradio-tray_menu.patch/src/trayicon.h' --- .pc/gnomeradio-tray_menu.patch/src/trayicon.h 2013-09-20 13:31:33 +0000 +++ .pc/gnomeradio-tray_menu.patch/src/trayicon.h 1970-01-01 00:00:00 +0000 @@ -1,32 +0,0 @@ -/* - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Library General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - */ - -#ifndef _TRAYICON_H -#define _TRAYICON_H - -GtkWidget *tray_menu; -GObject *tray_icon; -GtkWidget *mute_menuitem; - -int mute_menuitem_toggled_cb_id; - -void tray_icon_items_set_sensible(gboolean sensible); - -void create_tray_icon(GtkWidget *app); - -void create_tray_menu(GtkWidget *app); - -#endif === modified file 'debian/changelog' --- debian/changelog 2013-09-20 13:31:33 +0000 +++ debian/changelog 2013-10-03 19:38:23 +0000 @@ -1,6 +1,20 @@ +gnomeradio (1.8-2ubuntu24) saucy; urgency=low + + * Fixed previous debian/changelog: gnomeradio-tray_menu.patch is a new patch + not one updated. + * Updated debian/patches/gnomeradio-preferences.patch: + - Avoid memory leak (unref the gconf client when we're done). + - Use GtkSwitch instead GtkRadioButton to change audio loopback state. + - Optimise radio init() function to less memory usage. + * Updated debian/patches/gnomeradio-tray_menu.patch: Moved + tree_view_switch_to_preset() inside of gnomeradio_switch_to_preset() so + preset list will be updated when use LIRC command. + + -- POJAR GEORGE Mon, 30 Sep 2013 12:21:35 +0000 + gnomeradio (1.8-2ubuntu23) saucy; urgency=low - * Updated debian/patches/gnomeradio-tray_menu.patch: + * debian/patches/gnomeradio-tray_menu.patch: - Fixed menu item not update conform new order when we use move up[down] swap. (LP: #1232931) - Fixed conditional jump or move depends on uninitialized value. === modified file 'debian/patches/gnomeradio-alsa.patch' --- debian/patches/gnomeradio-alsa.patch 2013-09-20 13:31:33 +0000 +++ debian/patches/gnomeradio-alsa.patch 2013-10-03 19:38:23 +0000 @@ -4,7 +4,7 @@ Index: gnomeradio-1.8/src/alsa_stream.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ gnomeradio-1.8/src/alsa_stream.c 2013-09-29 23:34:39.614658000 +0000 ++++ gnomeradio-1.8/src/alsa_stream.c 2013-10-01 12:41:44.571249000 +0000 @@ -0,0 +1,640 @@ +/* + * ALSA streaming support @@ -649,7 +649,7 @@ Index: gnomeradio-1.8/src/alsa_stream.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ gnomeradio-1.8/src/alsa_stream.h 2013-09-29 23:34:39.614658000 +0000 ++++ gnomeradio-1.8/src/alsa_stream.h 2013-10-01 12:41:44.571249000 +0000 @@ -0,0 +1,34 @@ + +/* @@ -688,7 +688,7 @@ Index: gnomeradio-1.8/src/get_media_devices.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ gnomeradio-1.8/src/get_media_devices.c 2013-09-29 23:34:52.000000000 +0000 ++++ gnomeradio-1.8/src/get_media_devices.c 2013-10-01 12:42:04.000000000 +0000 @@ -0,0 +1,595 @@ +/* + Copyright © 2011 by Mauro Carvalho Chehab @@ -1288,7 +1288,7 @@ Index: gnomeradio-1.8/src/get_media_devices.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ gnomeradio-1.8/src/get_media_devices.h 2013-09-29 23:34:39.614658000 +0000 ++++ gnomeradio-1.8/src/get_media_devices.h 2013-10-01 12:41:44.571249000 +0000 @@ -0,0 +1,168 @@ +/* + Copyright © 2011 by Mauro Carvalho Chehab @@ -1460,8 +1460,8 @@ + const enum device_type not_desired_type); Index: gnomeradio-1.8/configure.in =================================================================== ---- gnomeradio-1.8.orig/configure.in 2013-09-29 23:34:39.614658000 +0000 -+++ gnomeradio-1.8/configure.in 2013-09-29 23:34:55.000000000 +0000 +--- gnomeradio-1.8.orig/configure.in 2013-10-01 12:41:44.571249000 +0000 ++++ gnomeradio-1.8/configure.in 2013-10-01 12:42:08.000000000 +0000 @@ -5,7 +5,7 @@ AM_INIT_AUTOMAKE(AC_PACKAGE_NAME, AC_PACKAGE_VERSION) @@ -1511,8 +1511,8 @@ +AC_OUTPUT Index: gnomeradio-1.8/src/gui.c =================================================================== ---- gnomeradio-1.8.orig/src/gui.c 2013-09-29 23:34:39.614658000 +0000 -+++ gnomeradio-1.8/src/gui.c 2013-09-29 23:34:58.000000000 +0000 +--- gnomeradio-1.8.orig/src/gui.c 2013-10-01 12:41:44.571249000 +0000 ++++ gnomeradio-1.8/src/gui.c 2013-10-01 12:42:44.382775314 +0000 @@ -36,6 +36,7 @@ #include "lirc.h" #include "prefs.h" @@ -1611,7 +1611,7 @@ + } + case ARG_ALSA_PLAYBACK: + if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { -+ alsa_capture = g_strdup (arg); ++ alsa_playback = g_strdup (arg); + break; + } else { + g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, @@ -1758,8 +1758,8 @@ Index: gnomeradio-1.8/src/Makefile.am =================================================================== ---- gnomeradio-1.8.orig/src/Makefile.am 2013-09-29 23:34:39.614658000 +0000 -+++ gnomeradio-1.8/src/Makefile.am 2013-09-29 23:34:58.000000000 +0000 +--- gnomeradio-1.8.orig/src/Makefile.am 2013-10-01 12:41:44.571249000 +0000 ++++ gnomeradio-1.8/src/Makefile.am 2013-10-01 12:42:08.000000000 +0000 @@ -1,35 +1,39 @@ -INCLUDES = -I$(top_srcdir) -I$(includedir) \ - $(GNOME_CFLAGS) $(GSTREAMER_CFLAGS) $(XML_CFLAGS)\ @@ -1833,8 +1833,8 @@ +gnomeradio_LDADD = $(ALSA_LIBS) $(GNOME_LIBS) $(GSTREAMER_LIBS) $(XML_LIBS) $(LIRC) Index: gnomeradio-1.8/src/radio.c =================================================================== ---- gnomeradio-1.8.orig/src/radio.c 2013-09-29 23:34:39.614658000 +0000 -+++ gnomeradio-1.8/src/radio.c 2013-09-29 23:35:59.362147207 +0000 +--- gnomeradio-1.8.orig/src/radio.c 2013-10-01 12:41:44.571249000 +0000 ++++ gnomeradio-1.8/src/radio.c 2013-10-01 12:42:03.000000000 +0000 @@ -26,6 +26,14 @@ #include "radio.h" #include "v4l1.h" === modified file 'debian/patches/gnomeradio-preferences.patch' --- debian/patches/gnomeradio-preferences.patch 2013-09-20 13:31:33 +0000 +++ debian/patches/gnomeradio-preferences.patch 2013-10-03 19:38:23 +0000 @@ -1,35 +1,33 @@ -Description: Added option to disable audio loopback mode in Preferences settings. +Description: Avoid memory leak (unref the gconf client when we're done). + Added option to disable audio loopback mode in Preferences settings. Moved in separate GOptionGroup all command line parameters which refers to audio loopback mode. Make sentence capitalization in text and increased preferences dialog. Author: POJAR GEORGE Index: gnomeradio-1.8/src/prefs.c =================================================================== ---- gnomeradio-1.8.orig/src/prefs.c 2013-09-27 23:25:22.078455000 +0000 -+++ gnomeradio-1.8/src/prefs.c 2013-09-28 01:45:39.323134916 +0000 -@@ -29,8 +29,10 @@ - #include "rec_tech.h" - #include "rb_gst_media_types.h" +--- gnomeradio-1.8.orig/src/prefs.c 2013-10-03 05:22:09.237965000 +0000 ++++ gnomeradio-1.8/src/prefs.c 2013-10-03 05:23:41.300599007 +0000 +@@ -31,6 +31,8 @@ #include "rb_missing_plugins.h" -+#include "alsa_stream.h" extern int autodetect; ++extern int can_capture; +extern int alsa_loopback; extern GtkWidget *preset_combo; extern GtkAdjustment *adj; -@@ -42,7 +44,10 @@ +@@ -42,7 +44,9 @@ static GtkWidget *device_entry; static GtkWidget *mixer_entry; -static GtkWidget *mute_on_exit_cb; -+static GtkWidget *audio_label; -+static GtkWidget *enabled; -+static GtkWidget *disabled; ++static GtkWidget *audio_box; ++static GtkWidget *audio_switch; +static GtkWidget *mute_on_exit; static GtkWidget *list_view; static GtkListStore *list_store; static GtkTreeSelection *selection; -@@ -75,6 +80,7 @@ +@@ -75,6 +79,7 @@ gconf_client_set_string(client, "/apps/gnomeradio/device", settings.device, NULL); gconf_client_set_string(client, "/apps/gnomeradio/driver", settings.driver, NULL); gconf_client_set_string(client, "/apps/gnomeradio/mixer", settings.mixer, NULL); @@ -37,7 +35,16 @@ gconf_client_set_bool(client, "/apps/gnomeradio/mute-on-exit", settings.mute_on_exit, NULL); /*gconf_client_set_float(client, "/apps/gnomeradio/volume", volume->value, NULL);*/ gconf_client_set_float(client, "/apps/gnomeradio/last-freq", gtk_adjustment_get_value(adj)/STEPS, NULL); -@@ -129,15 +135,16 @@ +@@ -107,6 +112,8 @@ + } + gconf_client_set_int(client, "/apps/gnomeradio/presets/last", mom_ps, NULL); + /*g_print("Storing Settings in GConf database\n");*/ ++ ++ g_object_unref (client); + + return TRUE; + } +@@ -129,15 +136,16 @@ return FALSE; /* Load general settings */ @@ -56,7 +63,14 @@ settings.mute_on_exit = gconf_client_get_bool(client, "/apps/gnomeradio/mute-on-exit", NULL); /*volume->value = gconf_client_get_float(client, "/apps/gnomeradio/volume", NULL);*/ freq = gconf_client_get_float(client, "/apps/gnomeradio/last-freq", NULL); -@@ -202,8 +209,25 @@ +@@ -197,13 +205,37 @@ + if (mom_ps >= count) + mom_ps = -1; + ++ g_object_unref (client); ++ + return TRUE; + } static void mute_on_exit_toggled_cb(GtkWidget* widget, gpointer data) { @@ -65,37 +79,40 @@ + settings.mute_on_exit = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mute_on_exit)); +} + -+static void audio_loopback_set_visible (gboolean visible) ++gboolean audio_box_set_visible (gboolean visible) +{ -+ gtk_widget_set_visible (audio_label, visible); -+ gtk_widget_set_visible (enabled, visible); -+ gtk_widget_set_visible (disabled, visible); ++ gtk_widget_hide (audio_box); ++ gtk_widget_set_no_show_all (audio_box, !visible); ++ if (visible) ++ gtk_widget_show_all (audio_box); +} + -+static void audio_loopback_toggled_cb (GtkWidget* widget, gpointer data) ++static void audio_switch_activate_cb (GtkWidget* widget, gpointer data) +{ -+ settings.audio_loopback = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)); ++ settings.audio_loopback = gtk_switch_get_active (GTK_SWITCH (audio_switch)); ++ ++ start_radio(TRUE, data); + + if (settings.audio_loopback) -+ start_radio(TRUE, data); ++ alsa_loopback = 1; + else -+ alsa_thread_stop(); ++ alsa_loopback = 0; ++ ++ audio_box_set_visible (can_capture); +} static gboolean device_entry_activate_cb(GtkWidget *widget, gpointer data) { -@@ -220,6 +244,10 @@ +@@ -220,6 +252,8 @@ settings.device = g_strdup(text); start_radio(TRUE, data); + -+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)) || -+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (disabled))) -+ audio_loopback_set_visible (radio_is_init()); ++ audio_box_set_visible (can_capture); return FALSE; } -@@ -1237,73 +1265,107 @@ +@@ -1237,73 +1271,107 @@ content_area = gtk_dialog_get_content_area (GTK_DIALOG(dialog)); @@ -107,7 +124,7 @@ grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 5); - gtk_grid_set_column_spacing(GTK_GRID(grid), 20); -+ gtk_grid_set_column_spacing(GTK_GRID(grid), 40); ++ gtk_grid_set_column_spacing(GTK_GRID(grid), 65); gtk_box_pack_start(GTK_BOX(box), grid, TRUE, TRUE, 0); /* The general settings part */ @@ -153,42 +170,44 @@ gtk_entry_set_text(GTK_ENTRY(mixer_entry), settings.mixer); - gtk_grid_attach(GTK_GRID(grid), mixer_entry, 2, 2, 1, 1); + gtk_grid_attach(GTK_GRID(grid), mixer_entry, 1, 2, 1, 1); ++ ++ audio_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); ++ gtk_widget_set_no_show_all (audio_box, TRUE); ++ ++ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); ++ ++ label = gtk_label_new (_("Loopback mode")); ++ gtk_widget_set_halign (label, GTK_ALIGN_START); ++ gtk_widget_set_margin_left (label, 10); ++ ++ audio_switch = gtk_switch_new (); ++ ++ gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); ++ gtk_box_pack_end (GTK_BOX (box), audio_switch, FALSE, FALSE, 0); ++ ++ label = gtk_label_new (NULL); ++ gtk_widget_set_halign (label, GTK_ALIGN_START); ++ gtk_widget_set_valign (label, GTK_ALIGN_START); ++ gtk_widget_set_margin_left (label, 10); ++ markup = g_strdup_printf ("%s", _("(audio streaming between radio device and audio output device)")); ++ gtk_label_set_markup (GTK_LABEL (label), markup); ++ g_free (markup); ++ ++ gtk_box_pack_start (GTK_BOX (audio_box), box, FALSE, FALSE, 0); ++ gtk_box_pack_end (GTK_BOX (audio_box), label, FALSE, FALSE, 0); ++ gtk_grid_attach(GTK_GRID(grid), audio_box, 0, 3, 2, 1); ++ ++ /* Enabled audio loopback from switch|commandline */ ++ if (settings.audio_loopback || alsa_loopback) ++ gtk_switch_set_active (GTK_SWITCH (audio_switch), TRUE); ++ else ++ gtk_switch_set_active (GTK_SWITCH (audio_switch), FALSE); - mute_on_exit_cb = gtk_check_button_new_with_label(_("Mute on exit")); - gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mute_on_exit_cb), settings.mute_on_exit); -+ audio_label = gtk_label_new (_("Audio Loopback mode")); -+ gtk_widget_set_no_show_all (audio_label, TRUE); -+ gtk_widget_set_halign (audio_label, GTK_ALIGN_START); -+ gtk_widget_set_margin_left (audio_label, 10); -+ gtk_grid_attach (GTK_GRID (grid), audio_label, 0, 3, 1, 1); -+ -+ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); -+ -+ enabled = gtk_radio_button_new_with_label (NULL, _("Enabled")); -+ gtk_widget_set_no_show_all (enabled, TRUE); -+ disabled = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (enabled), _("Disabled")); -+ gtk_widget_set_no_show_all (disabled, TRUE); -+ gtk_box_pack_start (GTK_BOX (box), enabled, TRUE, TRUE, 0); -+ gtk_box_pack_start (GTK_BOX (box), disabled, TRUE, TRUE, 0); -+ gtk_grid_attach(GTK_GRID(grid), box, 1, 3, 1, 1); -+ -+ /* Enabled from radio button or else from command line */ -+ if (settings.audio_loopback || alsa_loopback) -+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enabled), TRUE); -+ else -+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (disabled), TRUE); ++ audio_box_set_visible (can_capture); - gtk_grid_attach(GTK_GRID(grid), mute_on_exit_cb, 1, 3, 1, 1); -+ if (settings.audio_loopback) -+ if (alsa_loopback) -+ audio_loopback_set_visible (TRUE); -+ else -+ audio_loopback_set_visible (FALSE); -+ else -+ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)) || -+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (disabled))) -+ audio_loopback_set_visible (radio_is_init()); -+ + mute_on_exit = gtk_check_button_new_with_label(_("Mute on exit")); + gtk_widget_set_margin_left (mute_on_exit, 10); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mute_on_exit), settings.mute_on_exit); @@ -200,14 +219,12 @@ g_signal_connect(G_OBJECT(mixer_entry), "hide", G_CALLBACK(mixer_entry_activate_cb), app); g_signal_connect(G_OBJECT(mixer_entry), "activate", G_CALLBACK(mixer_entry_activate_cb), NULL); - g_signal_connect(G_OBJECT(mute_on_exit_cb), "toggled", G_CALLBACK(mute_on_exit_toggled_cb), NULL); -+ g_signal_connect(G_OBJECT(enabled), "toggled", G_CALLBACK(audio_loopback_toggled_cb), NULL); ++ g_signal_connect(G_OBJECT(audio_switch), "notify::active", G_CALLBACK(audio_switch_activate_cb), NULL); + g_signal_connect(G_OBJECT(mute_on_exit), "toggled", G_CALLBACK(mute_on_exit_toggled_cb), NULL); gtk_widget_set_tooltip_text(device_entry, _("The radio device to use (e.g. /dev/radio0)")); gtk_widget_set_tooltip_text(mixer_entry, _("The mixer device and channel to use (e.g. hw:0/Line)")); - gtk_widget_set_tooltip_text(mute_on_exit_cb, _("Mute radio device on exit")); -+ gtk_widget_set_tooltip_text(disabled, _("Stop audio streaming between the radio device and the audio output device")); -+ gtk_widget_set_tooltip_text(enabled, _("Start an audio streaming between the radio device and the audio output device")); + gtk_widget_set_tooltip_text(mute_on_exit, _("Mute radio device on exit")); /* The presets part */ @@ -228,7 +245,7 @@ gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled_window), 75); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); -@@ -1359,7 +1421,7 @@ +@@ -1359,7 +1427,7 @@ i++; } @@ -237,7 +254,7 @@ button_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); -@@ -1427,44 +1489,43 @@ +@@ -1427,44 +1495,43 @@ gtk_box_pack_end(GTK_BOX(button_box), save_button, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(button_box), open_button, FALSE, FALSE, 0); @@ -298,8 +315,8 @@ } Index: gnomeradio-1.8/data/gnomeradio.schemas.in =================================================================== ---- gnomeradio-1.8.orig/data/gnomeradio.schemas.in 2013-09-27 23:25:22.078455000 +0000 -+++ gnomeradio-1.8/data/gnomeradio.schemas.in 2013-09-28 01:47:01.103132485 +0000 +--- gnomeradio-1.8.orig/data/gnomeradio.schemas.in 2013-10-03 05:22:09.237965000 +0000 ++++ gnomeradio-1.8/data/gnomeradio.schemas.in 2013-10-03 05:22:09.237965000 +0000 @@ -61,6 +61,18 @@ @@ -321,31 +338,92 @@ gnomeradio Index: gnomeradio-1.8/src/gui.c =================================================================== ---- gnomeradio-1.8.orig/src/gui.c 2013-09-27 23:25:22.078455000 +0000 -+++ gnomeradio-1.8/src/gui.c 2013-09-28 02:58:01.891005826 +0000 -@@ -60,7 +60,7 @@ +--- gnomeradio-1.8.orig/src/gui.c 2013-10-03 05:22:09.237965000 +0000 ++++ gnomeradio-1.8/src/gui.c 2013-10-03 05:22:18.000000000 +0000 +@@ -59,8 +59,9 @@ + #define DEFAULT_LATENCY 500 int autodetect; ++int can_capture; -int alsa_loopback = 1; +int alsa_loopback = 0; char *alsa_playback = NULL; char *alsa_capture = NULL; int alsa_latency = DEFAULT_LATENCY; -@@ -295,6 +295,12 @@ - if (0 == strcmp(settings.device, "auto")) +@@ -97,20 +98,31 @@ + + static gboolean is_first_start(void) + { +- GConfClient *client = gconf_client_get_default(); ++ GConfClient *client; ++ gboolean first_start; ++ ++ client = gconf_client_get_default(); + if (!client) + return TRUE; + +- return !gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL); ++ first_start = gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL); ++ ++ g_object_unref (client); ++ ++ return !first_start; + } + + static void set_first_time_flag(void) + { +- GConfClient *client = gconf_client_get_default(); ++ GConfClient *client; ++ ++ client = gconf_client_get_default(); + if (!client) + return; + + gconf_client_set_bool(client, "/apps/gnomeradio/first_time_flag", TRUE, NULL); ++ ++ g_object_unref (client); + } + + typedef struct { +@@ -281,8 +293,14 @@ + void start_radio(gboolean restart, GtkWidget *app) + { + DriverType driver = DRIVER_ANY; +- if (restart) ++ ++ if (restart) { + radio_stop(); ++ if (settings.audio_loopback) ++ alsa_loopback = 1; ++ else ++ alsa_loopback = 0; ++ } + + if (settings.driver) { + if (0 == strcmp(settings.driver, "v4l1")) +@@ -292,12 +310,19 @@ + } + + autodetect = 0; +- if (0 == strcmp(settings.device, "auto")) ++ if ((0 == strcmp(settings.device, "auto")) || (0 == strcmp(settings.device, ""))) autodetect = 1; -+ if (settings.audio_loopback) { -+ if (0 == strcmp(settings.device, "")) -+ autodetect = 1; ++ if (settings.audio_loopback) + alsa_loopback = 1; -+ } + if (!radio_init(settings.device, driver)) { char *caption, *detail; -@@ -1254,7 +1260,6 @@ ++ can_capture = 0; ++ if (restart) ++ audio_box_set_visible (can_capture); ++ + if (autodetect) { + caption = g_strdup_printf (_("Could not find any radio device!")); + detail = g_strdup_printf (_("Please ensure that you have a radio device connected to your computer.\n" +@@ -1254,7 +1279,6 @@ enum { ARG_ALSA_LOOPBACK, @@ -353,7 +431,7 @@ ARG_ALSA_CAPTURE, ARG_ALSA_PLAYBACK, ARG_ALSA_LATENCY, -@@ -1268,9 +1273,6 @@ +@@ -1268,16 +1292,13 @@ case ARG_ALSA_LOOPBACK: alsa_loopback = 1; break; @@ -363,7 +441,24 @@ case ARG_ALSA_CAPTURE: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { alsa_capture = g_strdup (arg); -@@ -1315,7 +1317,6 @@ + break; + } else { + g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, +- _("invalid argument name '%s', must be e.g. 'hw:1,0'"), arg); ++ _("Invalid argument name '%s'. Example usage: --alsa-capture=hw:1,0"), arg); + return FALSE; + } + case ARG_ALSA_PLAYBACK: +@@ -1286,7 +1307,7 @@ + break; + } else { + g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, +- _("invalid argument name '%s', must be e.g. 'hw:0,0'"), arg); ++ _("Invalid argument name '%s'. Example usage: --alsa-playback=hw:0,0"), arg); + return FALSE; + } + case ARG_ALSA_LATENCY: +@@ -1315,7 +1336,6 @@ } options[] = { { "--alsa-loopback", ARG_ALSA_LOOPBACK}, { @@ -371,7 +466,7 @@ "--alsa-capture", ARG_ALSA_CAPTURE}, { "--alsa-playback", ARG_ALSA_PLAYBACK}, { "--alsa-latency", ARG_ALSA_LATENCY}, { -@@ -1334,6 +1335,27 @@ +@@ -1334,6 +1354,27 @@ return parse_one_option (val, arg, err); } @@ -399,7 +494,7 @@ G_GNUC_NORETURN static gboolean option_version_cb (const gchar * opt, const gchar * arg, gpointer data, GError ** err) -@@ -1350,13 +1372,7 @@ +@@ -1350,13 +1391,7 @@ gboolean do_scan = FALSE; GOptionContext *ctx; const GOptionEntry entries[] = { @@ -414,7 +509,7 @@ { "version", 0, G_OPTION_FLAG_NO_ARG | G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_CALLBACK, option_version_cb, NULL, NULL }, { NULL } }; -@@ -1370,11 +1386,13 @@ +@@ -1370,11 +1405,13 @@ ctx = g_option_context_new("- Listen to FM radio"); g_option_context_add_main_entries(ctx, entries, GETTEXT_PACKAGE); @@ -430,8 +525,8 @@ } Index: gnomeradio-1.8/src/gui.h =================================================================== ---- gnomeradio-1.8.orig/src/gui.h 2013-09-27 23:25:22.078455000 +0000 -+++ gnomeradio-1.8/src/gui.h 2013-09-27 23:31:15.075374641 +0000 +--- gnomeradio-1.8.orig/src/gui.h 2013-10-03 05:22:09.237965000 +0000 ++++ gnomeradio-1.8/src/gui.h 2013-10-03 05:22:18.000000000 +0000 @@ -31,6 +31,7 @@ { gchar *device; @@ -440,3 +535,159 @@ gboolean mute_on_exit; gchar *driver; +Index: gnomeradio-1.8/src/radio.c +=================================================================== +--- gnomeradio-1.8.orig/src/radio.c 2013-10-03 05:22:09.237965000 +0000 ++++ gnomeradio-1.8/src/radio.c 2013-10-03 05:22:09.237965000 +0000 +@@ -31,6 +31,7 @@ + #include "get_media_devices.h" + + extern int autodetect; ++extern int can_capture; + + extern int alsa_loopback; + extern char *alsa_playback; +@@ -46,14 +47,15 @@ + int radio_init(char *device, DriverType driver) + { + int rv = -1; ++ void *md; ++ const char *p = NULL; ++ ++ md = discover_media_devices(); + + if (autodetect) { +- void *md; +- const char *p = NULL; + char buf[PATH_MAX]; + + *device = 0; +- md = discover_media_devices(); + if (!md) { + fprintf (stderr, "open: Failed to open \"auto\" device"); + if (*device) +@@ -71,7 +73,12 @@ + device = &buf[0]; + } + +- free_media_devices(md); ++ p = NULL; ++ } ++ ++ if (!md) { ++ fprintf (stderr, "open: Failed to open radio device %s\n", device); ++ goto failure; + } + + switch (driver) { +@@ -87,9 +94,10 @@ + dev = v4l1_radio_dev_new(); + rv = dev->init (dev, device); + if (rv == 0) { +- fprintf(stderr, "v4l1: Initialization failed\n"); ++ fprintf(stderr, "v4l1: Initialization failed\n"); + dev->finalize (dev); + dev = NULL; ++ can_capture = 0; + if (alsa_loopback) + alsa_loopback = 0; + if (driver != DRIVER_ANY) +@@ -102,9 +110,10 @@ + dev = v4l2_radio_dev_new(); + rv = dev->init (dev, device); + if (rv == 0) { +- fprintf(stderr, "v4l2: Initialization failed\n"); ++ fprintf(stderr, "v4l2: Initialization failed\n"); + dev->finalize (dev); + dev = NULL; ++ can_capture = 0; + if (alsa_loopback) + alsa_loopback = 0; + if (driver != DRIVER_ANY) +@@ -117,36 +126,38 @@ + if (autodetect) + fprintf(stderr, "open: Using radio device: %s\n", device); + +- if (alsa_loopback) { +- if (alsa_capture == NULL) { +- void *md = discover_media_devices(); +- const char *p = strrchr(device, '/'); +- if (p) +- p++; +- else +- p = device; +- +- p = get_associated_device(md, NULL, MEDIA_SND_CAP, p, MEDIA_V4L_RADIO); +- if (p) +- alsa_capture = strdup(p); +- else +- alsa_loopback = 0; +- +- free_media_devices(md); +- } ++ p = strrchr(device, '/'); ++ if (p) ++ p++; ++ else ++ p = device; ++ ++ p = get_associated_device(md, NULL, MEDIA_SND_CAP, p, MEDIA_V4L_RADIO); ++ if (p) { ++ can_capture = 1; ++ if (alsa_loopback && alsa_capture == NULL) ++ alsa_capture = strdup(p); ++ p = NULL; ++ } else { ++ can_capture = 0; ++ if (alsa_loopback) ++ alsa_loopback = 0; ++ } + +- if (alsa_loopback) { +- if (alsa_playback == NULL) +- alsa_playback = "default"; ++ if (alsa_loopback) { ++ if (alsa_playback == NULL) ++ alsa_playback = "default"; + +- fprintf(stderr, "alsa: Using audio loopback device from %s (%s) to %s\n", +- alsa_capture, device, alsa_playback); +- } ++ fprintf(stderr, "alsa: Stream started from %s (%s) to %s\n", ++ alsa_capture, device, alsa_playback); + } + + radio_unmute(); + failure: + ++ if (md) ++ free_media_devices(md); ++ + return rv; + } + +@@ -161,6 +172,8 @@ + radio_mute(); + + if (dev) dev->finalize (dev); ++ if (alsa_loopback) ++ fprintf(stderr, "alsa: Stream stopped\n"); + } + + void radio_set_freq(float frequency) +Index: gnomeradio-1.8/src/prefs.h +=================================================================== +--- gnomeradio-1.8.orig/src/prefs.h 2013-10-03 05:22:09.237965000 +0000 ++++ gnomeradio-1.8/src/prefs.h 2013-10-03 05:22:18.000000000 +0000 +@@ -20,8 +20,11 @@ + #include + + gboolean save_settings(void); ++ + gboolean load_settings(void); + ++gboolean audio_box_set_visible (gboolean visible); ++ + enum + { + RADIO_DEVICE, === modified file 'debian/patches/gnomeradio-tray_menu.patch' --- debian/patches/gnomeradio-tray_menu.patch 2013-09-20 13:31:33 +0000 +++ debian/patches/gnomeradio-tray_menu.patch 2013-10-03 19:38:23 +0000 @@ -6,27 +6,24 @@ Author: POJAR GEORGE Index: gnomeradio-1.8/src/trayicon.c =================================================================== ---- gnomeradio-1.8.orig/src/trayicon.c 2013-09-29 22:40:45.000000000 +0000 -+++ gnomeradio-1.8/src/trayicon.c 2013-09-29 23:07:38.706197762 +0000 -@@ -24,14 +24,125 @@ - #include "gui.h" +--- gnomeradio-1.8.orig/src/trayicon.c 2013-10-03 19:27:43.386257491 +0000 ++++ gnomeradio-1.8/src/trayicon.c 2013-10-03 19:29:31.974254263 +0000 +@@ -25,12 +25,121 @@ #include "trayicon.h" #include "mixer.h" -+#include "prefs.h" -extern GtkAdjustment *adj; - -extern int mom_ps; extern gnomeradio_settings settings; -+GtkWidget *tray_menu; -+GObject *tray_icon; -+GtkWidget *mute_menuitem; ++static GtkWidget *mute_menuitem; + static GtkWidget *showwindow_menuitem; ++static GtkWidget *tray_menu; ++static GObject *tray_icon; + +int mute_menuitem_toggled_cb_id; + - static GtkWidget *showwindow_menuitem; - +void tray_icon_set_title(gchar *title) +{ + if (tray_icon) @@ -133,11 +130,10 @@ + tray_menu_remove_preset (index); + tray_menu_add_preset (ps, index); +} -+ + static void mute_menuitem_toggled_cb(GtkCheckMenuItem *checkmenuitem, gpointer user_data) { - toggle_volume(); -@@ -55,13 +166,8 @@ +@@ -55,13 +164,7 @@ void preset_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) { @@ -149,11 +145,10 @@ - ps = (preset*)g_list_nth_data(settings.presets, mom_ps); - gtk_adjustment_set_value(adj, ps->freq * STEPS); + gnomeradio_switch_to_preset(GPOINTER_TO_INT (user_data)); -+ list_view_switch_to_preset(GPOINTER_TO_INT (user_data)); } void create_tray_menu(GtkWidget *app) { -@@ -71,8 +177,7 @@ +@@ -71,8 +174,7 @@ tray_menu = gtk_menu_new(); @@ -163,7 +158,7 @@ preset *ps = (preset*)node->data; menuitem = gtk_menu_item_new_with_label(ps->title); -@@ -86,8 +191,7 @@ +@@ -86,8 +188,7 @@ mute_menuitem = gtk_check_menu_item_new_with_label(_("Muted")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), mixer->get_volume() == 0); gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), mute_menuitem); @@ -173,7 +168,7 @@ gtk_widget_show(mute_menuitem); menuitem = gtk_menu_item_new_with_mnemonic (_("_Record")); -@@ -128,7 +232,6 @@ +@@ -128,7 +229,6 @@ { GdkPixbuf *pixbuf; GtkIconTheme *icontheme; @@ -181,7 +176,7 @@ icontheme = gtk_icon_theme_get_default(); pixbuf = gtk_icon_theme_load_icon(icontheme, "gnomeradio", 22, 0, NULL); -@@ -138,8 +241,4 @@ +@@ -138,8 +238,4 @@ g_signal_connect (G_OBJECT(tray_icon), "activate", G_CALLBACK (tray_activate_cb), (gpointer)app); g_signal_connect (G_OBJECT(tray_icon), "popup-menu", G_CALLBACK (tray_popup_menu), (gpointer)app); @@ -192,17 +187,18 @@ } Index: gnomeradio-1.8/src/prefs.c =================================================================== ---- gnomeradio-1.8.orig/src/prefs.c 2013-09-29 22:40:45.000000000 +0000 -+++ gnomeradio-1.8/src/prefs.c 2013-09-29 22:40:45.000000000 +0000 -@@ -41,6 +41,7 @@ - extern gnomeradio_settings settings; - - extern gboolean main_visible; -+extern gboolean dialog_visible; - - static GtkWidget *device_entry; - static GtkWidget *mixer_entry; -@@ -472,7 +473,6 @@ +--- gnomeradio-1.8.orig/src/prefs.c 2013-10-03 19:27:43.386257491 +0000 ++++ gnomeradio-1.8/src/prefs.c 2013-10-03 19:27:43.378257492 +0000 +@@ -47,7 +47,7 @@ + static GtkWidget *audio_box; + static GtkWidget *audio_switch; + static GtkWidget *mute_on_exit; +-static GtkWidget *list_view; ++static GtkWidget *tree_view; + static GtkListStore *list_store; + static GtkTreeSelection *selection; + static GtkWidget *save_button; +@@ -478,7 +478,6 @@ GtkTreeIter iter = {0}; GtkAdjustment* v_scb; GtkTreePath *path = NULL; @@ -210,7 +206,16 @@ ps = malloc(sizeof(preset)); ps->title = g_strdup(_("unnamed")); -@@ -494,11 +494,7 @@ +@@ -492,7 +491,7 @@ + g_free(buffer); + gtk_tree_selection_unselect_all(selection); + +- v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); ++ v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view)); + gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); + + if (main_visible) { +@@ -500,17 +499,13 @@ mom_ps = g_list_length(settings.presets) - 1; preset_combo_set_item(mom_ps); @@ -223,16 +228,26 @@ } buffer = g_strdup_printf("%d", g_list_length(settings.presets) - 1); -@@ -517,8 +513,6 @@ + path = gtk_tree_path_new_from_string(buffer); + g_free(buffer); +- gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); ++ gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree_view), path, NULL, FALSE); + gtk_tree_path_free(path); + + gtk_widget_set_sensitive(save_button, TRUE); +@@ -523,10 +518,8 @@ GtkTreeIter iter; preset *ps; int *row; - GList* menuitems; - GtkWidget *menuitem; - gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); +- gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); ++ gtk_tree_view_get_cursor(GTK_TREE_VIEW(tree_view), &path, &focus_column); -@@ -543,21 +537,17 @@ + if (!path) return; + +@@ -549,21 +542,17 @@ if (settings.presets == NULL) mom_ps = -1; preset_combo_set_item(mom_ps); @@ -244,7 +259,8 @@ } gtk_tree_path_prev(path); - gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); +- gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); ++ gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree_view), path, NULL, FALSE); gtk_tree_path_free(path); - if (settings.presets == NULL) { @@ -257,16 +273,19 @@ } static void move_up_button_clicked_cb(GtkWidget * widget, gpointer data) -@@ -567,8 +557,6 @@ +@@ -573,10 +562,8 @@ gint pos; preset *ps; int *row; - GList* menuitems; - GtkWidget *menuitem; - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); +- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); ++ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_get_selected(selection, NULL, &iter); -@@ -600,25 +588,17 @@ + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + +@@ -606,25 +593,17 @@ mom_ps = *row; preset_combo_set_item(mom_ps); @@ -282,7 +301,8 @@ + tray_menu_move_up_preset (ps, mom_ps); } - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); +- gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); ++ gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tree_view), path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); - if (pos - 1 <= 0) { @@ -296,16 +316,19 @@ gtk_widget_set_sensitive(move_down_button, TRUE); } -@@ -629,8 +609,6 @@ +@@ -635,10 +614,8 @@ gint pos, count; preset *ps; int *row; - GList* menuitems; - GtkWidget *menuitem; - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); +- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); ++ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_get_selected(selection, NULL, &iter); -@@ -666,34 +644,25 @@ + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + +@@ -672,38 +649,29 @@ mom_ps = *row; preset_combo_set_item(mom_ps); @@ -321,7 +344,8 @@ + tray_menu_move_down_preset (ps, mom_ps); } - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); +- gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); ++ gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tree_view), path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); - if (pos + 2 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) { @@ -345,7 +369,20 @@ rec_settings.destination = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(button)); } -@@ -723,17 +692,15 @@ +-static gboolean list_view_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data) ++static gboolean tree_view_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data) + { + if (event->keyval == GDK_KEY_Delete) + remove_button_clicked_cb(widget, user_data); +@@ -722,24 +690,22 @@ + + event_button = (GdkEventButton *) event; + +- gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(list_view), event_button->x, event_button->y, &path, NULL, NULL, NULL); ++ gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tree_view), event_button->x, event_button->y, &path, NULL, NULL, NULL); + if (path != NULL) { + buffer = gtk_tree_path_to_string(path); + pos = (gint) g_strtod(buffer, NULL); g_free(buffer); gtk_tree_path_free(path); @@ -367,7 +404,7 @@ } return FALSE; } -@@ -744,8 +711,6 @@ +@@ -750,8 +716,6 @@ GtkTreeIter iter; preset *ps; int *row; @@ -376,7 +413,7 @@ path = gtk_tree_path_new_from_string(path_str); -@@ -764,15 +729,7 @@ +@@ -770,15 +734,7 @@ mom_ps = *row; preset_combo_set_item(mom_ps); @@ -393,7 +430,25 @@ } gtk_tree_model_get_iter(GTK_TREE_MODEL(list_store), &iter, path); -@@ -844,17 +801,16 @@ +@@ -823,7 +779,7 @@ + gtk_tree_path_free(path); + } + +-static void list_view_cursor_changed_cb(GtkWidget *widget, gpointer data) ++static void tree_view_cursor_changed_cb(GtkWidget *widget, gpointer data) + { + int *row; + preset *ps; +@@ -834,7 +790,7 @@ + if (settings.presets == NULL) + return; + +- gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); ++ gtk_tree_view_get_cursor(GTK_TREE_VIEW(tree_view), &path, &focus_column); + + if (!path) + return; +@@ -850,22 +806,21 @@ pos = g_list_index(settings.presets, (gpointer)ps); @@ -416,34 +471,67 @@ gtk_tree_path_free(path); return; } -@@ -899,6 +855,26 @@ - gtk_widget_grab_focus(list_view); + +-static void list_view_selection_changed_cb(GtkWidget *widget, gpointer data) ++static void tree_view_selection_changed_cb(GtkWidget *widget, gpointer data) + { + gboolean sel; + +@@ -875,10 +830,25 @@ + gtk_widget_set_sensitive(save_button, sel); } -+void list_view_switch_to_preset (gint active) -+{ -+ GtkTreePath *path = NULL; -+ GtkTreeIter iter; -+ -+ if (!dialog_visible) -+ return; +-static void list_view_scroll_to_active_preset_cb(GtkWidget *widget, gpointer data) ++void tree_view_switch_to_preset (gint active) + { + GtkTreePath *path = NULL; + GtkTreeIter iter; + + if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, active)) + return; + + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + -+ gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list_view), path, NULL, FALSE, 0, 0); -+ gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); ++ gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (tree_view), path, NULL, FALSE, 0, 0); ++ gtk_tree_view_set_cursor(GTK_TREE_VIEW (tree_view), path, NULL, FALSE ); + gtk_tree_path_free(path); + -+ gtk_widget_grab_focus(list_view); ++ gtk_widget_grab_focus(tree_view); +} + ++static void tree_view_scroll_to_active_preset_cb(GtkWidget *widget, gpointer data) ++{ + gint active; + + if (settings.presets == NULL) { +@@ -893,16 +863,7 @@ + return; + } + +- if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, active)) +- return; +- +- path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); +- +- gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list_view), path, NULL, FALSE, 0, 0); +- gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); +- gtk_tree_path_free(path); +- +- gtk_widget_grab_focus(list_view); ++ tree_view_switch_to_preset (active); + } + static void free_presets_list (gpointer data) - { - preset *ps = (preset *) data; -@@ -1060,8 +1036,6 @@ +@@ -953,7 +914,7 @@ + /* set it as the root element */ + xmlDocSetRootElement(doc, root); + /* get the tree view's model... */ +- model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); ++ model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); + /* ...and go through it with a foreach */ + gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc)save_to_file_foreach, (gpointer)root); + /* save the actual file */ +@@ -1066,8 +1027,6 @@ GtkTreePath *path = NULL; GtkTreeIter iter; GtkAdjustment* v_scb; @@ -452,7 +540,7 @@ /* load the file */ doc = xmlParseFile(filename); -@@ -1086,15 +1060,9 @@ +@@ -1092,15 +1051,9 @@ gint i, count; count = g_list_length (settings.presets); @@ -470,7 +558,25 @@ } } -@@ -1142,13 +1110,7 @@ +@@ -1111,7 +1064,7 @@ + } + + /* get the tree view's model */ +- model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); ++ model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); + + /* iterate through the root's children items */ + current = current->xmlChildrenNode; +@@ -1140,7 +1093,7 @@ + + gtk_tree_selection_unselect_all(selection); + +- v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); ++ v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view)); + gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); + + if (main_visible) { +@@ -1148,13 +1101,7 @@ mom_ps = g_list_length(settings.presets) - 1; preset_combo_set_item(mom_ps); @@ -485,23 +591,99 @@ } } /* free the data */ +@@ -1173,12 +1120,12 @@ + + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + +- gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); ++ gtk_tree_view_set_cursor(GTK_TREE_VIEW (tree_view), path, NULL, FALSE ); + gtk_tree_path_free(path); + +- gtk_widget_grab_focus(list_view); ++ gtk_widget_grab_focus(tree_view); + +- list_view_cursor_changed_cb(list_view, NULL); ++ tree_view_cursor_changed_cb(tree_view, NULL); + gtk_widget_set_sensitive(save_button, TRUE); + gtk_widget_set_sensitive(remove_button, TRUE); + } +@@ -1229,7 +1176,7 @@ + gtk_widget_grab_focus (mixer_entry); + break; + case PRESETS: +- list_view_scroll_to_active_preset_cb(list_view, NULL); ++ tree_view_scroll_to_active_preset_cb(tree_view, NULL); + break; + default: + break; +@@ -1377,22 +1324,22 @@ + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + + list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); +- list_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); +- gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(list_view), TRUE); +- gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list_view), FALSE); ++ tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); ++ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(tree_view), TRUE); ++ gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_view), FALSE); + +- selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); ++ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); + gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); +- gtk_container_add(GTK_CONTAINER(scrolled_window), list_view); ++ gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view); + +- g_signal_connect(G_OBJECT(list_view), "button-release-event", G_CALLBACK(button_release_cb), NULL); +- g_signal_connect(G_OBJECT(list_view), "key-press-event", G_CALLBACK(list_view_key_press_event_cb), NULL); +- g_signal_connect(G_OBJECT(list_view), "cursor-changed", G_CALLBACK(list_view_cursor_changed_cb), NULL); ++ g_signal_connect(G_OBJECT(tree_view), "button-release-event", G_CALLBACK(button_release_cb), NULL); ++ g_signal_connect(G_OBJECT(tree_view), "key-press-event", G_CALLBACK(tree_view_key_press_event_cb), NULL); ++ g_signal_connect(G_OBJECT(tree_view), "cursor-changed", G_CALLBACK(tree_view_cursor_changed_cb), NULL); + +- g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(list_view_selection_changed_cb), list_view); ++ g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_view_selection_changed_cb), tree_view); + + /*gtk_tree_selection_select_path(selection, gtk_tree_path_new_from_string("0")); +- gtk_tree_selection_set_select_function(selection, (GtkTreeSelectionFunc)list_view_select_cb, NULL, NULL);*/ ++ gtk_tree_selection_set_select_function(selection, (GtkTreeSelectionFunc)tree_view_select_cb, NULL, NULL);*/ + + cellrenderer = gtk_cell_renderer_text_new(); + g_object_set(G_OBJECT(cellrenderer), "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL); +@@ -1400,7 +1347,7 @@ + list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 0, NULL); + gtk_tree_view_column_set_reorderable(list_column, TRUE); + gtk_tree_view_column_set_expand(list_column, TRUE); +- gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); ++ gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), list_column); + + g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(name_cell_edited_cb), NULL); + +@@ -1411,7 +1358,7 @@ + list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 1, NULL); + gtk_tree_view_column_set_reorderable(list_column, TRUE); + gtk_tree_view_column_set_expand(list_column, FALSE); +- gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); ++ gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), list_column); + + g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(freq_cell_edited_cb), NULL); + Index: gnomeradio-1.8/src/prefs.h =================================================================== ---- gnomeradio-1.8.orig/src/prefs.h 2013-09-29 22:40:45.000000000 +0000 -+++ gnomeradio-1.8/src/prefs.h 2013-09-29 22:40:45.000000000 +0000 -@@ -31,6 +31,8 @@ +--- gnomeradio-1.8.orig/src/prefs.h 2013-10-03 19:27:43.386257491 +0000 ++++ gnomeradio-1.8/src/prefs.h 2013-10-03 19:27:43.378257492 +0000 +@@ -34,6 +34,8 @@ gboolean action_mode (gint mode); -+void list_view_switch_to_preset (gint active); ++void tree_view_switch_to_preset (gint active); + GtkWidget* prefs_window(GtkWidget *app); #endif Index: gnomeradio-1.8/src/trayicon.h =================================================================== ---- gnomeradio-1.8.orig/src/trayicon.h 2013-09-29 22:40:45.000000000 +0000 -+++ gnomeradio-1.8/src/trayicon.h 2013-09-29 22:40:45.000000000 +0000 +--- gnomeradio-1.8.orig/src/trayicon.h 2013-10-03 19:27:43.386257491 +0000 ++++ gnomeradio-1.8/src/trayicon.h 2013-10-03 19:27:43.382257492 +0000 @@ -16,14 +16,23 @@ #ifndef _TRAYICON_H @@ -533,8 +715,8 @@ Index: gnomeradio-1.8/src/record.c =================================================================== ---- gnomeradio-1.8.orig/src/record.c 2013-09-29 22:40:45.000000000 +0000 -+++ gnomeradio-1.8/src/record.c 2013-09-29 23:16:38.250181723 +0000 +--- gnomeradio-1.8.orig/src/record.c 2013-10-03 19:27:43.386257491 +0000 ++++ gnomeradio-1.8/src/record.c 2013-10-03 19:27:43.382257492 +0000 @@ -29,6 +29,7 @@ #include "gui.h" #include "rec_tech.h" @@ -554,8 +736,8 @@ Index: gnomeradio-1.8/src/gui.h =================================================================== ---- gnomeradio-1.8.orig/src/gui.h 2013-09-29 22:40:45.000000000 +0000 -+++ gnomeradio-1.8/src/gui.h 2013-09-29 22:40:45.000000000 +0000 +--- gnomeradio-1.8.orig/src/gui.h 2013-10-03 19:27:43.386257491 +0000 ++++ gnomeradio-1.8/src/gui.h 2013-10-03 19:27:43.382257492 +0000 @@ -68,8 +68,6 @@ void preset_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data); @@ -567,9 +749,9 @@ Index: gnomeradio-1.8/src/gui.c =================================================================== ---- gnomeradio-1.8.orig/src/gui.c 2013-09-29 22:40:45.000000000 +0000 -+++ gnomeradio-1.8/src/gui.c 2013-09-29 23:14:26.406185642 +0000 -@@ -70,6 +70,7 @@ +--- gnomeradio-1.8.orig/src/gui.c 2013-10-03 19:27:43.386257491 +0000 ++++ gnomeradio-1.8/src/gui.c 2013-10-03 19:27:43.382257492 +0000 +@@ -71,6 +71,7 @@ gnomeradio_settings settings; gboolean main_visible; @@ -577,15 +759,19 @@ GtkWidget *app; GtkWidget *preset_combo; -@@ -250,6 +251,7 @@ +@@ -261,7 +262,11 @@ + { GtkWidget* dialog; gint choise; ++ ++ if (dialog_visible) ++ return; + dialog_visible = TRUE; dialog = prefs_window(app); /* Michael Jochum proposed to not use gnome_dialog_set_parent() -@@ -276,6 +278,8 @@ +@@ -288,6 +293,8 @@ gtk_widget_destroy(dialog); } } @@ -594,7 +780,7 @@ } void start_radio(gboolean restart, GtkWidget *app) -@@ -497,7 +501,7 @@ +@@ -516,7 +523,7 @@ else buffer = g_strdup_printf(_("Gnomeradio - %.2f MHz"), freq); gtk_window_set_title(GTK_WINDOW(window), buffer); @@ -603,7 +789,7 @@ g_free(buffer); buffer = g_strdup_printf(_("Frequency: %.2f MHz"), freq); -@@ -513,11 +517,7 @@ +@@ -532,11 +539,7 @@ mixer->set_volume(vol - mixer->get_volume()); @@ -616,7 +802,57 @@ } #if 0 -@@ -694,36 +694,6 @@ +@@ -665,8 +668,11 @@ + + void preset_combo_set_item(gint i) + { +- if (i < -1) return; +- if (preset_combo == NULL) return; ++ if (i < -1) ++ return; ++ if (preset_combo == NULL) ++ return; ++ + gtk_combo_box_set_active(GTK_COMBO_BOX(preset_combo), i + 1); + } + +@@ -675,10 +681,14 @@ + preset* ps; + mom_ps = gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) - 1; + +- if (mom_ps < 0) return; ++ if (mom_ps < 0) ++ return; + + ps = (preset*)g_list_nth_data(settings.presets, mom_ps); + gtk_adjustment_set_value(adj, ps->freq * STEPS); ++ ++ if (dialog_visible) ++ tree_view_switch_to_preset (mom_ps); + } + + void change_preset(gboolean next) +@@ -696,6 +706,9 @@ + ps = g_list_nth_data(settings.presets, mom_ps); + gtk_adjustment_set_value(adj, ps->freq*STEPS); + preset_combo_set_item(mom_ps); ++ ++ if (dialog_visible) ++ tree_view_switch_to_preset (mom_ps); + } + + void gnomeradio_switch_to_preset (gint index) +@@ -705,6 +718,9 @@ + gtk_adjustment_set_value(adj, ps->freq*STEPS); + mom_ps = index; + preset_combo_set_item(mom_ps); ++ ++ if (dialog_visible) ++ tree_view_switch_to_preset (mom_ps); + } + } + +@@ -713,36 +729,6 @@ exit_gnome_radio(); } @@ -653,7 +889,7 @@ void recording_set_sensible(gboolean sensible) { /* Disable the presets */ -@@ -802,7 +772,7 @@ +@@ -821,7 +807,7 @@ if (!recording) return -1; === modified file 'src/gui.c' --- src/gui.c 2013-09-20 13:31:33 +0000 +++ src/gui.c 2013-10-03 19:38:23 +0000 @@ -59,6 +59,7 @@ #define DEFAULT_LATENCY 500 int autodetect; +int can_capture; int alsa_loopback = 0; char *alsa_playback = NULL; @@ -98,20 +99,31 @@ static gboolean is_first_start(void) { - GConfClient *client = gconf_client_get_default(); + GConfClient *client; + gboolean first_start; + + client = gconf_client_get_default(); if (!client) return TRUE; - return !gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL); + first_start = gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL); + + g_object_unref (client); + + return !first_start; } static void set_first_time_flag(void) { - GConfClient *client = gconf_client_get_default(); + GConfClient *client; + + client = gconf_client_get_default(); if (!client) return; gconf_client_set_bool(client, "/apps/gnomeradio/first_time_flag", TRUE, NULL); + + g_object_unref (client); } typedef struct { @@ -250,6 +262,9 @@ { GtkWidget* dialog; gint choise; + + if (dialog_visible) + return; dialog_visible = TRUE; dialog = prefs_window(app); @@ -285,8 +300,14 @@ void start_radio(gboolean restart, GtkWidget *app) { DriverType driver = DRIVER_ANY; - if (restart) + + if (restart) { radio_stop(); + if (settings.audio_loopback) + alsa_loopback = 1; + else + alsa_loopback = 0; + } if (settings.driver) { if (0 == strcmp(settings.driver, "v4l1")) @@ -296,18 +317,19 @@ } autodetect = 0; - if (0 == strcmp(settings.device, "auto")) + if ((0 == strcmp(settings.device, "auto")) || (0 == strcmp(settings.device, ""))) autodetect = 1; - if (settings.audio_loopback) { - if (0 == strcmp(settings.device, "")) - autodetect = 1; + if (settings.audio_loopback) alsa_loopback = 1; - } if (!radio_init(settings.device, driver)) { char *caption, *detail; + can_capture = 0; + if (restart) + audio_box_set_visible (can_capture); + if (autodetect) { caption = g_strdup_printf (_("Could not find any radio device!")); detail = g_strdup_printf (_("Please ensure that you have a radio device connected to your computer.\n" @@ -646,8 +668,11 @@ void preset_combo_set_item(gint i) { - if (i < -1) return; - if (preset_combo == NULL) return; + if (i < -1) + return; + if (preset_combo == NULL) + return; + gtk_combo_box_set_active(GTK_COMBO_BOX(preset_combo), i + 1); } @@ -656,10 +681,14 @@ preset* ps; mom_ps = gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) - 1; - if (mom_ps < 0) return; + if (mom_ps < 0) + return; ps = (preset*)g_list_nth_data(settings.presets, mom_ps); gtk_adjustment_set_value(adj, ps->freq * STEPS); + + if (dialog_visible) + tree_view_switch_to_preset (mom_ps); } void change_preset(gboolean next) @@ -677,6 +706,9 @@ ps = g_list_nth_data(settings.presets, mom_ps); gtk_adjustment_set_value(adj, ps->freq*STEPS); preset_combo_set_item(mom_ps); + + if (dialog_visible) + tree_view_switch_to_preset (mom_ps); } void gnomeradio_switch_to_preset (gint index) @@ -686,6 +718,9 @@ gtk_adjustment_set_value(adj, ps->freq*STEPS); mom_ps = index; preset_combo_set_item(mom_ps); + + if (dialog_visible) + tree_view_switch_to_preset (mom_ps); } } @@ -1249,16 +1284,16 @@ break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, - _("invalid argument name '%s', must be e.g. 'hw:1,0'"), arg); + _("Invalid argument name '%s'. Example usage: --alsa-capture=hw:1,0"), arg); return FALSE; } case ARG_ALSA_PLAYBACK: if (!strncmp(arg, "hw:", 3) && isdigit(arg[3]) && arg[4] == ',' && isdigit(arg[5])) { - alsa_capture = g_strdup (arg); + alsa_playback = g_strdup (arg); break; } else { g_set_error(err, G_OPTION_ERROR, G_OPTION_ERROR_FAILED, - _("invalid argument name '%s', must be e.g. 'hw:0,0'"), arg); + _("Invalid argument name '%s'. Example usage: --alsa-playback=hw:0,0"), arg); return FALSE; } case ARG_ALSA_LATENCY: === modified file 'src/prefs.c' --- src/prefs.c 2013-09-20 13:31:33 +0000 +++ src/prefs.c 2013-10-03 19:38:23 +0000 @@ -29,9 +29,9 @@ #include "rec_tech.h" #include "rb_gst_media_types.h" #include "rb_missing_plugins.h" -#include "alsa_stream.h" extern int autodetect; +extern int can_capture; extern int alsa_loopback; extern GtkWidget *preset_combo; @@ -41,15 +41,13 @@ extern gnomeradio_settings settings; extern gboolean main_visible; -extern gboolean dialog_visible; static GtkWidget *device_entry; static GtkWidget *mixer_entry; -static GtkWidget *audio_label; -static GtkWidget *enabled; -static GtkWidget *disabled; +static GtkWidget *audio_box; +static GtkWidget *audio_switch; static GtkWidget *mute_on_exit; -static GtkWidget *list_view; +static GtkWidget *tree_view; static GtkListStore *list_store; static GtkTreeSelection *selection; static GtkWidget *save_button; @@ -114,6 +112,8 @@ } gconf_client_set_int(client, "/apps/gnomeradio/presets/last", mom_ps, NULL); /*g_print("Storing Settings in GConf database\n");*/ + + g_object_unref (client); return TRUE; } @@ -205,6 +205,8 @@ if (mom_ps >= count) mom_ps = -1; + g_object_unref (client); + return TRUE; } @@ -213,21 +215,26 @@ settings.mute_on_exit = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mute_on_exit)); } -static void audio_loopback_set_visible (gboolean visible) +gboolean audio_box_set_visible (gboolean visible) { - gtk_widget_set_visible (audio_label, visible); - gtk_widget_set_visible (enabled, visible); - gtk_widget_set_visible (disabled, visible); + gtk_widget_hide (audio_box); + gtk_widget_set_no_show_all (audio_box, !visible); + if (visible) + gtk_widget_show_all (audio_box); } -static void audio_loopback_toggled_cb (GtkWidget* widget, gpointer data) +static void audio_switch_activate_cb (GtkWidget* widget, gpointer data) { - settings.audio_loopback = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)); + settings.audio_loopback = gtk_switch_get_active (GTK_SWITCH (audio_switch)); + + start_radio(TRUE, data); if (settings.audio_loopback) - start_radio(TRUE, data); + alsa_loopback = 1; else - alsa_thread_stop(); + alsa_loopback = 0; + + audio_box_set_visible (can_capture); } static gboolean device_entry_activate_cb(GtkWidget *widget, gpointer data) @@ -246,9 +253,7 @@ start_radio(TRUE, data); - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)) || - gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (disabled))) - audio_loopback_set_visible (radio_is_init()); + audio_box_set_visible (can_capture); return FALSE; } @@ -486,7 +491,7 @@ g_free(buffer); gtk_tree_selection_unselect_all(selection); - v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); + v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view)); gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); if (main_visible) { @@ -500,7 +505,7 @@ buffer = g_strdup_printf("%d", g_list_length(settings.presets) - 1); path = gtk_tree_path_new_from_string(buffer); g_free(buffer); - gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); + gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree_view), path, NULL, FALSE); gtk_tree_path_free(path); gtk_widget_set_sensitive(save_button, TRUE); @@ -514,7 +519,7 @@ preset *ps; int *row; - gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); + gtk_tree_view_get_cursor(GTK_TREE_VIEW(tree_view), &path, &focus_column); if (!path) return; @@ -541,7 +546,7 @@ } gtk_tree_path_prev(path); - gtk_tree_view_set_cursor(GTK_TREE_VIEW(list_view), path, NULL, FALSE); + gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree_view), path, NULL, FALSE); gtk_tree_path_free(path); if (settings.presets == NULL) @@ -558,7 +563,7 @@ preset *ps; int *row; - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_get_selected(selection, NULL, &iter); path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); @@ -591,7 +596,7 @@ tray_menu_move_up_preset (ps, mom_ps); } - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); + gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tree_view), path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); if (pos - 1 <= 0) @@ -610,7 +615,7 @@ preset *ps; int *row; - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_get_selected(selection, NULL, &iter); path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); @@ -647,7 +652,7 @@ tray_menu_move_down_preset (ps, mom_ps); } - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list_view), path, NULL, FALSE, 0, 0); + gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tree_view), path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); if (pos + 2 == gtk_tree_model_iter_n_children(GTK_TREE_MODEL(list_store), NULL)) @@ -666,7 +671,7 @@ rec_settings.destination = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(button)); } -static gboolean list_view_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data) +static gboolean tree_view_key_press_event_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data) { if (event->keyval == GDK_KEY_Delete) remove_button_clicked_cb(widget, user_data); @@ -685,7 +690,7 @@ event_button = (GdkEventButton *) event; - gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(list_view), event_button->x, event_button->y, &path, NULL, NULL, NULL); + gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tree_view), event_button->x, event_button->y, &path, NULL, NULL, NULL); if (path != NULL) { buffer = gtk_tree_path_to_string(path); pos = (gint) g_strtod(buffer, NULL); @@ -774,7 +779,7 @@ gtk_tree_path_free(path); } -static void list_view_cursor_changed_cb(GtkWidget *widget, gpointer data) +static void tree_view_cursor_changed_cb(GtkWidget *widget, gpointer data) { int *row; preset *ps; @@ -785,7 +790,7 @@ if (settings.presets == NULL) return; - gtk_tree_view_get_cursor(GTK_TREE_VIEW(list_view), &path, &focus_column); + gtk_tree_view_get_cursor(GTK_TREE_VIEW(tree_view), &path, &focus_column); if (!path) return; @@ -815,7 +820,7 @@ return; } -static void list_view_selection_changed_cb(GtkWidget *widget, gpointer data) +static void tree_view_selection_changed_cb(GtkWidget *widget, gpointer data) { gboolean sel; @@ -825,10 +830,25 @@ gtk_widget_set_sensitive(save_button, sel); } -static void list_view_scroll_to_active_preset_cb(GtkWidget *widget, gpointer data) +void tree_view_switch_to_preset (gint active) { GtkTreePath *path = NULL; GtkTreeIter iter; + + if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, active)) + return; + + path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); + + gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (tree_view), path, NULL, FALSE, 0, 0); + gtk_tree_view_set_cursor(GTK_TREE_VIEW (tree_view), path, NULL, FALSE ); + gtk_tree_path_free(path); + + gtk_widget_grab_focus(tree_view); +} + +static void tree_view_scroll_to_active_preset_cb(GtkWidget *widget, gpointer data) +{ gint active; if (settings.presets == NULL) { @@ -843,36 +863,7 @@ return; } - if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, active)) - return; - - path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); - - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list_view), path, NULL, FALSE, 0, 0); - gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); - gtk_tree_path_free(path); - - gtk_widget_grab_focus(list_view); -} - -void list_view_switch_to_preset (gint active) -{ - GtkTreePath *path = NULL; - GtkTreeIter iter; - - if (!dialog_visible) - return; - - if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store), &iter, NULL, active)) - return; - - path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); - - gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list_view), path, NULL, FALSE, 0, 0); - gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); - gtk_tree_path_free(path); - - gtk_widget_grab_focus(list_view); + tree_view_switch_to_preset (active); } static void free_presets_list (gpointer data) @@ -923,7 +914,7 @@ /* set it as the root element */ xmlDocSetRootElement(doc, root); /* get the tree view's model... */ - model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); + model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); /* ...and go through it with a foreach */ gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc)save_to_file_foreach, (gpointer)root); /* save the actual file */ @@ -1073,7 +1064,7 @@ } /* get the tree view's model */ - model = gtk_tree_view_get_model(GTK_TREE_VIEW(list_view)); + model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view)); /* iterate through the root's children items */ current = current->xmlChildrenNode; @@ -1102,7 +1093,7 @@ gtk_tree_selection_unselect_all(selection); - v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(list_view)); + v_scb = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view)); gtk_adjustment_set_value(v_scb, gtk_adjustment_get_upper(v_scb)); if (main_visible) { @@ -1129,12 +1120,12 @@ path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store), &iter); - gtk_tree_view_set_cursor(GTK_TREE_VIEW (list_view), path, NULL, FALSE ); + gtk_tree_view_set_cursor(GTK_TREE_VIEW (tree_view), path, NULL, FALSE ); gtk_tree_path_free(path); - gtk_widget_grab_focus(list_view); + gtk_widget_grab_focus(tree_view); - list_view_cursor_changed_cb(list_view, NULL); + tree_view_cursor_changed_cb(tree_view, NULL); gtk_widget_set_sensitive(save_button, TRUE); gtk_widget_set_sensitive(remove_button, TRUE); } @@ -1185,7 +1176,7 @@ gtk_widget_grab_focus (mixer_entry); break; case PRESETS: - list_view_scroll_to_active_preset_cb(list_view, NULL); + tree_view_scroll_to_active_preset_cb(tree_view, NULL); break; default: break; @@ -1233,7 +1224,7 @@ grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 5); - gtk_grid_set_column_spacing(GTK_GRID(grid), 40); + gtk_grid_set_column_spacing(GTK_GRID(grid), 65); gtk_box_pack_start(GTK_BOX(box), grid, TRUE, TRUE, 0); /* The general settings part */ @@ -1267,37 +1258,39 @@ gtk_entry_set_text(GTK_ENTRY(mixer_entry), settings.mixer); gtk_grid_attach(GTK_GRID(grid), mixer_entry, 1, 2, 1, 1); - audio_label = gtk_label_new (_("Audio Loopback mode")); - gtk_widget_set_no_show_all (audio_label, TRUE); - gtk_widget_set_halign (audio_label, GTK_ALIGN_START); - gtk_widget_set_margin_left (audio_label, 10); - gtk_grid_attach (GTK_GRID (grid), audio_label, 0, 3, 1, 1); + audio_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_widget_set_no_show_all (audio_box, TRUE); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); - enabled = gtk_radio_button_new_with_label (NULL, _("Enabled")); - gtk_widget_set_no_show_all (enabled, TRUE); - disabled = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (enabled), _("Disabled")); - gtk_widget_set_no_show_all (disabled, TRUE); - gtk_box_pack_start (GTK_BOX (box), enabled, TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX (box), disabled, TRUE, TRUE, 0); - gtk_grid_attach(GTK_GRID(grid), box, 1, 3, 1, 1); - - /* Enabled from radio button or else from command line */ + label = gtk_label_new (_("Loopback mode")); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + + audio_switch = gtk_switch_new (); + + gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); + gtk_box_pack_end (GTK_BOX (box), audio_switch, FALSE, FALSE, 0); + + label = gtk_label_new (NULL); + gtk_widget_set_halign (label, GTK_ALIGN_START); + gtk_widget_set_valign (label, GTK_ALIGN_START); + gtk_widget_set_margin_left (label, 10); + markup = g_strdup_printf ("%s", _("(audio streaming between radio device and audio output device)")); + gtk_label_set_markup (GTK_LABEL (label), markup); + g_free (markup); + + gtk_box_pack_start (GTK_BOX (audio_box), box, FALSE, FALSE, 0); + gtk_box_pack_end (GTK_BOX (audio_box), label, FALSE, FALSE, 0); + gtk_grid_attach(GTK_GRID(grid), audio_box, 0, 3, 2, 1); + + /* Enabled audio loopback from switch|commandline */ if (settings.audio_loopback || alsa_loopback) - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enabled), TRUE); + gtk_switch_set_active (GTK_SWITCH (audio_switch), TRUE); else - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (disabled), TRUE); + gtk_switch_set_active (GTK_SWITCH (audio_switch), FALSE); - if (settings.audio_loopback) - if (alsa_loopback) - audio_loopback_set_visible (TRUE); - else - audio_loopback_set_visible (FALSE); - else - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (enabled)) || - gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (disabled))) - audio_loopback_set_visible (radio_is_init()); + audio_box_set_visible (can_capture); mute_on_exit = gtk_check_button_new_with_label(_("Mute on exit")); gtk_widget_set_margin_left (mute_on_exit, 10); @@ -1309,13 +1302,11 @@ g_signal_connect(G_OBJECT(device_entry), "changed", G_CALLBACK(device_entry_auto_activate_cb), NULL); g_signal_connect(G_OBJECT(mixer_entry), "hide", G_CALLBACK(mixer_entry_activate_cb), app); g_signal_connect(G_OBJECT(mixer_entry), "activate", G_CALLBACK(mixer_entry_activate_cb), NULL); - g_signal_connect(G_OBJECT(enabled), "toggled", G_CALLBACK(audio_loopback_toggled_cb), NULL); + g_signal_connect(G_OBJECT(audio_switch), "notify::active", G_CALLBACK(audio_switch_activate_cb), NULL); g_signal_connect(G_OBJECT(mute_on_exit), "toggled", G_CALLBACK(mute_on_exit_toggled_cb), NULL); gtk_widget_set_tooltip_text(device_entry, _("The radio device to use (e.g. /dev/radio0)")); gtk_widget_set_tooltip_text(mixer_entry, _("The mixer device and channel to use (e.g. hw:0/Line)")); - gtk_widget_set_tooltip_text(disabled, _("Stop audio streaming between the radio device and the audio output device")); - gtk_widget_set_tooltip_text(enabled, _("Start an audio streaming between the radio device and the audio output device")); gtk_widget_set_tooltip_text(mute_on_exit, _("Mute radio device on exit")); /* The presets part */ @@ -1333,22 +1324,22 @@ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); list_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); - list_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); - gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(list_view), TRUE); - gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list_view), FALSE); + tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); + gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(tree_view), TRUE); + gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_view), FALSE); - selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list_view)); + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); - gtk_container_add(GTK_CONTAINER(scrolled_window), list_view); - - g_signal_connect(G_OBJECT(list_view), "button-release-event", G_CALLBACK(button_release_cb), NULL); - g_signal_connect(G_OBJECT(list_view), "key-press-event", G_CALLBACK(list_view_key_press_event_cb), NULL); - g_signal_connect(G_OBJECT(list_view), "cursor-changed", G_CALLBACK(list_view_cursor_changed_cb), NULL); - - g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(list_view_selection_changed_cb), list_view); + gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view); + + g_signal_connect(G_OBJECT(tree_view), "button-release-event", G_CALLBACK(button_release_cb), NULL); + g_signal_connect(G_OBJECT(tree_view), "key-press-event", G_CALLBACK(tree_view_key_press_event_cb), NULL); + g_signal_connect(G_OBJECT(tree_view), "cursor-changed", G_CALLBACK(tree_view_cursor_changed_cb), NULL); + + g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_view_selection_changed_cb), tree_view); /*gtk_tree_selection_select_path(selection, gtk_tree_path_new_from_string("0")); - gtk_tree_selection_set_select_function(selection, (GtkTreeSelectionFunc)list_view_select_cb, NULL, NULL);*/ + gtk_tree_selection_set_select_function(selection, (GtkTreeSelectionFunc)tree_view_select_cb, NULL, NULL);*/ cellrenderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(cellrenderer), "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL); @@ -1356,7 +1347,7 @@ list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 0, NULL); gtk_tree_view_column_set_reorderable(list_column, TRUE); gtk_tree_view_column_set_expand(list_column, TRUE); - gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), list_column); g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(name_cell_edited_cb), NULL); @@ -1367,7 +1358,7 @@ list_column = gtk_tree_view_column_new_with_attributes(NULL, cellrenderer, "text", 1, NULL); gtk_tree_view_column_set_reorderable(list_column, TRUE); gtk_tree_view_column_set_expand(list_column, FALSE); - gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), list_column); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), list_column); g_signal_connect(G_OBJECT(cellrenderer), "edited", G_CALLBACK(freq_cell_edited_cb), NULL); === modified file 'src/prefs.h' --- src/prefs.h 2013-09-20 13:31:33 +0000 +++ src/prefs.h 2013-10-03 19:38:23 +0000 @@ -20,8 +20,11 @@ #include gboolean save_settings(void); + gboolean load_settings(void); +gboolean audio_box_set_visible (gboolean visible); + enum { RADIO_DEVICE, @@ -31,7 +34,7 @@ gboolean action_mode (gint mode); -void list_view_switch_to_preset (gint active); +void tree_view_switch_to_preset (gint active); GtkWidget* prefs_window(GtkWidget *app); === modified file 'src/radio.c' --- src/radio.c 2013-09-20 13:31:33 +0000 +++ src/radio.c 2013-10-03 19:38:23 +0000 @@ -31,6 +31,7 @@ #include "get_media_devices.h" extern int autodetect; +extern int can_capture; extern int alsa_loopback; extern char *alsa_playback; @@ -46,14 +47,15 @@ int radio_init(char *device, DriverType driver) { int rv = -1; + void *md; + const char *p = NULL; + + md = discover_media_devices(); if (autodetect) { - void *md; - const char *p = NULL; char buf[PATH_MAX]; *device = 0; - md = discover_media_devices(); if (!md) { fprintf (stderr, "open: Failed to open \"auto\" device"); if (*device) @@ -71,7 +73,12 @@ device = &buf[0]; } - free_media_devices(md); + p = NULL; + } + + if (!md) { + fprintf (stderr, "open: Failed to open radio device %s\n", device); + goto failure; } switch (driver) { @@ -87,9 +94,10 @@ dev = v4l1_radio_dev_new(); rv = dev->init (dev, device); if (rv == 0) { - fprintf(stderr, "v4l1: Initialization failed\n"); + fprintf(stderr, "v4l1: Initialization failed\n"); dev->finalize (dev); dev = NULL; + can_capture = 0; if (alsa_loopback) alsa_loopback = 0; if (driver != DRIVER_ANY) @@ -102,9 +110,10 @@ dev = v4l2_radio_dev_new(); rv = dev->init (dev, device); if (rv == 0) { - fprintf(stderr, "v4l2: Initialization failed\n"); + fprintf(stderr, "v4l2: Initialization failed\n"); dev->finalize (dev); dev = NULL; + can_capture = 0; if (alsa_loopback) alsa_loopback = 0; if (driver != DRIVER_ANY) @@ -117,36 +126,38 @@ if (autodetect) fprintf(stderr, "open: Using radio device: %s\n", device); + p = strrchr(device, '/'); + if (p) + p++; + else + p = device; + + p = get_associated_device(md, NULL, MEDIA_SND_CAP, p, MEDIA_V4L_RADIO); + if (p) { + can_capture = 1; + if (alsa_loopback && alsa_capture == NULL) + alsa_capture = strdup(p); + p = NULL; + } else { + can_capture = 0; + if (alsa_loopback) + alsa_loopback = 0; + } + if (alsa_loopback) { - if (alsa_capture == NULL) { - void *md = discover_media_devices(); - const char *p = strrchr(device, '/'); - if (p) - p++; - else - p = device; - - p = get_associated_device(md, NULL, MEDIA_SND_CAP, p, MEDIA_V4L_RADIO); - if (p) - alsa_capture = strdup(p); - else - alsa_loopback = 0; - - free_media_devices(md); - } - - if (alsa_loopback) { - if (alsa_playback == NULL) - alsa_playback = "default"; - - fprintf(stderr, "alsa: Using audio loopback device from %s (%s) to %s\n", - alsa_capture, device, alsa_playback); - } + if (alsa_playback == NULL) + alsa_playback = "default"; + + fprintf(stderr, "alsa: Stream started from %s (%s) to %s\n", + alsa_capture, device, alsa_playback); } radio_unmute(); failure: + if (md) + free_media_devices(md); + return rv; } @@ -161,6 +172,8 @@ radio_mute(); if (dev) dev->finalize (dev); + if (alsa_loopback) + fprintf(stderr, "alsa: Stream stopped\n"); } void radio_set_freq(float frequency) === modified file 'src/trayicon.c' --- src/trayicon.c 2013-09-20 13:31:33 +0000 +++ src/trayicon.c 2013-10-03 19:38:23 +0000 @@ -24,18 +24,16 @@ #include "gui.h" #include "trayicon.h" #include "mixer.h" -#include "prefs.h" extern gnomeradio_settings settings; -GtkWidget *tray_menu; -GObject *tray_icon; -GtkWidget *mute_menuitem; +static GtkWidget *mute_menuitem; +static GtkWidget *showwindow_menuitem; +static GtkWidget *tray_menu; +static GObject *tray_icon; int mute_menuitem_toggled_cb_id; -static GtkWidget *showwindow_menuitem; - void tray_icon_set_title(gchar *title) { if (tray_icon) @@ -167,7 +165,6 @@ void preset_menuitem_activate_cb(GtkMenuItem *menuitem, gpointer user_data) { gnomeradio_switch_to_preset(GPOINTER_TO_INT (user_data)); - list_view_switch_to_preset(GPOINTER_TO_INT (user_data)); } void create_tray_menu(GtkWidget *app) {