src/preferences.c

   1 #include <gtk/gtk.h>
   2 #include <glib/gi18n.h>
   3 #include <string.h>
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <glib/gstdio.h>
   7 #include "preferences.h"
   8 #include "file.h"
   9
  10 // TODO: register_group
  11 // TODO: STRING_LIST
  12 // TODO: share code in file reading
  13 // TODO: remove hackaround in show_window
  14 // TODO: move typeddata to uibuilder, make it more used & general, it's a "prettier" solution methinks
  15 // maybe this wasn't such a good idea...
  16
  17 #define VIKING_PREFS_FILE "viking.prefs"
  18
  19 #define TEST_BOOLEAN(str) (! ((str)[0] == '\0' || (str)[0] == '0' || (str)[0] == 'n' || (str)[0] == 'N' || (str)[0] == 'f' || (str)[0] == 'F') )
  20
  21 static GPtrArray *params;
  22 static GHashTable *values;
  23 gboolean loaded;
  24
  25 /************ groups *********/
  26
  27 static GPtrArray *groups_names;
  28 static GHashTable *groups_keys_to_indices; // contains gint, NULL (0) is not found, instead 1 is used for 0, 2 for 1, etc.
  29
  30 static void preferences_groups_init()
  31 {
  32   groups_names = g_ptr_array_new();
  33   groups_keys_to_indices = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL );
  34 }
  35
  36 static void preferences_groups_uninit()
  37 {
  38   g_ptr_array_free ( groups_names, TRUE );
  39   g_hash_table_destroy ( groups_keys_to_indices );
  40 }
  41
  42 void a_preferences_register_group ( const gchar *key, const gchar *name )
  43 {
  44   if ( g_hash_table_lookup ( groups_keys_to_indices, key ) )
  45     g_error("Duplicate preferences group keys");
  46   else {
  47     g_ptr_array_add ( groups_names, g_strdup(name) );
  48     g_hash_table_insert ( groups_keys_to_indices, g_strdup(key), GINT_TO_POINTER ( (gint) groups_names->len ) ); /* index + 1 */
  49   }
  50 }
  51
  52 /* returns -1 if not found. */
  53 static gint16 preferences_groups_key_to_index( const gchar *key )
  54 {
  55   gint index = GPOINTER_TO_INT ( g_hash_table_lookup ( groups_keys_to_indices, key ) );
  56   if ( ! index )
  57     return VIK_LAYER_GROUP_NONE; /* which should be -1 anyway */
  58   return (gint16) (index - 1);
  59 }
  60
  61 /*****************************/
  62
  63 /************/
  64
  65 typedef struct {
  66   VikLayerParamData data;
  67   guint8 type;
  68   gpointer freeme; // because data.s is const and the compiler complains
  69 } VikLayerTypedParamData;
  70
  71 void layer_typed_param_data_free(gpointer p)
  72 {
  73   VikLayerTypedParamData *val = (VikLayerTypedParamData *)p;
  74   switch ( val->type ) {
  75     case VIK_LAYER_PARAM_STRING:
  76       if ( val->freeme )
  77         g_free ( val->freeme );
  78       break;
  79     /* TODO: APPLICABLE TO US? NOTE: string layer works auniquely: data.sl should NOT be free'd when
  80      * the internals call get_param -- i.e. it should be managed w/in the layer.
  81      * The value passed by the internals into set_param should also be managed
  82      * by the layer -- i.e. free'd by the layer.
  83      */
  84     case VIK_LAYER_PARAM_STRING_LIST:
  85       g_error ( "Param strings not implemented in preferences"); //fake it
  86       break;
  87   }
  88   g_free ( val );
  89 }
  90
  91 VikLayerTypedParamData *layer_typed_param_data_copy_from_data(guint8 type, VikLayerParamData val) {
  92   VikLayerTypedParamData *newval = g_new(VikLayerTypedParamData,1);
  93   newval->data = val;
  94   newval->type = type;
  95   switch ( newval->type ) {
  96     case VIK_LAYER_PARAM_STRING: {
  97       gchar *s = g_strdup(newval->data.s);
  98       newval->data.s = s;
  99       newval->freeme = s;
 100       break;
 101     }
 102     /* TODO: APPLICABLE TO US? NOTE: string layer works auniquely: data.sl should NOT be free'd when
 103      * the internals call get_param -- i.e. it should be managed w/in the layer.
 104      * The value passed by the internals into set_param should also be managed
 105      * by the layer -- i.e. free'd by the layer.
 106      */
 107     case VIK_LAYER_PARAM_STRING_LIST:
 108       g_error ( "Param strings not implemented in preferences"); //fake it
 109       break;
 110   }
 111   return newval;
 112 }
 113
 114 /* TODO: share this code with file.c */
 115 VikLayerTypedParamData *layer_data_typed_param_copy_from_string ( guint8 type, const gchar *str )
 116 {
 117   g_assert ( type != VIK_LAYER_PARAM_STRING_LIST );
 118   VikLayerTypedParamData *rv = g_new(VikLayerTypedParamData,1);
 119   rv->type = type;
 120   switch ( type )
 121   {
 122     case VIK_LAYER_PARAM_DOUBLE: rv->data.d = strtod(str, NULL); break;
 123     case VIK_LAYER_PARAM_UINT: rv->data.u = strtoul(str, NULL, 10); break;
 124     case VIK_LAYER_PARAM_INT: rv->data.i = strtol(str, NULL, 10); break;
 125     case VIK_LAYER_PARAM_BOOLEAN: rv->data.b = TEST_BOOLEAN(str); break;
 126     case VIK_LAYER_PARAM_COLOR: memset(&(rv->data.c), 0, sizeof(rv->data.c)); /* default: black */
 127       gdk_color_parse ( str, &(rv->data.c) ); break;
 128     /* STRING or STRING_LIST -- if STRING_LIST, just set param to add a STRING */
 129     default: {
 130       gchar *s = g_strdup(str);
 131       rv->data.s = s;
 132       rv->freeme = s;
 133     }
 134   }
 135   return rv;
 136 }
 137
 138 /************/
 139
 140 /* MAKES A COPY OF THE KEY!!! */
 141 static gboolean preferences_load_parse_param(gchar *buf, gchar **key, gchar **val )
 142 {
 143   gchar *eq_pos;
 144   gint len;
 145
 146   // comments, special characters in viking file format
 147   if ( buf == NULL || buf[0] == '\0' || buf[0] == '~' || buf[0] == '=' || buf[0] == '#' )
 148     return FALSE;
 149   eq_pos = strchr ( buf, '=' );
 150   if ( ! eq_pos )
 151     return FALSE;
 152   *key = g_strndup ( buf, eq_pos - buf );
 153   *val = eq_pos + 1;
 154   len = strlen(*val);
 155   if ( len > 0 )
 156     if ( (*val)[len - 1] == '\n' )
 157       (*val) [ len - 1 ] = '\0'; /* cut off newline */
 158   return TRUE;
 159 }
 160
 161 static gboolean preferences_load_from_file()
 162 {
 163   gchar *fn = g_build_filename(a_get_viking_dir(), VIKING_PREFS_FILE, NULL);
 164   FILE *f = g_fopen(fn, "r");
 165   g_free ( fn );
 166
 167   if ( f ) {
 168     gchar buf[4096];
 169     gchar *key, *val;
 170     VikLayerTypedParamData *oldval, *newval;
 171     while ( ! feof (f) ) {
 172       fgets(buf,sizeof(buf),f);
 173       if ( preferences_load_parse_param(buf, &key, &val ) ) {
 174         // if it's not in there, ignore it
 175         oldval = g_hash_table_lookup ( values, key );
 176         if ( ! oldval ) {
 177           g_free(key);
 178           continue;
 179         }
 180
 181         // otherwise change it (you know the type!)
 182         // if it's a string list do some funky stuff ... yuck... not yet.
 183         if ( oldval->type == VIK_LAYER_PARAM_STRING_LIST )
 184           g_error ( "Param strings not implemented in preferences"); // fake it
 185
 186         newval = layer_data_typed_param_copy_from_string ( oldval->type, val );
 187         g_hash_table_insert ( values, key, newval );
 188
 189         g_free(key);
 190
 191         // change value
 192       }
 193     }
 194     fclose(f);
 195     f = NULL;
 196     return TRUE;
 197   }
 198   return FALSE;
 199 }
 200
 201 static void preferences_run_setparam ( gpointer notused, guint16 i, VikLayerParamData data, VikLayerParam *params )
 202 {
 203   if ( params[i].type == VIK_LAYER_PARAM_STRING_LIST )
 204     g_error ( "Param strings not implemented in preferences"); //fake it
 205   g_hash_table_insert ( values, (gchar *)(params[i].name), layer_typed_param_data_copy_from_data(params[i].type, data) );
 206 }
 207
 208 static VikLayerParamData preferences_run_getparam ( gpointer notused, guint16 i )
 209 {
 210   VikLayerTypedParamData *val = (VikLayerTypedParamData *) g_hash_table_lookup ( values, ((VikLayerParam *)g_ptr_array_index(params,i))->name );
 211   g_assert ( val != NULL );
 212   if ( val->type == VIK_LAYER_PARAM_STRING_LIST )
 213     g_error ( "Param strings not implemented in preferences"); //fake it
 214   return val->data;
 215 }
 216
 217 /* TRUE on success */
 218 static gboolean preferences_save_to_file()
 219 {
 220   gchar *fn = g_build_filename(a_get_viking_dir(), VIKING_PREFS_FILE, NULL);
 221
 222   // TODO: error checking
 223   FILE *f = g_fopen(fn, "w");
 224   g_free ( fn );
 225
 226   if ( f ) {
 227     VikLayerParam *param;
 228     VikLayerTypedParamData *val;
 229     int i;
 230     for ( i = 0; i < params->len; i++ ) {
 231       param = (VikLayerParam *) g_ptr_array_index(params,i);
 232       val = (VikLayerTypedParamData *) g_hash_table_lookup ( values, param->name );
 233       g_assert ( val != NULL );
 234       file_write_layer_param ( f, param->name, val->type, val->data );
 235     }
 236     fclose(f);
 237     f = NULL;
 238     return TRUE;
 239   }
 240
 241   return FALSE;
 242 }
 243
 244
 245 void a_preferences_show_window(GtkWindow *parent) {
 246     //VikLayerParamData *a_uibuilder_run_dialog ( GtkWindow *parent, VikLayerParam \*params, // guint16 params_count, gchar **groups, guint8 groups_count, // VikLayerParamData *params_defaults )
 247     // TODO: THIS IS A MAJOR HACKAROUND, but ok when we have only a couple preferences.
 248     gint params_count = params->len;
 249     VikLayerParam *contiguous_params = g_new(VikLayerParam,params_count);
 250     int i;
 251     for ( i = 0; i < params->len; i++ ) {
 252       contiguous_params[i] = *((VikLayerParam*)(g_ptr_array_index(params,i)));
 253     }
 254     loaded = TRUE;
 255     preferences_load_from_file();
 256     if ( a_uibuilder_properties_factory ( parent, contiguous_params, params_count,
 257                                 (gchar **) groups_names->pdata, groups_names->len, // groups, groups_count, // groups? what groups?!
 258                                 (gboolean (*) (gpointer,guint16,VikLayerParamData,gpointer)) preferences_run_setparam,
 259                                 NULL /* not used */, contiguous_params,
 260                                 preferences_run_getparam, NULL /* not used */ ) ) {
 261       preferences_save_to_file();
 262     }
 263     g_free ( contiguous_params );
 264 }
 265
 266 void a_preferences_register(VikLayerParam *pref, VikLayerParamData defaultval, const gchar *group_key )
 267 {
 268   /* copy value */
 269   VikLayerParam *newpref = g_new(VikLayerParam,1);
 270   *newpref = *pref;
 271   VikLayerTypedParamData *newval = layer_typed_param_data_copy_from_data(pref->type, defaultval);
 272   if ( group_key )
 273     newpref->group = preferences_groups_key_to_index ( group_key );
 274
 275   g_ptr_array_add ( params, newpref );
 276   g_hash_table_insert ( values, (gchar *)pref->name, newval );
 277 }
 278
 279 void a_preferences_init()
 280 {
 281   preferences_groups_init();
 282
 283   /* not copied */
 284   params = g_ptr_array_new ();
 285
 286   /* key not copied (same ptr as in pref), actual param data yes */
 287   values = g_hash_table_new_full ( g_str_hash, g_str_equal, NULL, layer_typed_param_data_free);
 288
 289   loaded = FALSE;
 290 }
 291
 292 void a_preferences_uninit()
 293 {
 294   preferences_groups_uninit();
 295
 296   g_ptr_array_free ( params, TRUE );
 297   g_hash_table_destroy ( values );
 298 }
 299
 300
 301
 302 VikLayerParamData *a_preferences_get(const gchar *key)
 303 {
 304   if ( ! loaded ) {
 305     /* since we can't load the file in a_preferences_init (no params registered yet),
 306      * do it once before we get the first key. */
 307     preferences_load_from_file();
 308     loaded = TRUE;
 309   }
 310   return g_hash_table_lookup ( values, key );
 311 }