[andy/viking.git] / src / preferences.c

/*
 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
 *
 * Copyright (C) 2003-2007, Evan Battaglia <gtoevan@gmx.net>
 *
 * 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 <gtk/gtk.h>
#include <glib/gi18n.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <glib/gstdio.h>
#include "preferences.h"
#include "dir.h"
#include "file.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') )

static GPtrArray *params;
static GHashTable *values;
gboolean loaded;

/************ groups *********/

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.

static void preferences_groups_init()
{
  groups_names = g_ptr_array_new();
  groups_keys_to_indices = g_hash_table_new_full ( g_str_hash, g_str_equal, g_free, NULL );
}

static void preferences_groups_uninit()
{
  g_ptr_array_free ( groups_names, TRUE );
  g_hash_table_destroy ( groups_keys_to_indices );
}

void a_preferences_register_group ( const gchar *key, const gchar *name )
{
  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 */
  }
}

/* returns -1 if not found. */
static gint16 preferences_groups_key_to_index( const gchar *key )
{
  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);
}

/*****************************/

/************/

typedef struct {
  VikLayerParamData data;
  guint8 type;
} VikLayerTypedParamData;

static void layer_typed_param_data_free(gpointer p)
{
  VikLayerTypedParamData *val = (VikLayerTypedParamData *)p;
  switch ( val->type ) {
    case VIK_LAYER_PARAM_STRING:
      if ( val->data.s )
        g_free ( (gpointer)val->data.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_critical ( "Param strings not implemented in preferences"); //fake it
      break;
  }
  g_free ( val );
}

static 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;
      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_critical ( "Param strings not implemented in preferences"); //fake it
      break;
  }
  return newval;
}

/* TODO: share this code with file.c */
static VikLayerTypedParamData *layer_data_typed_param_copy_from_string ( guint8 type, const gchar *str )
{
  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;
    }
  }
  return rv;
}

/************/

/* MAKES A COPY OF THE KEY!!! */
static gboolean preferences_load_parse_param(gchar *buf, gchar **key, gchar **val )
{
  gchar *eq_pos;
  gint len;

  // 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;
  len = strlen(*val);
  if ( len > 0 )
    if ( (*val)[len - 1] == '\n' )
      (*val) [ len - 1 ] = '\0'; /* cut off newline */
  return TRUE;
}

static gboolean preferences_load_from_file()
{
  gchar *fn = g_build_filename(a_get_viking_dir(), VIKING_PREFS_FILE, NULL);
  FILE *f = g_fopen(fn, "r");
  g_free ( fn );

  if ( f ) {
    gchar buf[4096];
    gchar *key, *val;
    VikLayerTypedParamData *oldval, *newval;
    while ( ! feof (f) ) {
      if (fgets(buf,sizeof(buf),f) == NULL)
        break;
      if ( preferences_load_parse_param(buf, &key, &val ) ) {
        // if it's not in there, ignore it
        oldval = g_hash_table_lookup ( values, key );
        if ( ! oldval ) {
          g_free(key);
          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_critical ( "Param strings not implemented in preferences"); // fake it

        newval = layer_data_typed_param_copy_from_string ( oldval->type, val );
        g_hash_table_insert ( values, key, newval );

        g_free(key);

        // change value
      }
    }
    fclose(f);
    f = NULL;
    return TRUE;
  }
  return FALSE;
}

static void preferences_run_setparam ( gpointer notused, guint16 i, VikLayerParamData data, VikLayerParam *params )
{
  if ( params[i].type == VIK_LAYER_PARAM_STRING_LIST )
    g_critical ( "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) );
}

/* 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_critical ( "Param strings not implemented in preferences"); //fake it
  return val->data;
}

/* 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 = 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 ) {
    VikLayerParam *param;
    VikLayerTypedParamData *val;
    int i;
    for ( i = 0; i < params->len; i++ ) {
      param = (VikLayerParam *) g_ptr_array_index(params,i);
      val = (VikLayerTypedParamData *) g_hash_table_lookup ( values, param->name );
      g_assert ( val != NULL );
      file_write_layer_param ( f, param->name, val->type, val->data );
    }
    fclose(f);
    f = NULL;
    return TRUE;
  }

  return FALSE;
}


void a_preferences_show_window(GtkWindow *parent) {
    //VikLayerParamData *a_uibuilder_run_dialog ( GtkWindow *parent, VikLayerParam \*params, // guint16 params_count, gchar **groups, guint8 groups_count, // VikLayerParamData *params_defaults )
    // TODO: THIS IS A MAJOR HACKAROUND, but ok when we have only a couple preferences.
    gint params_count = params->len;
    VikLayerParam *contiguous_params = g_new(VikLayerParam,params_count);
    int i;
    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 ( _("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 */ ) ) {
      a_preferences_save_to_file();
    }
    g_free ( contiguous_params );
}

void a_preferences_register(VikLayerParam *pref, VikLayerParamData defaultval, const gchar *group_key )
{
  /* copy value */
  VikLayerParam *newpref = g_new(VikLayerParam,1);
  *newpref = *pref;
  VikLayerTypedParamData *newval = 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, 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);

  loaded = FALSE;
}

void a_preferences_uninit()
{
  preferences_groups_uninit();

  g_ptr_array_free ( params, TRUE );
  g_hash_table_destroy ( values );
}


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