src/preferences.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2007, Evan Battaglia <gtoevan@gmx.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21 #include <gtk/gtk.h>
  22 #include <glib/gi18n.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include <glib/gstdio.h>
  26 #include "preferences.h"
  27 #include "dir.h"
  28 #include "file.h"
  29 #include "util.h"
  30
  31 // TODO: STRING_LIST
  32 // TODO: share code in file reading
  33 // TODO: remove hackaround in show_window
  34
  35 #define VIKING_PREFS_FILE "viking.prefs"
  36
  37 static GPtrArray *params;
  38 static GHashTable *values;
  39 gboolean loaded;
  40
  41 /************ groups *********/
  42
  43 static GPtrArray *groups_names;
  44 static GHashTable *groups_keys_to_indices; // contains gint, NULL (0) is not found, instead 1 is used for 0, 2 for 1, etc.
  45
  46 static void preferences_groups_init()
  47 {
  48   groups_names = g_ptr_array_new();
  49   groups_keys_to_indices = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL );
  50 }
  51
  52 static void preferences_groups_uninit()
  53 {
  54   g_ptr_array_foreach ( groups_names, (GFunc)g_free, NULL );
  55   g_ptr_array_free ( groups_names, TRUE );
  56   g_hash_table_destroy ( groups_keys_to_indices );
  57 }
  58
  59 void a_preferences_register_group ( const gchar *key, const gchar *name )
  60 {
  61   if ( g_hash_table_lookup ( groups_keys_to_indices, key ) )
  62     g_critical("Duplicate preferences group keys");
  63   else {
  64     g_ptr_array_add ( groups_names, g_strdup(name) );
  65     g_hash_table_insert ( groups_keys_to_indices, g_strdup(key), GINT_TO_POINTER ( (gint) groups_names->len ) ); /* index + 1 */
  66   }
  67 }
  68
  69 /* returns -1 if not found. */
  70 static gint16 preferences_groups_key_to_index( const gchar *key )
  71 {
  72   gint index = GPOINTER_TO_INT ( g_hash_table_lookup ( groups_keys_to_indices, key ) );
  73   if ( ! index )
  74     return VIK_LAYER_GROUP_NONE; /* which should be -1 anyway */
  75   return (gint16) (index - 1);
  76 }
  77
  78 /*****************************/
  79
  80 static gboolean preferences_load_from_file()
  81 {
  82   gchar *fn = g_build_filename(a_get_viking_dir(), VIKING_PREFS_FILE, NULL);
  83   FILE *f = g_fopen(fn, "r");
  84   g_free ( fn );
  85
  86   if ( f ) {
  87     gchar buf[4096];
  88     gchar *key = NULL;
  89     gchar *val = NULL;
  90     VikLayerTypedParamData *oldval, *newval;
  91     while ( ! feof (f) ) {
  92       if (fgets(buf,sizeof(buf),f) == NULL)
  93         break;
  94       if ( split_string_from_file_on_equals ( buf, &key, &val ) ) {
  95         // if it's not in there, ignore it
  96         oldval = g_hash_table_lookup ( values, key );
  97         if ( ! oldval ) {
  98           g_free(key);
  99           g_free(val);
 100           continue;
 101         }
 102
 103         // otherwise change it (you know the type!)
 104         // if it's a string list do some funky stuff ... yuck... not yet.
 105         if ( oldval->type == VIK_LAYER_PARAM_STRING_LIST )
 106           g_critical ( "Param strings not implemented in preferences"); // fake it
 107
 108         newval = vik_layer_data_typed_param_copy_from_string ( oldval->type, val );
 109         g_hash_table_insert ( values, key, newval );
 110
 111         g_free(key);
 112         g_free(val);
 113         // change value
 114       }
 115     }
 116     fclose(f);
 117     f = NULL;
 118     return TRUE;
 119   }
 120   return FALSE;
 121 }
 122
 123 static void preferences_run_setparam ( gpointer notused, guint16 i, VikLayerParamData data, VikLayerParam *vlparams )
 124 {
 125   // Don't change stored pointer values
 126   if ( vlparams[i].type == VIK_LAYER_PARAM_PTR )
 127     return;
 128   if ( vlparams[i].type == VIK_LAYER_PARAM_STRING_LIST )
 129     g_critical ( "Param strings not implemented in preferences"); //fake it
 130   g_hash_table_insert ( values, (gchar *)(vlparams[i].name), vik_layer_typed_param_data_copy_from_data(vlparams[i].type, data) );
 131 }
 132
 133 /* Allow preferences to be manipulated externally */
 134 void a_preferences_run_setparam ( VikLayerParamData data, VikLayerParam *vlparams )
 135 {
 136   preferences_run_setparam (NULL, 0, data, vlparams);
 137 }
 138
 139 static VikLayerParamData preferences_run_getparam ( gpointer notused, guint16 i, gboolean notused2 )
 140 {
 141   VikLayerTypedParamData *val = (VikLayerTypedParamData *) g_hash_table_lookup ( values, ((VikLayerParam *)g_ptr_array_index(params,i))->name );
 142   g_assert ( val != NULL );
 143   if ( val->type == VIK_LAYER_PARAM_STRING_LIST )
 144     g_critical ( "Param strings not implemented in preferences"); //fake it
 145   return val->data;
 146 }
 147
 148 /**
 149  * a_preferences_save_to_file:
 150  *
 151  * Returns: TRUE on success
 152  */
 153 gboolean a_preferences_save_to_file()
 154 {
 155   gchar *fn = g_build_filename(a_get_viking_dir(), VIKING_PREFS_FILE, NULL);
 156
 157   // TODO: error checking
 158   FILE *f = g_fopen(fn, "w");
 159   /* Since preferences files saves OSM login credentials,
 160    * it'll be better to store it in secret.
 161    */
 162   g_chmod(fn, 0600);
 163   g_free ( fn );
 164
 165   if ( f ) {
 166     VikLayerParam *param;
 167     VikLayerTypedParamData *val;
 168     int i;
 169     for ( i = 0; i < params->len; i++ ) {
 170       param = (VikLayerParam *) g_ptr_array_index(params,i);
 171       val = (VikLayerTypedParamData *) g_hash_table_lookup ( values, param->name );
 172       if ( val )
 173         if ( val->type != VIK_LAYER_PARAM_PTR )
 174           file_write_layer_param ( f, param->name, val->type, val->data );
 175     }
 176     fclose(f);
 177     f = NULL;
 178     return TRUE;
 179   }
 180
 181   return FALSE;
 182 }
 183
 184
 185 void a_preferences_show_window(GtkWindow *parent) {
 186     //VikLayerParamData *a_uibuilder_run_dialog ( GtkWindow *parent, VikLayerParam \*params, // guint16 params_count, gchar **groups, guint8 groups_count, // VikLayerParamData *params_defaults )
 187     // TODO: THIS IS A MAJOR HACKAROUND, but ok when we have only a couple preferences.
 188     gint params_count = params->len;
 189     VikLayerParam *contiguous_params = g_new(VikLayerParam,params_count);
 190     int i;
 191     for ( i = 0; i < params->len; i++ ) {
 192       contiguous_params[i] = *((VikLayerParam*)(g_ptr_array_index(params,i)));
 193     }
 194     loaded = TRUE;
 195     preferences_load_from_file();
 196     if ( a_uibuilder_properties_factory ( _("Preferences"), parent, contiguous_params, params_count,
 197                                 (gchar **) groups_names->pdata, groups_names->len, // groups, groups_count, // groups? what groups?!
 198                                 (gboolean (*) (gpointer,guint16,VikLayerParamData,gpointer,gboolean)) preferences_run_setparam,
 199                                 NULL /* not used */, contiguous_params,
 200                                 preferences_run_getparam, NULL, NULL /* not used */ ) ) {
 201       a_preferences_save_to_file();
 202     }
 203     g_free ( contiguous_params );
 204 }
 205
 206 void a_preferences_register(VikLayerParam *pref, VikLayerParamData defaultval, const gchar *group_key )
 207 {
 208   // All preferences should be registered before loading
 209   if ( loaded )
 210     g_critical ( "REGISTERING preference %s after LOADING from " VIKING_PREFS_FILE, pref->name );
 211   /* copy value */
 212   VikLayerParam *newpref = g_new(VikLayerParam,1);
 213   *newpref = *pref;
 214   VikLayerTypedParamData *newval = vik_layer_typed_param_data_copy_from_data(pref->type, defaultval);
 215   if ( group_key )
 216     newpref->group = preferences_groups_key_to_index ( group_key );
 217
 218   g_ptr_array_add ( params, newpref );
 219   g_hash_table_insert ( values, (gchar *)pref->name, newval );
 220 }
 221
 222 void a_preferences_init()
 223 {
 224   preferences_groups_init();
 225
 226   /* not copied */
 227   params = g_ptr_array_new ();
 228
 229   /* key not copied (same ptr as in pref), actual param data yes */
 230   values = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, vik_layer_typed_param_data_free);
 231
 232   loaded = FALSE;
 233 }
 234
 235 void a_preferences_uninit()
 236 {
 237   preferences_groups_uninit();
 238
 239   g_ptr_array_foreach ( params, (GFunc)g_free, NULL );
 240   g_ptr_array_free ( params, TRUE );
 241   g_hash_table_destroy ( values );
 242 }
 243
 244
 245
 246 VikLayerParamData *a_preferences_get(const gchar *key)
 247 {
 248   if ( ! loaded ) {
 249     g_debug ( "%s: First time: %s\n", __FUNCTION__, key );
 250     /* since we can't load the file in a_preferences_init (no params registered yet),
 251      * do it once before we get the first key. */
 252     preferences_load_from_file();
 253     loaded = TRUE;
 254   }
 255   return g_hash_table_lookup ( values, key );
 256 }