- import version 0.9.1 from upstream

1 files changed, 435 insertions, 0 deletions

diff --git a/src/lingot-gui-config-dialog.c b/src/lingot-gui-config-dialog.c
new file mode 100644
index 0000000..ef76889
--- /dev/null
+++ b/src/lingot-gui-config-dialog.c
@@ -0,0 +1,435 @@
+/*
+ * lingot, a musical instrument tuner.
+ *
+ * Copyright (C) 2004-2011  Ibán Cereijo Graña, Jairo Chapela Martínez.
+ *
+ * This file is part of lingot.
+ *
+ * lingot 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.
+ *
+ * lingot 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 lingot; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <stdio.h>
+#include <math.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <glade/glade.h>
+
+#include "lingot-defs.h"
+
+#include "lingot-core.h"
+#include "lingot-config.h"
+#include "lingot-gui-mainframe.h"
+#include "lingot-gui-config-dialog.h"
+#include "lingot-i18n.h"
+#include "lingot-config.h"
+#include "lingot-gui-config-dialog-scale.h"
+#include "lingot-msg.h"
+
+int lingot_gui_config_dialog_apply(LingotConfigDialog*);
+void lingot_gui_config_dialog_close(LingotConfigDialog*);
+void lingot_gui_config_dialog_rewrite(LingotConfigDialog*);
+void lingot_gui_config_dialog_combo_select_value(GtkWidget* combo, int value);
+audio_system_t lingot_gui_config_dialog_get_audio_system(GtkComboBox* combo);
+
+/* button press event attention routine. */
+
+void lingot_gui_config_dialog_callback_button_cancel(GtkButton *button,
+		LingotConfigDialog* dialog) {
+	lingot_gui_config_dialog_close(dialog);
+}
+
+void lingot_gui_config_dialog_callback_button_ok(GtkButton *button,
+		LingotConfigDialog* dialog) {
+	if (lingot_gui_config_dialog_apply(dialog)) {
+		// dumps the current config to the config file
+		lingot_config_save(dialog->conf, CONFIG_FILE_NAME);
+		// establish the current config as the old config, so the close rollback
+		// will do nothing.
+		lingot_config_copy(dialog->conf_old, dialog->conf);
+		lingot_gui_config_dialog_close(dialog);
+	}
+}
+
+void lingot_gui_config_dialog_callback_button_apply(GtkButton *button,
+		LingotConfigDialog* dialog) {
+	if (lingot_gui_config_dialog_apply(dialog)) {
+		lingot_gui_config_dialog_rewrite(dialog);
+	}
+}
+
+void lingot_gui_config_dialog_callback_button_default(GtkButton *button,
+		LingotConfigDialog* dialog) {
+	lingot_config_restore_default_values(dialog->conf);
+	lingot_gui_config_dialog_rewrite(dialog);
+}
+
+void lingot_gui_config_dialog_callback_cancel(GtkWidget *widget,
+		LingotConfigDialog* dialog) {
+	//lingot_mainframe_change_config(dialog->mainframe, dialog->conf_old); // restore old configuration.
+	lingot_gui_config_dialog_close(dialog);
+}
+
+void lingot_gui_config_dialog_callback_close(GtkWidget *widget,
+		LingotConfigDialog *dialog) {
+	lingot_gui_mainframe_change_config(dialog->mainframe, dialog->conf_old); // restore old configuration.
+	gtk_widget_destroy(dialog->win);
+	lingot_gui_config_dialog_destroy(dialog);
+}
+
+void lingot_gui_config_dialog_callback_change_sample_rate(GtkWidget *widget,
+		LingotConfigDialog *dialog) {
+
+	const gchar* text = gtk_entry_get_text(GTK_ENTRY(
+			GTK_BIN(dialog->sample_rate)->child));
+
+	int sr;
+	if (text != NULL) {
+		sr = atoi(text);
+	} else {
+		sr = 44100;
+		//g_print("WARNING: cannot get sample rate, assuming 44100\n");
+	}
+
+	char buff1[20];
+	char buff2[20];
+	gdouble srf = sr;
+	gdouble os = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(
+			dialog->oversampling));
+	sprintf(buff1, "%d", sr);
+	sprintf(buff2, " = %0.1f", srf / os);
+	gtk_label_set_text(dialog->label_sample_rate1, buff1);
+	//gtk_label_set_text(dialog->jack_label_sample_rate1, buff1);
+	gtk_label_set_text(dialog->label_sample_rate2, buff2);
+}
+
+void lingot_gui_config_dialog_callback_change_input_system(GtkWidget *widget,
+		LingotConfigDialog *dialog) {
+
+	char buff[10];
+	char* text = gtk_combo_box_get_active_text(dialog->input_system);
+	audio_system_t audio_system = str_to_audio_system_t(text);
+	free(text);
+
+	LingotAudioSystemProperties* properties =
+			lingot_audio_get_audio_system_properties(audio_system);
+
+	if (properties != NULL) {
+		if ((properties->forced_sample_rate)
+				&& (properties->n_sample_rates > 0)) {
+			sprintf(buff, "%d", properties->sample_rates[0]);
+			gtk_entry_set_text(GTK_ENTRY(GTK_BIN(dialog->sample_rate)->child),
+					buff);
+		}
+
+		gtk_widget_set_sensitive(GTK_WIDGET(dialog->sample_rate),
+				(gboolean) !properties->forced_sample_rate);
+
+		GtkListStore* model = GTK_LIST_STORE(gtk_combo_box_get_model(
+						GTK_COMBO_BOX(dialog->sample_rate)));
+		gtk_list_store_clear(model);
+
+		int i;
+		for (i = 0; i < properties->n_sample_rates; i++) {
+			sprintf(buff, "%d", properties->sample_rates[i]);
+			gtk_combo_box_append_text(GTK_COMBO_BOX(dialog->sample_rate), buff);
+		}
+
+		// TODO: devices
+
+		gtk_entry_set_text(GTK_ENTRY(GTK_BIN(dialog->input_dev)->child),
+				dialog->conf->audio_dev[audio_system]);
+		gtk_widget_set_sensitive(GTK_WIDGET(dialog->input_dev),
+				(gboolean) (audio_system != AUDIO_SYSTEM_JACK));
+
+		lingot_audio_audio_system_properties_destroy(properties);
+	} else {
+		gtk_entry_set_text(GTK_ENTRY(GTK_BIN(dialog->input_dev)->child), "");
+		gtk_widget_set_sensitive(GTK_WIDGET(dialog->input_dev), FALSE);
+		gtk_widget_set_sensitive(GTK_WIDGET(dialog->sample_rate), FALSE);
+	}
+}
+
+void lingot_gui_config_dialog_callback_change_deviation(GtkWidget *widget,
+		LingotConfigDialog *dialog) {
+	gtk_widget_queue_draw(GTK_WIDGET(dialog->scale_treeview));
+}
+
+void lingot_gui_config_dialog_set_audio_system(GtkComboBox* combo,
+		audio_system_t audio_system) {
+	const char* token = audio_system_t_to_str(audio_system);
+	GtkTreeModel* model = gtk_combo_box_get_model(combo);
+	GtkTreeIter iter;
+
+	gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
+
+	while (valid) {
+		gchar *str_data;
+		gtk_tree_model_get(model, &iter, 0, &str_data, -1);
+		if (!strcmp(str_data, token))
+			gtk_combo_box_set_active_iter(combo, &iter);
+		g_free(str_data);
+		valid = gtk_tree_model_iter_next(model, &iter);
+	}
+}
+
+audio_system_t lingot_gui_config_dialog_get_audio_system(GtkComboBox* combo) {
+	char* text = gtk_combo_box_get_active_text(combo);
+	int result = str_to_audio_system_t(text);
+	free(text);
+	return result;
+}
+
+void lingot_gui_config_dialog_combo_select_value(GtkWidget* combo, int value) {
+
+	GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+	GtkTreeIter iter;
+
+	gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
+
+	while (valid) {
+		gchar *str_data;
+		gtk_tree_model_get(model, &iter, 0, &str_data, -1);
+		if (atoi(str_data) == value)
+			gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+		g_free(str_data);
+		valid = gtk_tree_model_iter_next(model, &iter);
+	}
+}
+
+void lingot_gui_config_dialog_rewrite(LingotConfigDialog* dialog) {
+	LingotConfig* conf = dialog->conf;
+
+	lingot_gui_config_dialog_set_audio_system(dialog->input_system,
+			conf->audio_system);
+	//		gtk_entry_set_text(dialog->oss_input_dev, conf->audio_dev);
+	//		gtk_entry_set_text(dialog->alsa_input_dev, conf->audio_dev_alsa);
+	gtk_entry_set_text(GTK_ENTRY(GTK_BIN(dialog->input_dev)->child),
+			conf->audio_dev[conf->audio_system]);
+
+	gtk_range_set_value(GTK_RANGE(dialog->calculation_rate),
+			conf->calculation_rate);
+	gtk_range_set_value(GTK_RANGE(dialog->visualization_rate),
+			conf->visualization_rate);
+	gtk_range_set_value(GTK_RANGE(dialog->noise_threshold),
+			conf->noise_threshold_db);
+	gtk_range_set_value(GTK_RANGE(dialog->gain), conf->gain);
+	gtk_spin_button_set_value(dialog->oversampling, conf->oversampling);
+	//	lingot_config_dialog_set_root_reference_note(
+	//			dialog->combo_root_frequency_reference_note,
+	//			conf->root_frequency_referente_note);
+	gtk_spin_button_set_value(dialog->root_frequency_error,
+			conf->root_frequency_error);
+	gtk_spin_button_set_value(dialog->temporal_window, conf->temporal_window);
+	gtk_spin_button_set_value(dialog->dft_number, conf->dft_number);
+	gtk_spin_button_set_value(dialog->dft_size, conf->dft_size);
+	gtk_spin_button_set_value(dialog->peak_number, conf->peak_number);
+	gtk_spin_button_set_value(dialog->peak_halfwidth, conf->peak_half_width);
+	gtk_spin_button_set_value(dialog->minimum_frequency, conf->min_frequency);
+	gtk_range_set_value(GTK_RANGE(dialog->rejection_peak_relation),
+			conf->peak_rejection_relation_db);
+	lingot_gui_config_dialog_combo_select_value(GTK_WIDGET(dialog->fft_size),
+			(int) conf->fft_size);
+
+	char buff[10];
+	sprintf(buff, "%d", conf->sample_rate);
+	gtk_entry_set_text(GTK_ENTRY(GTK_BIN(dialog->sample_rate)->child), buff);
+
+	lingot_gui_config_dialog_scale_rewrite(dialog, conf->scale);
+}
+
+void lingot_gui_config_dialog_destroy(LingotConfigDialog* dialog) {
+	dialog->mainframe->config_dialog = NULL;
+	lingot_config_destroy(dialog->conf);
+	lingot_config_destroy(dialog->conf_old);
+	free(dialog);
+}
+
+int lingot_gui_config_dialog_apply(LingotConfigDialog* dialog) {
+
+	gchar* text1;
+	const gchar* text2;
+	LingotConfig* conf = dialog->conf;
+
+	if (!lingot_gui_config_dialog_scale_validate(dialog, conf->scale)) {
+		return 0;
+	}
+
+	conf->audio_system = lingot_gui_config_dialog_get_audio_system(
+			dialog->input_system);
+	sprintf(conf->audio_dev[conf->audio_system], "%s", gtk_entry_get_text(
+			GTK_ENTRY(GTK_BIN(dialog->input_dev)->child)));
+	conf->root_frequency_error = gtk_spin_button_get_value_as_float(
+			dialog->root_frequency_error);
+	conf->calculation_rate = gtk_range_get_value(GTK_RANGE(
+			dialog->calculation_rate));
+	conf->visualization_rate = gtk_range_get_value(GTK_RANGE(
+			dialog->visualization_rate));
+	conf->temporal_window = gtk_spin_button_get_value_as_float(
+			dialog->temporal_window);
+	conf->noise_threshold_db = gtk_range_get_value(GTK_RANGE(
+			dialog->noise_threshold));
+	conf->gain = gtk_range_get_value(GTK_RANGE(dialog->gain));
+	conf->oversampling = gtk_spin_button_get_value_as_int(dialog->oversampling);
+	conf->dft_number = gtk_spin_button_get_value_as_int(dialog->dft_number);
+	conf->dft_size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(
+			dialog->dft_size));
+	conf->peak_number = gtk_spin_button_get_value_as_int(dialog->peak_number);
+	conf->peak_half_width = gtk_spin_button_get_value_as_int(
+			dialog->peak_halfwidth);
+	conf->peak_rejection_relation_db = gtk_range_get_value(GTK_RANGE(
+			dialog->rejection_peak_relation));
+	conf->min_frequency = gtk_spin_button_get_value_as_int(
+			dialog->minimum_frequency);
+	text1 = gtk_combo_box_get_active_text(dialog->fft_size);
+	conf->fft_size = atoi(text1);
+	g_free(text1);
+	text2 = gtk_entry_get_text(GTK_ENTRY(GTK_BIN(dialog->sample_rate)->child));
+	conf->sample_rate = atoi(text2);
+
+	LingotScale* scale = conf->scale;
+	lingot_config_scale_destroy(scale);
+
+	lingot_gui_config_dialog_scale_apply(dialog, scale);
+
+	lingot_config_update_internal_params(conf);
+	lingot_gui_mainframe_change_config(dialog->mainframe, conf);
+
+	if (scale->max_offset_rounded > 200) {
+		lingot_msg_add_warning(
+				_("The provided scale contains wide gaps in frequency that increase the gauge range and produce a loss of visual accuracy. Consider providing scales with at least 12 tones, or with a maximum distance between adjacent notes below 200 cents."));
+	}
+
+	return 1;
+}
+
+void lingot_gui_config_dialog_close(LingotConfigDialog* dialog) {
+	dialog->mainframe->config_dialog = NULL;
+	gtk_widget_destroy(dialog->win);
+}
+
+void lingot_gui_config_dialog_show(LingotMainFrame* frame, LingotConfig* config) {
+	GladeXML* _gladeXML = NULL;
+
+	if (frame->config_dialog == NULL) {
+
+		LingotConfigDialog* dialog = malloc(sizeof(LingotConfigDialog));
+
+		dialog->mainframe = frame;
+		dialog->conf = lingot_config_new();
+		dialog->conf_old = lingot_config_new();
+
+		// config copy
+		lingot_config_copy(dialog->conf, (config == NULL) ? frame->conf
+				: config);
+		lingot_config_copy(dialog->conf_old, frame->conf);
+
+		// TODO: obtain glade files installation dir by other way
+#	    define FILE_NAME "lingot-config-dialog.glade"
+		FILE* fd = fopen("src/glade/" FILE_NAME, "r");
+		if (fd != NULL) {
+			fclose(fd);
+			_gladeXML = glade_xml_new("src/glade/" FILE_NAME, "dialog1", NULL);
+		} else {
+			_gladeXML = glade_xml_new(LINGOT_GLADEDIR FILE_NAME, "dialog1",
+					NULL);
+		}
+#		undef FILE_NAME
+
+		dialog->win = glade_xml_get_widget(_gladeXML, "dialog1");
+
+		gtk_window_set_icon(GTK_WINDOW(dialog->win), gtk_window_get_icon(
+				GTK_WINDOW(frame->win)));
+		//gtk_window_set_position(GTK_WINDOW(dialog->win), GTK_WIN_POS_CENTER_ALWAYS);
+		dialog->mainframe->config_dialog = dialog;
+
+		dialog->input_system
+				= GTK_COMBO_BOX(glade_xml_get_widget(_gladeXML, "input_system"));
+		dialog->input_dev
+				= GTK_COMBO_BOX_ENTRY(glade_xml_get_widget(_gladeXML, "input_dev"));
+		dialog->sample_rate
+				= GTK_COMBO_BOX_ENTRY(glade_xml_get_widget(_gladeXML, "sample_rate"));
+		dialog->calculation_rate
+				= GTK_HSCALE(glade_xml_get_widget(_gladeXML, "calculation_rate"));
+		dialog->visualization_rate
+				= GTK_HSCALE(glade_xml_get_widget(_gladeXML, "visualization_rate"));
+		dialog->noise_threshold
+				= GTK_HSCALE(glade_xml_get_widget(_gladeXML, "noise_threshold"));
+		dialog->gain = GTK_HSCALE(glade_xml_get_widget(_gladeXML, "gain"));
+		dialog->oversampling
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML, "oversampling"));
+		dialog->fft_size
+				= GTK_COMBO_BOX(glade_xml_get_widget(_gladeXML, "fft_size"));
+		dialog->temporal_window
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML, "temporal_window"));
+		dialog->root_frequency_error
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML,
+								"root_frequency_error"));
+		dialog->dft_number
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML, "dft_number"));
+		dialog->dft_size
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML, "dft_size"));
+		dialog->peak_number
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML, "peak_number"));
+		dialog->peak_halfwidth
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML, "peak_halfwidth"));
+		dialog->rejection_peak_relation
+				= GTK_HSCALE(glade_xml_get_widget(_gladeXML,
+								"rejection_peak_relation"));
+		dialog->label_sample_rate1 = GTK_LABEL(glade_xml_get_widget(_gladeXML,
+						"label_sample_rate1"));
+		dialog->label_sample_rate2 = GTK_LABEL(glade_xml_get_widget(_gladeXML,
+						"label_sample_rate2"));
+		dialog->minimum_frequency
+				= GTK_SPIN_BUTTON(glade_xml_get_widget(_gladeXML,
+								"minimum_frequency"));
+
+		lingot_gui_config_dialog_scale_show(dialog, _gladeXML);
+
+		gtk_signal_connect(GTK_OBJECT(dialog->input_system), "changed",
+				GTK_SIGNAL_FUNC (lingot_gui_config_dialog_callback_change_input_system), dialog);
+		gtk_signal_connect(GTK_OBJECT(GTK_BIN(dialog->sample_rate)->child), "changed",
+				GTK_SIGNAL_FUNC (lingot_gui_config_dialog_callback_change_sample_rate), dialog);
+
+		gtk_signal_connect (GTK_OBJECT (dialog->oversampling), "value_changed",
+				GTK_SIGNAL_FUNC (lingot_gui_config_dialog_callback_change_sample_rate), dialog);
+		gtk_signal_connect (GTK_OBJECT (dialog->root_frequency_error), "value_changed",
+				GTK_SIGNAL_FUNC (lingot_gui_config_dialog_callback_change_deviation), dialog);
+
+		g_signal_connect(GTK_OBJECT(glade_xml_get_widget(_gladeXML, "button_default")), "clicked", GTK_SIGNAL_FUNC(lingot_gui_config_dialog_callback_button_default), dialog);
+		g_signal_connect(GTK_OBJECT(glade_xml_get_widget(_gladeXML, "button_apply")), "clicked", GTK_SIGNAL_FUNC(lingot_gui_config_dialog_callback_button_apply), dialog);
+		g_signal_connect(GTK_OBJECT(glade_xml_get_widget(_gladeXML, "button_accept")), "clicked", GTK_SIGNAL_FUNC(lingot_gui_config_dialog_callback_button_ok), dialog);
+		g_signal_connect(GTK_OBJECT(glade_xml_get_widget(_gladeXML, "button_cancel")), "clicked", GTK_SIGNAL_FUNC(lingot_gui_config_dialog_callback_button_cancel), dialog);
+		g_signal_connect(GTK_OBJECT(dialog->win), "destroy", GTK_SIGNAL_FUNC(lingot_gui_config_dialog_callback_close), dialog);
+
+		lingot_gui_config_dialog_rewrite(dialog);
+
+		gtk_widget_show(dialog->win);
+		GtkWidget* scroll = glade_xml_get_widget(_gladeXML, "scrolledwindow1");
+		gtk_widget_show_all(scroll);
+		g_object_unref(_gladeXML);
+	} else {
+		if (config != NULL) {
+			lingot_config_copy(frame->config_dialog->conf, config);
+			lingot_gui_config_dialog_rewrite(frame->config_dialog);
+		}
+
+		gtk_window_present(GTK_WINDOW(frame->config_dialog->win));
+	}
+
+	if (config != NULL) {
+		lingot_config_destroy(config);
+	}
+}