/*
* 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 <stdlib.h>
#include <string.h>
#include <glade/glade.h>
#include <math.h>
#include "lingot-gui-config-dialog.h"
#include "lingot-gui-config-dialog-scale.h"
#include "lingot-msg.h"
#include "lingot-i18n.h"
enum {
COLUMN_NAME = 0, COLUMN_SHIFT = 1, COLUMN_FREQUENCY = 2, NUM_COLUMNS = 3
};
void lingot_gui_config_dialog_scale_tree_add_row_tree(gpointer data,
GtkTreeView *treeview) {
GtkTreeModel *model;
GtkTreeStore *model_store;
GtkTreeIter iter1, iter2;
gdouble freq;
model = gtk_tree_view_get_model(treeview);
model_store = (GtkTreeStore *) model;
GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
if (gtk_tree_selection_count_selected_rows(selection) == 0) {
gtk_tree_store_append(model_store, &iter2, NULL);
} else {
GList *list = gtk_tree_selection_get_selected_rows(selection, &model);
int ipath = atoi(gtk_tree_path_to_string(list->data));
GString *fixed_path = g_string_new("");
g_string_printf(fixed_path, "%d", ipath);
GtkTreePath *path = gtk_tree_path_new_from_string(fixed_path->str);
g_string_free(fixed_path, TRUE);
gboolean valid = FALSE;
if (path) {
if (gtk_tree_model_get_iter(model, &iter1, path)) { // get iter from specified path
valid = TRUE;
} else { // invalid path
// g_error("Error!!!\n");
// TODO
}
gtk_tree_path_free(path);
} else {
// g_error("Error!!!\n");
// TODO
}
g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
g_list_free(list);
if (!valid)
return;
if (ipath == 0) {
lingot_msg_add_warning(
_("You cannot insert before the reference note."));
return;
}
// g_free(path_str);
gtk_tree_store_insert_before(model_store, &iter2, NULL, &iter1);
}
gtk_tree_model_get_iter_first(model, &iter1);
gtk_tree_model_get(model, &iter1, COLUMN_FREQUENCY, &freq, -1);
gtk_tree_store_set(model_store, &iter2, COLUMN_NAME, "?", COLUMN_SHIFT,
"1/1", COLUMN_FREQUENCY, freq, -1);
}
void lingot_gui_config_dialog_scale_tree_remove_selected_items(gpointer data,
GtkTreeView *treeview) {
GtkTreeStore *store;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
if (gtk_tree_selection_count_selected_rows(selection) == 0)
return;
GList *list = gtk_tree_selection_get_selected_rows(selection, &model);
store = GTK_TREE_STORE(model);
int nRemoved = 0;
while (list) {
int ipath = atoi(gtk_tree_path_to_string(list->data));
ipath -= nRemoved;
GString *fixed_path = g_string_new("");
g_string_printf(fixed_path, "%d", ipath);
GtkTreePath *path = gtk_tree_path_new_from_string(fixed_path->str);
g_string_free(fixed_path, TRUE);
if (path) {
if (ipath != 0) {
if (gtk_tree_model_get_iter(model, &iter, path)) { // get iter from specified path
gtk_tree_store_remove(store, &iter); // remove item
nRemoved++;
} else { // invalid path
// g_error("Error!!!\n");
// TODO
}
}
gtk_tree_path_free(path);
} else {
// g_error("Error!!!\n");
// TODO
}
list = list->next;
}
g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
g_list_free(list);
}
void lingot_gui_config_dialog_scale_tree_cell_edited_callback(
GtkCellRendererText *cell, gchar *path_string, gchar *new_text,
gpointer user_data) {
GtkTreeView *treeview;
GtkTreeModel *model;
GtkTreeStore *model_store;
GtkTreeIter iter, iter2;
GtkCellRenderer *renderer;
char* shift_char;
char* stored_shift_char;
gdouble freq, stored_freq, base_freq, stored_shift;
double shift_cents;
short int shift_numerator, shift_denominator;
gdouble shiftf2, freq2;
char* char_pointer;
char buff[80];
const char* delim = " \t\n";
LingotConfigDialog* config_dialog = (LingotConfigDialog*) user_data;
int index;
treeview = config_dialog->scale_treeview;
model_store = (GtkTreeStore *) gtk_tree_view_get_model(treeview);
GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
if (gtk_tree_selection_count_selected_rows(selection) != 1)
return;
GList *list = gtk_tree_selection_get_selected_rows(selection, &model);
// model_store = GTK_TREE_STORE ( model );
int ipath = atoi(gtk_tree_path_to_string(list->data));
GString *fixed_path = g_string_new("");
g_string_printf(fixed_path, "%d", ipath);
GtkTreePath *path = gtk_tree_path_new_from_string(fixed_path->str);
g_string_free(fixed_path, TRUE);
gboolean valid = FALSE;
if (path) {
if (gtk_tree_model_get_iter(model, &iter, path)) { // get iter from specified path
valid = TRUE;
} else { // invalid path
// g_error("Error!!!\n");
// TODO
}
gtk_tree_path_free(path);
} else {
// g_error("Error!!!\n");
// TODO
}
g_list_foreach(list, (GFunc) gtk_tree_path_free, NULL);
g_list_free(list);
if (!valid)
return;
renderer = &cell->parent;
guint column_number = GPOINTER_TO_UINT(g_object_get_data(
G_OBJECT(renderer), "my_column_num"));
switch (column_number) {
case COLUMN_NAME:
if (strchr(new_text, ' ') || strchr(new_text, '\t')) {
lingot_msg_add_warning(
_("Do not use space characters for the note names."));
} else if (strchr(new_text, '\n') || strchr(new_text, '{') || strchr(
new_text, '}')) {
lingot_msg_add_warning(_("The name contains illegal characters."));
} else {
char_pointer = strtok(new_text, delim);
gtk_tree_store_set(model_store, &iter, COLUMN_NAME, (char_pointer
== NULL) ? "?" : new_text, -1);
}
break;
case COLUMN_SHIFT:
lingot_config_scale_parse_shift(new_text, &shift_cents,
&shift_numerator, &shift_denominator);
// TODO: full validation
if ((ipath == 0) && (fabs(shift_cents - 0.0) > 1e-10)) {
lingot_msg_add_warning(
_("You cannot change the first shift, it must be 1/1."));
break;
}
if (isnan(shift_cents) || (shift_cents <= 0.0 - 1e-10) || (shift_cents
> 1200.0)) {
lingot_msg_add_warning(
_("The shift must be between 0 and 1200 cents, or between 1/1 and 2/1."));
break;
}
gtk_tree_model_get(model, &iter, COLUMN_SHIFT, &stored_shift_char,
COLUMN_FREQUENCY, &stored_freq, -1);
lingot_config_scale_parse_shift(stored_shift_char, &stored_shift, NULL,
NULL);
free(stored_shift_char);
lingot_config_scale_format_shift(buff, shift_cents, shift_numerator,
shift_denominator);
gtk_tree_store_set(model_store, &iter, COLUMN_SHIFT, buff,
COLUMN_FREQUENCY, stored_freq * pow(2.0, (shift_cents
- stored_shift) / 1200.0), -1);
break;
case COLUMN_FREQUENCY:
if (!strcmp(new_text, "mid-A")) {
freq = MID_A_FREQUENCY;
} else if (!strcmp(new_text, "mid-C")) {
freq = MID_C_FREQUENCY;
} else {
sscanf(new_text, "%lg", &freq);
// TODO: validation
}
gtk_tree_model_get(model, &iter, COLUMN_SHIFT, &shift_char,
COLUMN_FREQUENCY, &stored_freq, -1);
lingot_config_scale_parse_shift(shift_char, &shift_cents, NULL, NULL);
free(shift_char);
freq *= pow(2.0, -gtk_spin_button_get_value_as_float(
config_dialog->root_frequency_error) / 1200.0);
base_freq = freq * pow(2.0, -shift_cents / 1200.0);
gtk_tree_model_get_iter_first(model, &iter2);
index = 0;
do {
gtk_tree_model_get(model, &iter2, COLUMN_SHIFT, &shift_char, -1);
lingot_config_scale_parse_shift(shift_char, &shiftf2, NULL, NULL);
free(shift_char);
freq2 = base_freq * pow(2.0, shiftf2 / 1200.0);
gtk_tree_store_set(model_store, &iter2, COLUMN_FREQUENCY, (index
== ipath) ? freq : freq2, -1);
index++;
} while (gtk_tree_model_iter_next(model, &iter2));
//gtk_spin_button_set_value(config_dialog->root_frequency_error, 0.0);
break;
}
}
void lingot_gui_config_dialog_scale_tree_frequency_cell_data_function(
GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
GtkTreeIter *iter, gpointer user_data) {
gdouble freq;
gchar buf[20];
LingotConfigDialog* config_dialog = (LingotConfigDialog*) user_data;
gtk_tree_model_get(model, iter, COLUMN_FREQUENCY, &freq, -1);
freq *= pow(2.0, gtk_spin_button_get_value_as_float(
config_dialog->root_frequency_error) / 1200.0);
if (fabs(freq - MID_A_FREQUENCY) < 1e-3) {
g_object_set(renderer, "text", "mid-A", NULL);
} else if (fabs(freq - MID_C_FREQUENCY) < 1e-3) {
g_object_set(renderer, "text", "mid-C", NULL);
} else {
g_snprintf(buf, sizeof(buf), "%.4f", freq);
g_object_set(renderer, "text", buf, NULL);
}
}
void lingot_gui_config_dialog_scale_tree_add_column(
LingotConfigDialog* config_dialog) {
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeView *treeview = config_dialog->scale_treeview;
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "text", COLUMN_NAME,
NULL);
g_object_set(renderer, "editable", TRUE, NULL);
g_object_set_data(G_OBJECT(renderer), "my_column_num", GUINT_TO_POINTER(
COLUMN_NAME));
g_signal_connect(
renderer,
"edited",
(GCallback) lingot_gui_config_dialog_scale_tree_cell_edited_callback,
config_dialog);
gtk_tree_view_append_column(treeview, column);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Shift"));
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "text", COLUMN_SHIFT,
NULL);
g_object_set(renderer, "editable", TRUE, NULL);
g_object_set_data(G_OBJECT(renderer), "my_column_num", GUINT_TO_POINTER(
COLUMN_SHIFT));
// gtk_tree_view_column_set_cell_data_func(column, renderer,
// lingot_config_dialog_scale_tree_shift_cell_data_function, NULL,
// NULL);
g_signal_connect(
renderer,
"edited",
(GCallback) lingot_gui_config_dialog_scale_tree_cell_edited_callback,
config_dialog);
gtk_tree_view_append_column(treeview, column);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Frequency [Hz]"));
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "text",
COLUMN_FREQUENCY, NULL);
g_object_set(renderer, "editable", TRUE, NULL);
g_object_set_data(G_OBJECT(renderer), "my_column_num", GUINT_TO_POINTER(
COLUMN_FREQUENCY));
gtk_tree_view_column_set_cell_data_func(column, renderer,
lingot_gui_config_dialog_scale_tree_frequency_cell_data_function,
config_dialog, NULL);
g_signal_connect(
renderer,
"edited",
(GCallback) lingot_gui_config_dialog_scale_tree_cell_edited_callback,
config_dialog);
gtk_tree_view_append_column(treeview, column);
}
int lingot_gui_config_dialog_scale_validate(LingotConfigDialog* dialog,
LingotScale* scale) {
GtkTreeIter iter, iter2;
GtkTreeModel* model = gtk_tree_view_get_model(dialog->scale_treeview);
char* name;
char* name2;
char* shift_char;
gdouble shift, last_shift;
int empty_names = 0;
gtk_tree_model_get_iter_first(model, &iter);
last_shift = -1.0;
// TODO: full validation
int row1 = 0;
do {
gtk_tree_model_get(model, &iter, COLUMN_NAME, &name, COLUMN_SHIFT,
&shift_char, -1);
lingot_config_scale_parse_shift(shift_char, &shift, NULL, NULL);
free(shift_char);
if (!strcmp(name, "") || !strcmp(name, "?")) {
empty_names = 1;
}
gtk_tree_model_get_iter_first(model, &iter2);
int row2 = 0;
do {
gtk_tree_model_get(model, &iter2, COLUMN_NAME, &name2, -1);
if ((row1 != row2) && !strcmp(name, name2)) {
lingot_msg_add_error(_("There are notes with the same name"));
// TODO: select the conflictive line
free(name);
free(name2);
return 0;
}
free(name2);
row2++;
} while (gtk_tree_model_iter_next(model, &iter2));
free(name);
if (shift < last_shift) {
lingot_msg_add_error(
_("There are invalid values in the scale: the notes should be ordered by frequency / shift"));
// TODO: select the conflictive line
return 0;
}
if (shift >= 1200.0) {
lingot_msg_add_error(
_("There are invalid values in the scale: all the notes should be in the same octave"));
return 0;
}
last_shift = shift;
row1++;
} while (gtk_tree_model_iter_next(model, &iter));
if (empty_names) {
lingot_msg_add_warning(_("There are notes without name"));
return 0;
}
return 1;
}
void lingot_gui_config_dialog_scale_apply(LingotConfigDialog* dialog,
LingotScale* scale) {
GtkTreeIter iter;
GtkTreeModel* model = gtk_tree_view_get_model(dialog->scale_treeview);
gdouble freq, shift;
short int shift_num, shift_den;
char* shift_char;
gchar* name;
int i = 0;
int rows = gtk_tree_model_iter_n_children(model, NULL);
gtk_tree_model_get_iter_first(model, &iter);
gtk_tree_model_get(model, &iter, COLUMN_FREQUENCY, &freq, -1);
scale->name = strdup(gtk_entry_get_text(dialog->scale_name));
scale->base_frequency = freq;
lingot_config_scale_allocate(scale, rows);
do {
gtk_tree_model_get(model, &iter, COLUMN_NAME, &name, COLUMN_SHIFT,
&shift_char, -1);
lingot_config_scale_parse_shift(shift_char, &shift, &shift_num,
&shift_den);
free(shift_char);
scale->note_name[i] = name;
scale->offset_cents[i] = shift;
scale->offset_ratios[0][i] = shift_num;
scale->offset_ratios[1][i] = shift_den;
i++;
} while (gtk_tree_model_iter_next(model, &iter));
}
void lingot_gui_config_dialog_scale_rewrite(LingotConfigDialog* dialog,
LingotScale* scale) {
gtk_entry_set_text(dialog->scale_name, scale->name);
GtkTreeStore* store = (GtkTreeStore *) gtk_tree_view_get_model(
dialog->scale_treeview);
gtk_tree_store_clear(store);
GtkTreeIter iter2;
char buff[80];
int i;
for (i = 0; i < scale->notes; i++) {
gtk_tree_store_append(store, &iter2, NULL);
FLT freq = scale->base_frequency * pow(2.0, scale->offset_cents[i]
/ 1200.0);
lingot_config_scale_format_shift(buff, scale->offset_cents[i],
scale->offset_ratios[0][i], scale->offset_ratios[1][i]);
gtk_tree_store_set(store, &iter2, COLUMN_NAME, scale->note_name[i],
COLUMN_SHIFT, buff, COLUMN_FREQUENCY, freq, -1);
}
}
void lingot_gui_config_dialog_import_scl(gpointer data,
LingotConfigDialog* config_dialog) {
GtkWidget * dialog = gtk_file_chooser_dialog_new(_("Open Scale File"),
GTK_WINDOW(config_dialog->win), GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
GTK_RESPONSE_ACCEPT, NULL);
GtkFileFilter *filefilter;
filefilter = gtk_file_filter_new();
static gchar* filechooser_last_folder = NULL;
gtk_file_filter_set_name(filefilter, (const gchar *) _("Scala files"));
gtk_file_filter_add_pattern(filefilter, "*.scl");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), filefilter);
if (filechooser_last_folder != NULL) {
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
filechooser_last_folder);
}
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if (filechooser_last_folder != NULL)
free(filechooser_last_folder);
filechooser_last_folder = strdup(gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(dialog)));
// TODO
LingotScale* scale = lingot_config_scale_new();
if (!lingot_config_scale_load_scl(scale, filename)) {
lingot_msg_add_error(_(
"The scale cannot be imported: file format error"));
lingot_config_scale_destroy(scale);
free(scale);
} else {
lingot_gui_config_dialog_scale_rewrite(config_dialog, scale);
}
g_free(filename);
}
gtk_widget_destroy(dialog);
//g_free(filefilter);
}
gint lingot_gui_config_dialog_scale_key_press_cb(GtkWidget *widget,
GdkEventKey *kevent, gpointer data) {
LingotConfigDialog* dialog = (LingotConfigDialog*) data;
if (kevent->type == GDK_KEY_PRESS) {
if (kevent->keyval == 0xffff) {
g_signal_emit_by_name(G_OBJECT(dialog->button_scale_del),
"clicked", NULL);
} else if (kevent->keyval == 0xff63) {
g_signal_emit_by_name(G_OBJECT(dialog->button_scale_add),
"clicked", NULL);
}
}
return TRUE;
}
gint lingot_gui_config_dialog_scale_tree_view_column_get_index(
GtkTreeViewColumn *column) {
GtkTreeView *tree = GTK_TREE_VIEW(column->tree_view);
GList *cols = gtk_tree_view_get_columns(tree);
int counter = 0;
while (cols != NULL) {
if (column == GTK_TREE_VIEW_COLUMN(cols->data)) {
g_list_free(cols);
return counter;
}
cols = cols->next;
counter++;
}
g_list_free(cols);
return -1;
}
gboolean lingot_gui_config_dialog_scale_table_query_tooltip(GtkWidget *widget,
gint x, gint y, gboolean keyboard_mode, GtkTooltip *tooltip,
gpointer user_data) {
GtkTreePath* path;
GtkTreeViewColumn* col;
gint cx, cy;
gtk_tree_view_get_path_at_pos((GtkTreeView*) widget, x, y, &path, &col,
&cx, &cy);
gint column_index =
lingot_gui_config_dialog_scale_tree_view_column_get_index(col);
switch (column_index) {
case COLUMN_NAME:
gtk_tooltip_set_text(
tooltip,
_("Note identifier, free text that will be displayed in the main window when tuning close to the given note. Don't use space characters here."));
break;
case COLUMN_SHIFT:
gtk_tooltip_set_text(
tooltip,
_("Shift. You can define it as a deviation in cents from the reference note (the first one), or as a frequency ratio, like '3/2' or '5/4'. All the values must be between 0 and 1200 cents, or between 1/1 and 2/1 (i.e., all the notes must be in the same octave), and they must be well ordered."));
break;
case COLUMN_FREQUENCY:
gtk_tooltip_set_text(
tooltip,
_("Frequency. You can enter here the absolute frequency for a given note as a reference, and all the other frequencies will shift according to the deviations specified in the 'Shift' column. You can use an absolute numeric value or the keywords 'mid-C' (261.625565 Hz) and 'mid-A' (440 Hz)."));
break;
}
return TRUE;
}
void lingot_gui_config_dialog_scale_show(LingotConfigDialog* dialog,
GladeXML* _gladeXML) {
dialog->scale_name = GTK_ENTRY(
glade_xml_get_widget(_gladeXML, "scale_name"));
GtkWidget* scroll = glade_xml_get_widget(_gladeXML, "scrolledwindow1");
/* crea el modelo del arbol */
GtkTreeStore *model_store = gtk_tree_store_new(3, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_DOUBLE);
GtkTreeModel* model = GTK_TREE_MODEL(model_store);
/* crea un nuevo widget gtktreeview */
dialog->scale_treeview = GTK_TREE_VIEW(gtk_tree_view_new());
/* agrega columnas al modelo del arbol */
lingot_gui_config_dialog_scale_tree_add_column(dialog);
/* asocia el modelo al gtkteeview */
gtk_tree_view_set_model(dialog->scale_treeview, model);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(
dialog->scale_treeview), GTK_SELECTION_MULTIPLE);
g_object_unref(G_OBJECT(model));
gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(dialog->scale_treeview));
dialog->button_scale_del = GTK_BUTTON(glade_xml_get_widget(_gladeXML,
"button_scale_del"));
dialog->button_scale_add = GTK_BUTTON(glade_xml_get_widget(_gladeXML,
"button_scale_add"));
GtkButton* button_import = GTK_BUTTON(glade_xml_get_widget(_gladeXML,
"button_scale_import"));
g_signal_connect(G_OBJECT(dialog->scale_treeview), "key_press_event",
G_CALLBACK(lingot_gui_config_dialog_scale_key_press_cb), dialog);
g_signal_connect(G_OBJECT(dialog->button_scale_add), "clicked", G_CALLBACK(
lingot_gui_config_dialog_scale_tree_add_row_tree),
dialog->scale_treeview);
g_signal_connect(G_OBJECT(dialog->button_scale_del), "clicked", G_CALLBACK(
lingot_gui_config_dialog_scale_tree_remove_selected_items),
dialog->scale_treeview);
g_signal_connect(G_OBJECT(button_import), "clicked", G_CALLBACK(
lingot_gui_config_dialog_import_scl), dialog);
gtk_widget_set_has_tooltip(GTK_WIDGET(dialog->scale_treeview), TRUE);
g_signal_connect(G_OBJECT(dialog->scale_treeview), "query-tooltip",
(GCallback) lingot_gui_config_dialog_scale_table_query_tooltip,
NULL);
}