~blackskad/gnomeradio/dev-vol-button

/* 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 <config.h>

#include <gnome.h>

#include <gconf/gconf-client.h>

#include <math.h>

#include "gui.h"

#include "trayicon.h"

#include "tech.h"

#include "radio.h"

#include "rec_tech.h"

#include "lirc.h"

#include "prefs.h"

#include "record.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"

GtkWidget* mute_button, *preset_combo;

GtkAdjustment *adj;

GtkTooltips *tooltips;

int mom_ps;

gnomeradio_settings settings;

gboolean main_visible;

static GtkWidget *drawing_area;

static GdkPixmap *digits, *signal_s, *stereo;

static GtkWidget *freq_scale;

static GtkWidget *rec_pixmap;

static int timeout_id, bp_timeout_id = -1, bp_timeout_steps = 0;

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(_("%d stations found"), 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("%.2f is a station\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 *title;

	char *title_hdr;

	data.stations = NULL;

	data.dialog = gtk_dialog_new_with_buttons(_("Scanning"),

		GTK_WINDOW(app), DIALOG_FLAGS, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);

	gtk_dialog_set_has_separator(GTK_DIALOG(data.dialog), FALSE);

	gtk_window_set_resizable(GTK_WINDOW(data.dialog), FALSE);

	title_hdr = g_strconcat("<span weight=\"bold\">", _("Scanning for available stations:"), "</span>", NULL);

	title = gtk_label_new(title_hdr);

	gtk_misc_set_alignment(GTK_MISC(title), 0, 0.5);

	gtk_label_set_use_markup(GTK_LABEL(title), TRUE);

	g_free(title_hdr);

	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), title, FALSE, FALSE, 6);

	data.progress = gtk_progress_bar_new();

	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), data.progress, TRUE, FALSE, 6);

	data.label = gtk_label_new(_("No stations found"));

	gtk_misc_set_alignment(GTK_MISC(data.label), 0, 0.5);

	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), 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);	

	int response = 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 (g_list_length(data.stations) > 0) {

			gfloat f = *((gfloat*)data.stations->data);

			adj->value = f*STEPS;

			radio_set_freq(f);

			GtkWidget *dialog;

			GList *ptr;

			char *text;

			text = g_strdup_printf(_("%d stations found. \nDo you want to add them as presets?\n"),

					g_list_length(data.stations));

			dialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_QUESTION,

					GTK_BUTTONS_YES_NO, text);

			g_free(text);

			int response = gtk_dialog_run(GTK_DIALOG(dialog));

			gtk_widget_destroy(dialog);

			for (ptr = data.stations; ptr; ptr = ptr->next) {

				if (response == GTK_RESPONSE_YES) {

					preset *ps = g_malloc0(sizeof(preset));

					ps->title = g_strdup(_("unnamed"));

					ps->freq = *((gfloat*)ptr->data);

					settings.presets = g_list_append(settings.presets, ps);

				}

				g_free(ptr->data);

			}	

		}

	}	

}	

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 <e9725005@stud3.tuwien.ac.at> 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));*/

	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_entry */

				gtk_widget_hide_all(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;

    }

	if (!radio_init(settings.device, driver))

	{

		char *caption = g_strdup_printf(_("Could not open device \"%s\"!"), settings.device);

		char *detail = g_strdup_printf(_("Check your settings and make sure that no other\n"

				"program is using %s.\nAlso make sure that you have read-access to it."), settings.device);

		show_error_message(caption, detail);

		g_free(caption);

		g_free(detail);

		if (!restart)

			prefs_button_clicked_cb(NULL, app);

	}

}

void start_mixer(gboolean restart, GtkWidget *app)

{

	gint res, vol;

	if (restart)

		mixer_close();

	res = mixer_init(settings.mixer_dev, settings.mixer);

	if (res <1) 

	{

		char *buffer;

		if (res == -1)

			buffer = g_strdup_printf(_("Mixer source \"%s\" is not a valid source!"), settings.mixer);

		else 

			buffer = g_strdup_printf(_("Could not open \"%s\"!"), settings.mixer_dev);

		show_error_message(buffer, NULL);

		g_free(buffer);

	}		

	vol = mixer_get_volume();

	if (vol >= 0) {

		g_message("setting volume: %d -> %d", gtk_volume_button_get_value(mute_button), vol);

		gtk_volume_button_set_value(mute_button, vol);

		g_message("new volume: %d", gtk_volume_button_get_value(mute_button));

		/*gtk_adjustment_set_value(volume, (double)vol);*/

	}

}

GList* get_mixer_recdev_list(void)

{

	int i;

	char **array, *dev;

	GList *result = NULL;

	array = mixer_get_rec_devices();

	if (!array)

		return NULL;

	i = 0;	

	dev = array[i];

	while (dev)

	{

		char *text = g_strdup(dev);

		result = g_list_append(result, text);

		free(dev);

		dev = array[++i];

	}			

	free(array);

	return result;

}

static gboolean redraw_status_window(void)

{

	GdkWindow *real_window, *window;

	GdkGC *gc;

	int win_width, win_height;

	int val, freq[5], signal_strength, is_stereo;

	val = (int)(rint(adj->value/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 = drawing_area->window;

	if (real_window == NULL)

		/* UI has not been realized yet */

		return TRUE;

	gc = gdk_gc_new(real_window);

	gdk_drawable_get_size(real_window, &win_width, &win_height);

	/* use doublebuffering to avoid flickering */

	window = gdk_pixmap_new(real_window, win_width, win_height, -1);

	gdk_draw_rectangle(window, gc, TRUE, 0, 0, win_width, win_height);

	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);

	else gdk_draw_rectangle(window, gc, TRUE, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH);

	gdk_draw_drawable(window, gc, digits, freq[1] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*5, 5, DIGIT_WIDTH, DIGIT_HEIGTH);

	gdk_draw_drawable(window, gc, digits, freq[2] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*4, 5, DIGIT_WIDTH, DIGIT_HEIGTH);

	gdk_draw_drawable(window, gc, digits, 10 * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*3, 5, DIGIT_WIDTH, DIGIT_HEIGTH);

	gdk_draw_drawable(window, gc, digits, freq[3] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*2, 5, DIGIT_WIDTH, DIGIT_HEIGTH);

	gdk_draw_drawable(window, gc, digits, freq[4] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*1, 5, DIGIT_WIDTH, DIGIT_HEIGTH);

	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_draw_drawable(window, gc, stereo, is_stereo * STEREO_WIDTH, 0, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH, 5, STEREO_WIDTH, DIGIT_HEIGTH);

	/* draw the pixmap to the real window */	

	gdk_draw_drawable(real_window, gc, window, 0, 0, 0, 0, win_width + 5, win_height);

	g_object_unref(G_OBJECT(gc));

	g_object_unref(G_OBJECT(window));

	return TRUE;	

}

static gboolean expose_event_cb(GtkWidget *widget, GdkEventExpose *event, gpointer data)

{

	redraw_status_window();

	return TRUE;

}	

void exit_gnome_radio(void)

{

	if (settings.mute_on_exit)

	{

		radio_mute();

		radio_stop();

	}

	mixer_close();

	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(adj->value)/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(GTK_STATUS_ICON(tray_icon), buffer); //gtk_tooltips_set_tip(tooltips, tray_icon, buffer, NULL);

	g_free(buffer);

	buffer = g_strdup_printf(_("Frequency: %.2f MHz"), freq);

	gtk_tooltips_set_tip(tooltips, freq_scale, buffer, NULL);

	g_free(buffer);

	radio_set_freq(adj->value/STEPS);

}

static void volume_value_changed_cb(GtkVolumeButton *button, gpointer user_data)

{

	char *text;

	int vol = (int)(gtk_volume_button_get_value(mute_button) + 0.5f);

	mixer_set_volume(vol);

/*	text = g_strdup_printf(_("Volume: %d%%"), vol);

	gtk_tooltips_set_tip(tooltips, vol_scale, text, NULL);

	g_free(text);*/

    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)data;

	if (increase)

	{

		if (adj->value >= FREQ_MAX*STEPS)

			gtk_adjustment_set_value(adj, FREQ_MIN*STEPS);

		else

			gtk_adjustment_set_value(adj, adj->value+1);

	}

	else

	{

		if (adj->value <= FREQ_MIN*STEPS)

			gtk_adjustment_set_value(adj, FREQ_MAX*STEPS);

		else

			gtk_adjustment_set_value(adj, adj->value-1);

	}

}

static gboolean change_frequency_timeout(gpointer data)

{

	change_frequency(data);

	if (bp_timeout_steps < 10)

	{

		gtk_timeout_remove(bp_timeout_id);

		bp_timeout_id = gtk_timeout_add(200 - 20*bp_timeout_steps,

			(GtkFunction)change_frequency_timeout, data);

		bp_timeout_steps++; 

	}

	return TRUE;

}	

static void step_button_pressed_cb(GtkButton *button, gpointer data)

{

	bp_timeout_id = gtk_timeout_add(500, (GtkFunction)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)

		gtk_timeout_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 = (gint)(data);

	if (!max) {

		max = (FREQ_MAX - FREQ_MIN) * STEPS;

	}	

	if (radio_check_station(adj->value/STEPS) || (start > max))	{

		start = mom = 0;

		radio_unmute();

		timeout_id = 0;

		return FALSE;

	}

	if (!mom) {

		mom = adj->value;

	}

	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) {

		gtk_timeout_remove(timeout_id);

		timeout_id = 0;

		radio_unmute();

		return;

	}

	radio_mute();

	timeout_id = gtk_timeout_add(1000/SCAN_SPEED, (GtkFunction)scan_freq, (gpointer)1);	

}

void scbw_button_clicked_cb(GtkButton *button, gpointer data)

{

	if (timeout_id) {

		gtk_timeout_remove(timeout_id);

		timeout_id = 0;

		radio_unmute();

		return;

	}

	radio_mute();

	timeout_id = gtk_timeout_add(1000/SCAN_SPEED, (GtkFunction)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);

}

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_MENU_SHELL(tray_menu)->children;

	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);

}

static int start_recording(const gchar *destination, const char* station, const char* time)

{

	GtkWidget *dialog;

	Recording* recording;

	char *filename;

	if (!mixer_set_rec_device())

	{

		GtkWidget *dialog;

		dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,

				"Could not set \"%s\" as recording Source", settings.mixer);

		gtk_dialog_run (GTK_DIALOG (dialog));

		gtk_widget_destroy (dialog);

		return -1;

	}

	/* You can translate the filename for a recording:

	 * args for this format are: path, station title, time 

	 */ 

	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->station = g_strdup(station);

	dialog = record_status_window(recording);

	run_status_window(recording);

	return 1;

}

void rec_button_clicked_cb(GtkButton *button, gpointer app)

{

	GtkWidget *dialog;

	char *station;

	char time_str[100];

	time_t t;