X-Git-Url: https://git.street.me.uk/andy/viking.git/blobdiff_plain/8339c44d59a9541171338d5bc3b2abc7e32dde5f..bc07590a14b533ff65b0c4e802e160de7816ec0d:/src/preferences.c diff --git a/src/preferences.c b/src/preferences.c index 07f00c51..7174cc99 100644 --- a/src/preferences.c +++ b/src/preferences.c @@ -1,126 +1,86 @@ +/* + * viking -- GPS Data and Topo Analyzer, Explorer, and Manager + * + * Copyright (C) 2003-2007, Evan Battaglia + * + * 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 +#include +#include #include "preferences.h" +#include "dir.h" #include "file.h" +#include "util.h" -// TODO: register_group // TODO: STRING_LIST // TODO: share code in file reading // TODO: remove hackaround in show_window -// TODO: move typeddata to uibuilder, make it more used & general, it's a "prettier" solution methinks -// maybe this wasn't such a good idea... #define VIKING_PREFS_FILE "viking.prefs" -#define TEST_BOOLEAN(str) (! ((str)[0] == '\0' || (str)[0] == '0' || (str)[0] == 'n' || (str)[0] == 'N' || (str)[0] == 'f' || (str)[0] == 'F') ) - -/** application wide parameters. */ -static VikLayerParam prefs[] = { - { "geocaching.username", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("geocaching.com username:"), VIK_LAYER_WIDGET_ENTRY }, - { "geocaching.password", VIK_LAYER_PARAM_STRING, VIK_LAYER_GROUP_NONE, N_("geocaching.com password:"), VIK_LAYER_WIDGET_ENTRY }, -}; - static GPtrArray *params; static GHashTable *values; +gboolean loaded; -/************/ +/************ groups *********/ -typedef struct { - VikLayerParamData data; - guint8 type; - gpointer freeme; // because data.s is const and the compiler complains -} VikLayerTypedParamData; +static GPtrArray *groups_names; +static GHashTable *groups_keys_to_indices; // contains gint, NULL (0) is not found, instead 1 is used for 0, 2 for 1, etc. -void layer_typed_param_data_free(gpointer p) +static void preferences_groups_init() { - VikLayerTypedParamData *val = (VikLayerTypedParamData *)p; - switch ( val->type ) { - case VIK_LAYER_PARAM_STRING: - if ( val->freeme ) - g_free ( val->freeme ); - break; - /* TODO: APPLICABLE TO US? NOTE: string layer works auniquely: data.sl should NOT be free'd when - * the internals call get_param -- i.e. it should be managed w/in the layer. - * The value passed by the internals into set_param should also be managed - * by the layer -- i.e. free'd by the layer. - */ - case VIK_LAYER_PARAM_STRING_LIST: - g_error ( "Param strings not implemented in preferences"); //fake it - break; - } - g_free ( val ); + groups_names = g_ptr_array_new(); + groups_keys_to_indices = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL ); } -VikLayerTypedParamData *layer_typed_param_data_copy_from_data(guint8 type, VikLayerParamData val) { - VikLayerTypedParamData *newval = g_new(VikLayerTypedParamData,1); - newval->data = val; - newval->type = type; - switch ( newval->type ) { - case VIK_LAYER_PARAM_STRING: { - gchar *s = g_strdup(newval->data.s); - newval->data.s = s; - newval->freeme = s; - break; - } - /* TODO: APPLICABLE TO US? NOTE: string layer works auniquely: data.sl should NOT be free'd when - * the internals call get_param -- i.e. it should be managed w/in the layer. - * The value passed by the internals into set_param should also be managed - * by the layer -- i.e. free'd by the layer. - */ - case VIK_LAYER_PARAM_STRING_LIST: - g_error ( "Param strings not implemented in preferences"); //fake it - break; - } - return newval; +static void preferences_groups_uninit() +{ + g_ptr_array_foreach ( groups_names, (GFunc)g_free, NULL ); + g_ptr_array_free ( groups_names, TRUE ); + g_hash_table_destroy ( groups_keys_to_indices ); } -/* TODO: share this code with file.c */ -VikLayerTypedParamData *layer_data_typed_param_copy_from_string ( guint8 type, const gchar *str ) +void a_preferences_register_group ( const gchar *key, const gchar *name ) { - g_assert ( type != VIK_LAYER_PARAM_STRING_LIST ); - VikLayerTypedParamData *rv = g_new(VikLayerTypedParamData,1); - rv->type = type; - switch ( type ) - { - case VIK_LAYER_PARAM_DOUBLE: rv->data.d = strtod(str, NULL); break; - case VIK_LAYER_PARAM_UINT: rv->data.u = strtoul(str, NULL, 10); break; - case VIK_LAYER_PARAM_INT: rv->data.i = strtol(str, NULL, 10); break; - case VIK_LAYER_PARAM_BOOLEAN: rv->data.b = TEST_BOOLEAN(str); break; - case VIK_LAYER_PARAM_COLOR: memset(&(rv->data.c), 0, sizeof(rv->data.c)); /* default: black */ - gdk_color_parse ( str, &(rv->data.c) ); break; - /* STRING or STRING_LIST -- if STRING_LIST, just set param to add a STRING */ - default: { - gchar *s = g_strdup(str); - rv->data.s = s; - rv->freeme = s; - } + if ( g_hash_table_lookup ( groups_keys_to_indices, key ) ) + g_critical("Duplicate preferences group keys"); + else { + g_ptr_array_add ( groups_names, g_strdup(name) ); + g_hash_table_insert ( groups_keys_to_indices, g_strdup(key), GINT_TO_POINTER ( (gint) groups_names->len ) ); /* index + 1 */ } - return rv; } -/************/ - -/* MAKES A COPY OF THE KEY!!! */ -static gboolean preferences_load_parse_param(gchar *buf, gchar **key, gchar **val ) +/* returns -1 if not found. */ +static gint16 preferences_groups_key_to_index( const gchar *key ) { - gchar *eq_pos; - // comments, special characters in viking file format - if ( buf == NULL || buf[0] == '\0' || buf[0] == '~' || buf[0] == '=' || buf[0] == '#' ) - return FALSE; - eq_pos = strchr ( buf, '=' ); - if ( ! eq_pos ) - return FALSE; - *key = g_strndup ( buf, eq_pos - buf ); - *val = eq_pos + 1; - return TRUE; + gint index = GPOINTER_TO_INT ( g_hash_table_lookup ( groups_keys_to_indices, key ) ); + if ( ! index ) + return VIK_LAYER_GROUP_NONE; /* which should be -1 anyway */ + return (gint16) (index - 1); } +/*****************************/ + static gboolean preferences_load_from_file() { gchar *fn = g_build_filename(a_get_viking_dir(), VIKING_PREFS_FILE, NULL); - FILE *f = fopen(fn, "r"); + FILE *f = g_fopen(fn, "r"); g_free ( fn ); if ( f ) { @@ -128,29 +88,32 @@ static gboolean preferences_load_from_file() gchar *key, *val; VikLayerTypedParamData *oldval, *newval; while ( ! feof (f) ) { - fgets(buf,sizeof(buf),f); - if ( preferences_load_parse_param(buf, &key, &val ) ) { + if (fgets(buf,sizeof(buf),f) == NULL) + break; + if ( split_string_from_file_on_equals ( buf, &key, &val ) ) { // if it's not in there, ignore it oldval = g_hash_table_lookup ( values, key ); if ( ! oldval ) { g_free(key); + g_free(val); continue; } // otherwise change it (you know the type!) // if it's a string list do some funky stuff ... yuck... not yet. if ( oldval->type == VIK_LAYER_PARAM_STRING_LIST ) - g_error ( "Param strings not implemented in preferences"); // fake it - - g_free(key); + g_critical ( "Param strings not implemented in preferences"); // fake it - newval = layer_data_typed_param_copy_from_string ( oldval->type, val ); + newval = vik_layer_data_typed_param_copy_from_string ( oldval->type, val ); g_hash_table_insert ( values, key, newval ); + g_free(key); + g_free(val); // change value } } fclose(f); + f = NULL; return TRUE; } return FALSE; @@ -159,26 +122,40 @@ static gboolean preferences_load_from_file() static void preferences_run_setparam ( gpointer notused, guint16 i, VikLayerParamData data, VikLayerParam *params ) { if ( params[i].type == VIK_LAYER_PARAM_STRING_LIST ) - g_error ( "Param strings not implemented in preferences"); //fake it - g_hash_table_insert ( values, (gchar *)(params[i].name), layer_typed_param_data_copy_from_data(params[i].type, data) ); + g_critical ( "Param strings not implemented in preferences"); //fake it + g_hash_table_insert ( values, (gchar *)(params[i].name), vik_layer_typed_param_data_copy_from_data(params[i].type, data) ); } -static VikLayerParamData preferences_run_getparam ( gpointer notused, guint16 i ) +/* Allow preferences to be manipulated externally */ +void a_preferences_run_setparam ( VikLayerParamData data, VikLayerParam *params ) +{ + preferences_run_setparam (NULL, 0, data, params); +} + +static VikLayerParamData preferences_run_getparam ( gpointer notused, guint16 i, gboolean notused2 ) { VikLayerTypedParamData *val = (VikLayerTypedParamData *) g_hash_table_lookup ( values, ((VikLayerParam *)g_ptr_array_index(params,i))->name ); g_assert ( val != NULL ); if ( val->type == VIK_LAYER_PARAM_STRING_LIST ) - g_error ( "Param strings not implemented in preferences"); //fake it + g_critical ( "Param strings not implemented in preferences"); //fake it return val->data; } -/* TRUE on success */ -static gboolean preferences_save_to_file() +/** + * a_preferences_save_to_file: + * + * Returns: TRUE on success + */ +gboolean a_preferences_save_to_file() { gchar *fn = g_build_filename(a_get_viking_dir(), VIKING_PREFS_FILE, NULL); // TODO: error checking - FILE *f = fopen(fn, "w"); + FILE *f = g_fopen(fn, "w"); + /* Since preferences files saves OSM login credentials, + * it'll be better to store it in secret. + */ + g_chmod(fn, 0600); g_free ( fn ); if ( f ) { @@ -192,6 +169,7 @@ static gboolean preferences_save_to_file() file_write_layer_param ( f, param->name, val->type, val->data ); } fclose(f); + f = NULL; return TRUE; } @@ -208,46 +186,50 @@ void a_preferences_show_window(GtkWindow *parent) { for ( i = 0; i < params->len; i++ ) { contiguous_params[i] = *((VikLayerParam*)(g_ptr_array_index(params,i))); } - + loaded = TRUE; preferences_load_from_file(); - if ( a_uibuilder_properties_factory ( parent, contiguous_params, params_count, - NULL, 0, // groups, groups_count, // groups? what groups?! - (gboolean (*) (gpointer,guint16,VikLayerParamData,gpointer)) preferences_run_setparam, + if ( a_uibuilder_properties_factory ( _("Preferences"), parent, contiguous_params, params_count, + (gchar **) groups_names->pdata, groups_names->len, // groups, groups_count, // groups? what groups?! + (gboolean (*) (gpointer,guint16,VikLayerParamData,gpointer,gboolean)) preferences_run_setparam, NULL /* not used */, contiguous_params, - preferences_run_getparam, NULL /* not used */ ) ) { - preferences_save_to_file(); + preferences_run_getparam, NULL, NULL /* not used */ ) ) { + a_preferences_save_to_file(); } g_free ( contiguous_params ); } -void a_preferences_register(VikLayerParam *pref, VikLayerParamData defaultval) +void a_preferences_register(VikLayerParam *pref, VikLayerParamData defaultval, const gchar *group_key ) { /* copy value */ - VikLayerTypedParamData *newval = layer_typed_param_data_copy_from_data(pref->type, defaultval); + VikLayerParam *newpref = g_new(VikLayerParam,1); + *newpref = *pref; + VikLayerTypedParamData *newval = vik_layer_typed_param_data_copy_from_data(pref->type, defaultval); + if ( group_key ) + newpref->group = preferences_groups_key_to_index ( group_key ); - g_ptr_array_add ( params, pref ); + g_ptr_array_add ( params, newpref ); g_hash_table_insert ( values, (gchar *)pref->name, newval ); } void a_preferences_init() { + preferences_groups_init(); + /* not copied */ params = g_ptr_array_new (); /* key not copied (same ptr as in pref), actual param data yes */ - values = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, layer_typed_param_data_free); - - VikLayerParamData tmp; - tmp.s = "hello world"; - a_preferences_register(prefs, tmp); - a_preferences_register(prefs+1, tmp); + values = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, vik_layer_typed_param_data_free); - /* load from file? */ + loaded = FALSE; } void a_preferences_uninit() { - g_ptr_array_free ( params, FALSE ); + preferences_groups_uninit(); + + g_ptr_array_foreach ( params, (GFunc)g_free, NULL ); + g_ptr_array_free ( params, TRUE ); g_hash_table_destroy ( values ); } @@ -255,5 +237,11 @@ void a_preferences_uninit() VikLayerParamData *a_preferences_get(const gchar *key) { + if ( ! loaded ) { + /* since we can't load the file in a_preferences_init (no params registered yet), + * do it once before we get the first key. */ + preferences_load_from_file(); + loaded = TRUE; + } return g_hash_table_lookup ( values, key ); }