trunk/src/gconf.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of GPXView.
 *
 * GPXView 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 3 of the License, or
 * (at your option) any later version.
 *
 * GPXView 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 GPXView.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stddef.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>     // for isnan
#include "gpxview.h"

#define GCONF_PATH         "/apps/gpxview/"
#define GCONF_KEY_GPX      GCONF_PATH "gpx%d"
#define GCONF_KEY_CNT      GCONF_PATH "entries"

#define GCONF_KEY_LOC_NAME GCONF_PATH "location%d/name"
#define GCONF_KEY_LOC_LAT  GCONF_PATH "location%d/latitude"
#define GCONF_KEY_LOC_LON  GCONF_PATH "location%d/longitude"
#define GCONF_KEY_LOC_CNT  GCONF_PATH "location_entries"

#define GCONF_KEY_CLOSED   GCONF_PATH "closed/%s"

#include <string.h>

enum {
  STORE_STRING, STORE_FLOAT, STORE_INT, STORE_BOOL,
};

typedef struct {
  char *key;
  int type;
  int offset;
} store_t;

#define OFFSET(a) offsetof(appdata_t, a)

static store_t store[] = {
  { "image_path",       STORE_STRING, OFFSET(image_path) },
  { "path",             STORE_STRING, OFFSET(path) },
  { "geotext/text",     STORE_STRING, OFFSET(geotext_text) },
  { "geotext/shift",    STORE_INT,    OFFSET(geotext_shift) },
  { "mmpoi_path",       STORE_STRING, OFFSET(mmpoi_path) },
  { "garmin_path",      STORE_STRING, OFFSET(garmin_path) },
  { "fnotes_path",      STORE_STRING, OFFSET(fieldnotes_path) },
  { "garmin_ign_found", STORE_BOOL,   OFFSET(garmin_ign_found) },
  { "active_location",  STORE_INT,    OFFSET(active_location) },
  { "mmpoi_use_radius", STORE_BOOL,   OFFSET(mmpoi_use_radius) },
  { "mmpoi_radius",     STORE_FLOAT,  OFFSET(mmpoi_radius) },
  { "mmpoi_ign_found",  STORE_BOOL,   OFFSET(mmpoi_dont_export_found) },
  { "mmpoi_ign_disabl", STORE_BOOL,   OFFSET(mmpoi_dont_export_disabled) },
  { "use_gps",          STORE_BOOL,   OFFSET(use_gps) },
  { "imperial",         STORE_BOOL,   OFFSET(imperial) },
  { "compass_locked",   STORE_BOOL,   OFFSET(compass_locked) },
  { "latitude",         STORE_FLOAT,  OFFSET(home.lat) },
  { "longitude",        STORE_FLOAT,  OFFSET(home.lon) },
  { "gps_lat",          STORE_FLOAT,  OFFSET(gps.saved.lat) },
  { "gps_lon",          STORE_FLOAT,  OFFSET(gps.saved.lon) },
  { "search_in",        STORE_INT,    OFFSET(search) },
  { "search_days",      STORE_INT,    OFFSET(search_days) },
  { "search_str",       STORE_STRING, OFFSET(search_str) },
  { "gpxlist_items",    STORE_INT,    OFFSET(gpxlist_items) },
  { "cachelist_items",  STORE_INT,    OFFSET(cachelist_items) },
  { "compass_damping",  STORE_INT,    OFFSET(compass_damping) },
  { "cachelist_hide_found", STORE_BOOL, OFFSET(cachelist_hide_found) },
  { "cachelist_update", STORE_BOOL,   OFFSET(cachelist_update) },
  { "disable_gcvote",   STORE_BOOL,   OFFSET(disable_gcvote) },
  { "username",         STORE_STRING, OFFSET(username) },
#ifdef USE_MAEMO
  { "mmpoi_dontlaunch", STORE_BOOL,   OFFSET(mmpoi_dontlaunch) },
  { "cachelist_dss",    STORE_BOOL,   OFFSET(cachelist_disable_screensaver) },
  { "goto_dss",         STORE_BOOL,   OFFSET(goto_disable_screensaver) },
#endif
#ifdef ENABLE_OSM_GPS_MAP
  { "map_lat",          STORE_FLOAT,  OFFSET(map.pos.lat) },
  { "map_lon",          STORE_FLOAT,  OFFSET(map.pos.lon) },
  { "map_zoom",         STORE_INT,    OFFSET(map.zoom) },
  { "map_source",       STORE_INT,    OFFSET(map.source) },
  { "map_dpix",         STORE_BOOL,   OFFSET(map.dpix) },
#endif
#ifdef ESPEAK
  { "espeak/enabled",   STORE_BOOL,   OFFSET(espeak.enabled) },
#endif

  { "geotoad/password", STORE_STRING, OFFSET(gt.password) },
  { "geotoad/filename", STORE_STRING, OFFSET(gt.filename) },
  { "geotoad/distance", STORE_FLOAT,  OFFSET(gt.distance) },
  { "geotoad/lat",      STORE_FLOAT,  OFFSET(gt.lat) },
  { "geotoad/lon",      STORE_FLOAT,  OFFSET(gt.lon) },
  { "geotoad/flags",    STORE_INT,    OFFSET(gt.flags) },
  { "geotoad/no_ownfnd",STORE_BOOL,   OFFSET(gt.no_owned_found) },

  { NULL, -1, -1 }
};

static char *get_basename(char *name) {
  char *p = strrchr(name, '/');
  if(!p) p = name;
  else   p = p+1;

  g_assert(*p);

  /* escape all non alnum characters */
  p = g_strdup(p);
  int i;
  for(i=0;i<strlen(p);i++)
    if(!isalnum(p[i]))
      p[i] = '_';

  return p;
}

void gconf_remove_closed_name(appdata_t *appdata, char *filename) {
  if(!filename || !strlen(filename)) return;

  char *key = g_strdup_printf(GCONF_KEY_CLOSED, get_basename(filename));
  gconf_client_unset(appdata->gconf_client, key, NULL);
  g_free(key);
}

void gconf_save_closed_name(appdata_t *appdata, char *filename, char *name) {
  if(!filename || !strlen(filename)) return;

  char *key = g_strdup_printf(GCONF_KEY_CLOSED, get_basename(filename));
  gconf_client_set_string(appdata->gconf_client, key, name, NULL);
  g_free(key);
}

char *gconf_restore_closed_name(appdata_t *appdata, char *filename) {
  if(!filename || !strlen(filename)) return NULL;

  char *key = g_strdup_printf(GCONF_KEY_CLOSED, get_basename(filename));
  char *ret = gconf_client_get_string(appdata->gconf_client, key, NULL);
  g_free(key);
  return ret;
}

void gconf_save_state(appdata_t *appdata) {
  int entries = 0;

  printf("saving gconf state\n");

  /* free proxy settings */
  if(appdata->proxy) {
    proxy_t *proxy = appdata->proxy;

    if(proxy->authentication_password) g_free(proxy->authentication_password);
    if(proxy->authentication_user)     g_free(proxy->authentication_user);
    if(proxy->host)                    g_free(proxy->host);
    if(proxy->ignore_hosts)            g_free(proxy->ignore_hosts);

    g_free(proxy);
    appdata->proxy = NULL;
  }

  gpx_t *gpx = appdata->gpx;
  while(gpx) {
    char str[128];
    snprintf(str, sizeof(str), GCONF_KEY_GPX, entries++);
    gconf_client_set_string(appdata->gconf_client, str, gpx->filename, NULL);
    gpx = gpx->next;
  }

  gconf_client_set_int(appdata->gconf_client, GCONF_KEY_CNT, entries, NULL);

  /* -------------- save locations (excl. home location) --------------- */
  entries = 0;
  location_t *loc = appdata->location;
  while(loc) {
    char str[128];
    snprintf(str, sizeof(str), GCONF_KEY_LOC_NAME, entries);
    gconf_client_set_string(appdata->gconf_client, str, loc->name, NULL);
    snprintf(str, sizeof(str), GCONF_KEY_LOC_LAT, entries);
    gconf_client_set_float(appdata->gconf_client, str, loc->pos.lat, NULL);
    snprintf(str, sizeof(str), GCONF_KEY_LOC_LON, entries);
    gconf_client_set_float(appdata->gconf_client, str, loc->pos.lon, NULL);
    entries++;
    loc = loc->next;
  }

  gconf_client_set_int(appdata->gconf_client, GCONF_KEY_LOC_CNT, entries, NULL);

  /* store everything listed in the store table */
  store_t *st = store;
  while(st->key) {
    void **ptr = ((void*)appdata) + st->offset;
    char *key = g_strdup_printf(GCONF_PATH "%s", st->key);

    switch(st->type) {
    case STORE_STRING: 
      if((char*)(*ptr)) {
        gconf_client_set_string(appdata->gconf_client, key, (char*)(*ptr), NULL);
      }
      g_free((char*)(*ptr));
      *ptr = NULL;
      break;

    case STORE_BOOL: 
      gconf_client_set_bool(appdata->gconf_client, key, *((int*)ptr), NULL);
      break;

    case STORE_INT: 
      gconf_client_set_int(appdata->gconf_client, key, *((int*)ptr), NULL);
      break;

    case STORE_FLOAT: 
      if(!isnan(*((float*)ptr)))
        gconf_client_set_float(appdata->gconf_client, key, *((float*)ptr), NULL);
      break;

    default:
      printf("Unsupported type %d\n", st->type);
      break;
    }

    g_free(key);
    st++;
  }
}

void gconf_load_state(appdata_t *appdata) {
  gpx_t **gpx = &appdata->gpx;

  while(*gpx) gpx = &((*gpx)->next);

  gpx_dialog_t *dialog = NULL;

  /* default positions are invalid */
  appdata->home.lat = appdata->home.lon = NAN;
  appdata->gps.saved.lat = appdata->gps.saved.lon = NAN;
  appdata->geomath.lat = appdata->geomath.lon = NAN;

  appdata->gt.lat = appdata->gt.lon = NAN;
  appdata->gt.distance = 1.0;  // in km/mil

  /* ------------- get proxy settings -------------------- */
  if(gconf_client_get_bool(appdata->gconf_client, 
                           PROXY_KEY "use_http_proxy", NULL)) {
    proxy_t *proxy = appdata->proxy = g_new0(proxy_t, 1);
    
    /* get basic settings */
    proxy->host = gconf_client_get_string(appdata->gconf_client, 
                                          PROXY_KEY "host", NULL);
    proxy->port = gconf_client_get_int(appdata->gconf_client, 
                                       PROXY_KEY "port", NULL);
    proxy->ignore_hosts =
      gconf_client_get_string(appdata->gconf_client, 
                              PROXY_KEY "ignore_hosts", NULL);
    
    /* check for authentication */
    proxy->use_authentication =
      gconf_client_get_bool(appdata->gconf_client, 
                            PROXY_KEY "use_authentication", NULL);
    
    if(proxy->use_authentication) {
      proxy->authentication_user =
        gconf_client_get_string(appdata->gconf_client, 
                                PROXY_KEY "authentication_user", NULL);
      proxy->authentication_password =
        gconf_client_get_string(appdata->gconf_client, 
                                PROXY_KEY "authentication_password", NULL);
    }
  }

  /* restore everything listed in the store table */
  store_t *st = store;
  while(st->key) {
    void **ptr = ((void*)appdata) + st->offset;
    char *key = g_strdup_printf(GCONF_PATH "%s", st->key);

    /* check if key is present */
    GConfValue *value = gconf_client_get(appdata->gconf_client, key, NULL);
    if(value) {
      gconf_value_free(value); 
      
      switch(st->type) {
      case STORE_STRING: {
        char **str = (char**)ptr;
        *str = gconf_client_get_string(appdata->gconf_client, key, NULL);
      } break;
        
      case STORE_BOOL: 
        *((int*)ptr) = gconf_client_get_bool(appdata->gconf_client, key, NULL);
        break;
        
      case STORE_INT: 
        *((int*)ptr) = gconf_client_get_int(appdata->gconf_client, key, NULL);
        break;
        
      case STORE_FLOAT: 
        *((float*)ptr) = gconf_client_get_float(appdata->gconf_client, key, NULL);
        break;
        
      default:
        printf("Unsupported type %d\n", st->type);
        break;
      }
    }
    g_free(key);
    st++;
  }

  int i, entries = gconf_client_get_int(appdata->gconf_client, 
                                 GCONF_KEY_CNT, NULL);

  if(entries)
    dialog = gpx_busy_dialog_new(GTK_WIDGET(appdata->window));

  for(i=0;i<entries;i++) {
    char str[128];
    snprintf(str, sizeof(str), GCONF_KEY_GPX, i);
    char *fname = gconf_client_get_string(appdata->gconf_client, str, NULL);
    if(fname) {
      /* check if there's a valid name stored for this file. */
      /* if yes it's a "closed" file */
      char *name = gconf_restore_closed_name(appdata, fname);
      if(name) {
        *gpx = g_new0(gpx_t, 1);
        (*gpx)->filename = fname;
        (*gpx)->name = g_strdup(name);
        (*gpx)->closed = TRUE;
      } else {
        if(g_file_test(fname, G_FILE_TEST_IS_DIR)) 
          *gpx = gpx_parse_dir(dialog, fname, appdata->username);
        else
          *gpx = gpx_parse(dialog, fname, appdata->username);

        if(!*gpx) {
          /* restoring the gpx file failed, mark it as unusable, but save */
          /* its presence for later use */
          
          /* create "closed" entry to remember this file for next */
          /* load attempt */
          *gpx = g_new0(gpx_t, 1);
          (*gpx)->filename = fname;
          char *p = fname;
          if(strrchr(fname, '/'))
            p = strrchr(fname, '/')+1;

          (*gpx)->name = g_strdup_printf(_("Failed to load: %s"), p);
          (*gpx)->closed = TRUE;
        } else
          free(fname);
      }
      gpx = &((*gpx)->next);
    }
  }

  gpx_busy_dialog_destroy(dialog);

  /* ------------- load locations --------------------- */
  entries = gconf_client_get_int(appdata->gconf_client, 
                                 GCONF_KEY_LOC_CNT, NULL);

  location_t **loc = &appdata->location;
  for(i=0;i<entries;i++) {
    *loc = g_new0(location_t, 1);
    if(*loc) {
      char str[128];
      snprintf(str, sizeof(str), GCONF_KEY_LOC_NAME, i);
      (*loc)->name = gconf_client_get_string(appdata->gconf_client, str, NULL);
      snprintf(str, sizeof(str), GCONF_KEY_LOC_LAT, i);
      (*loc)->pos.lat  = gconf_client_get_float(appdata->gconf_client, str, NULL);
      snprintf(str, sizeof(str), GCONF_KEY_LOC_LON, i);
      (*loc)->pos.lon  = gconf_client_get_float(appdata->gconf_client, str, NULL);
      
      loc = &((*loc)->next);
    }
  }

  /* ----- set all kinds of defaults ------- */

  if(!appdata->compass_damping) appdata->compass_damping = 1;
  
  if(!appdata->mmpoi_radius) 
    appdata->mmpoi_radius = 100.0;  // 100 km

  if(!appdata->search)
    appdata->search = SEARCH_NAME | SEARCH_ID;

  if(!appdata->image_path) {
#ifdef USE_MAEMO
    /* update cachelist by default */
    appdata->cachelist_update = TRUE;
#endif

    /* use gps by default */
    appdata->use_gps = TRUE;

#ifndef USE_MAEMO
    char *p = getenv("HOME");
    if(p) {
      /* build image path in home directory */
      appdata->image_path =
        malloc(strlen(p)+strlen(DEFAULT_IMAGE_PATH_HOME)+2);
      strcpy(appdata->image_path, p);
      if(appdata->image_path[strlen(appdata->image_path)-1] != '/')
        strcat(appdata->image_path, "/");
      strcat(appdata->image_path, DEFAULT_IMAGE_PATH_HOME);
    } else
#endif
    appdata->image_path = strdup(DEFAULT_IMAGE_PATH);

    /* check if this path is actually accessible */
    /* and change it to the current users home if not */
    /* (this should only happen on scratchbox) */
    if(!g_file_test(appdata->image_path, G_FILE_TEST_IS_DIR)) {
      if(g_mkdir_with_parents(appdata->image_path, 0700) != 0) {
        char *p = getenv("HOME");
        if(!p) p = "/tmp/";

        appdata->image_path = 
          g_strdup_printf("%s%s%s", p, 
                          (p[strlen(p)-1]!='/')?"/":"",
                          DEFAULT_IMAGE_PATH_HOME);
        printf("using alt path %s\n", appdata->image_path);
      }
    }

  } else {
    /* some versions old versions messed up the path */
    if(appdata->image_path[strlen(appdata->image_path)-1] != '/') {
      printf("adjusting image path\n");
      appdata->image_path = realloc(appdata->image_path, 
                                    strlen(appdata->image_path)+2);
      strcat(appdata->image_path, "/");
    }
  }

  if(!appdata->mmpoi_path) {
    char *p = getenv("HOME");
    if(p) {
      /* build mmpoi path in home directory */
      appdata->mmpoi_path = 
        malloc(strlen(p)+strlen(DEFAULT_MMPOI_PATH)+2);
      strcpy(appdata->mmpoi_path, p);
      if(appdata->mmpoi_path[strlen(appdata->mmpoi_path)-1] != '/')
        strcat(appdata->mmpoi_path, "/");
      strcat(appdata->mmpoi_path, DEFAULT_MMPOI_PATH);
    } else
      appdata->mmpoi_path = strdup(DEFAULT_MMPOI_PATH);
  }

  if(!appdata->fieldnotes_path) {
    char *p = getenv("HOME");
    if(p) {
      /* build fieldnotes path in home directory */
      appdata->fieldnotes_path = 
        malloc(strlen(p)+strlen(DEFAULT_FIELDNOTES_PATH)+2);
      strcpy(appdata->fieldnotes_path, p);
      if(appdata->fieldnotes_path[strlen(appdata->fieldnotes_path)-1] != '/')
        strcat(appdata->fieldnotes_path, "/");
      strcat(appdata->fieldnotes_path, DEFAULT_FIELDNOTES_PATH);
    } else
      appdata->fieldnotes_path = strdup(DEFAULT_FIELDNOTES_PATH);
  }

  if(!appdata->garmin_path) {
    char *p = getenv("HOME");
    if(p) {
      /* build image path in home directory */
      appdata->garmin_path = 
        malloc(strlen(p)+strlen(DEFAULT_GARMIN_PATH)+2);
      strcpy(appdata->garmin_path, p);
      if(appdata->garmin_path[strlen(appdata->garmin_path)-1] != '/')
        strcat(appdata->garmin_path, "/");
      strcat(appdata->garmin_path, DEFAULT_GARMIN_PATH);
    } else
      appdata->garmin_path = strdup(DEFAULT_GARMIN_PATH);
  }

  /* make sure image path actually exists */
  checkdir(appdata->image_path);

  if(!appdata->gpxlist_items)
    appdata->gpxlist_items = GPXLIST_ITEM_DEFAULT;

  if(!appdata->cachelist_items)
    appdata->cachelist_items = CACHELIST_ITEM_DEFAULT;

  /* if there are no entries in the main list, try to add the */
  /* "welcome" one */
  if(!appdata->gpx) {
    char *name = g_strdup(ICONPATH "welcome.gpx");
    dialog = gpx_busy_dialog_new(GTK_WIDGET(appdata->window));
    printf("No GPX file loaded, trying to load demo\n");
    appdata->gpx = gpx_parse(dialog, name, appdata->username);
    gpx_busy_dialog_destroy(dialog);
    g_free(name);
  }
}

1	harbaum	1	/*
2			* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3			*
4			* This file is part of GPXView.
5			*
6			* GPXView 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 3 of the License, or
9			* (at your option) any later version.
10			*
11			* GPXView 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 GPXView. If not, see <http://www.gnu.org/licenses/>.
18			*/
19
20			#include <stddef.h>
21			#include <stdlib.h>
22			#include <ctype.h>
23	harbaum	34	#include <math.h> // for isnan
24	harbaum	1	#include "gpxview.h"
25
26			#define GCONF_PATH "/apps/gpxview/"
27			#define GCONF_KEY_GPX GCONF_PATH "gpx%d"
28			#define GCONF_KEY_CNT GCONF_PATH "entries"
29
30			#define GCONF_KEY_LOC_NAME GCONF_PATH "location%d/name"
31			#define GCONF_KEY_LOC_LAT GCONF_PATH "location%d/latitude"
32			#define GCONF_KEY_LOC_LON GCONF_PATH "location%d/longitude"
33			#define GCONF_KEY_LOC_CNT GCONF_PATH "location_entries"
34
35			#define GCONF_KEY_CLOSED GCONF_PATH "closed/%s"
36
37			#include <string.h>
38
39			enum {
40			STORE_STRING, STORE_FLOAT, STORE_INT, STORE_BOOL,
41			};
42
43			typedef struct {
44			char *key;
45			int type;
46			int offset;
47			} store_t;
48
49			#define OFFSET(a) offsetof(appdata_t, a)
50
51			static store_t store[] = {
52			{ "image_path", STORE_STRING, OFFSET(image_path) },
53			{ "path", STORE_STRING, OFFSET(path) },
54			{ "geotext/text", STORE_STRING, OFFSET(geotext_text) },
55			{ "geotext/shift", STORE_INT, OFFSET(geotext_shift) },
56			{ "mmpoi_path", STORE_STRING, OFFSET(mmpoi_path) },
57			{ "garmin_path", STORE_STRING, OFFSET(garmin_path) },
58			{ "fnotes_path", STORE_STRING, OFFSET(fieldnotes_path) },
59			{ "garmin_ign_found", STORE_BOOL, OFFSET(garmin_ign_found) },
60			{ "active_location", STORE_INT, OFFSET(active_location) },
61			{ "mmpoi_use_radius", STORE_BOOL, OFFSET(mmpoi_use_radius) },
62			{ "mmpoi_radius", STORE_FLOAT, OFFSET(mmpoi_radius) },
63			{ "mmpoi_ign_found", STORE_BOOL, OFFSET(mmpoi_dont_export_found) },
64			{ "mmpoi_ign_disabl", STORE_BOOL, OFFSET(mmpoi_dont_export_disabled) },
65			{ "use_gps", STORE_BOOL, OFFSET(use_gps) },
66			{ "imperial", STORE_BOOL, OFFSET(imperial) },
67			{ "compass_locked", STORE_BOOL, OFFSET(compass_locked) },
68			{ "latitude", STORE_FLOAT, OFFSET(home.lat) },
69			{ "longitude", STORE_FLOAT, OFFSET(home.lon) },
70	harbaum	282	{ "gps_lat", STORE_FLOAT, OFFSET(gps.saved.lat) },
71			{ "gps_lon", STORE_FLOAT, OFFSET(gps.saved.lon) },
72	harbaum	1	{ "search_in", STORE_INT, OFFSET(search) },
73			{ "search_days", STORE_INT, OFFSET(search_days) },
74			{ "search_str", STORE_STRING, OFFSET(search_str) },
75			{ "gpxlist_items", STORE_INT, OFFSET(gpxlist_items) },
76			{ "cachelist_items", STORE_INT, OFFSET(cachelist_items) },
77			{ "compass_damping", STORE_INT, OFFSET(compass_damping) },
78			{ "cachelist_hide_found", STORE_BOOL, OFFSET(cachelist_hide_found) },
79	harbaum	129	{ "cachelist_update", STORE_BOOL, OFFSET(cachelist_update) },
80	harbaum	167	{ "disable_gcvote", STORE_BOOL, OFFSET(disable_gcvote) },
81	harbaum	204	{ "username", STORE_STRING, OFFSET(username) },
82	harbaum	1	#ifdef USE_MAEMO
83			{ "mmpoi_dontlaunch", STORE_BOOL, OFFSET(mmpoi_dontlaunch) },
84			{ "cachelist_dss", STORE_BOOL, OFFSET(cachelist_disable_screensaver) },
85			{ "goto_dss", STORE_BOOL, OFFSET(goto_disable_screensaver) },
86			#endif
87	harbaum	48	#ifdef ENABLE_OSM_GPS_MAP
88			{ "map_lat", STORE_FLOAT, OFFSET(map.pos.lat) },
89			{ "map_lon", STORE_FLOAT, OFFSET(map.pos.lon) },
90			{ "map_zoom", STORE_INT, OFFSET(map.zoom) },
91	harbaum	89	{ "map_source", STORE_INT, OFFSET(map.source) },
92	harbaum	280	{ "map_dpix", STORE_BOOL, OFFSET(map.dpix) },
93	harbaum	48	#endif
94	harbaum	246	#ifdef ESPEAK
95			{ "espeak/enabled", STORE_BOOL, OFFSET(espeak.enabled) },
96			#endif
97	harbaum	196
98	harbaum	197	{ "geotoad/password", STORE_STRING, OFFSET(gt.password) },
99			{ "geotoad/filename", STORE_STRING, OFFSET(gt.filename) },
100			{ "geotoad/distance", STORE_FLOAT, OFFSET(gt.distance) },
101			{ "geotoad/lat", STORE_FLOAT, OFFSET(gt.lat) },
102			{ "geotoad/lon", STORE_FLOAT, OFFSET(gt.lon) },
103			{ "geotoad/flags", STORE_INT, OFFSET(gt.flags) },
104	harbaum	252	{ "geotoad/no_ownfnd",STORE_BOOL, OFFSET(gt.no_owned_found) },
105	harbaum	196
106	harbaum	1	{ NULL, -1, -1 }
107			};
108
109			static char get_basename(char name) {
110			char *p = strrchr(name, '/');
111			if(!p) p = name;
112			else p = p+1;
113
114			g_assert(*p);
115
116			/* escape all non alnum characters */
117			p = g_strdup(p);
118			int i;
119			for(i=0;i<strlen(p);i++)
120			if(!isalnum(p[i]))
121			p[i] = '_';
122
123			return p;
124			}
125
126			void gconf_remove_closed_name(appdata_t appdata, char filename) {
127	harbaum	211	if(!filename \|\| !strlen(filename)) return;
128
129	harbaum	1	char *key = g_strdup_printf(GCONF_KEY_CLOSED, get_basename(filename));
130			gconf_client_unset(appdata->gconf_client, key, NULL);
131			g_free(key);
132			}
133
134			void gconf_save_closed_name(appdata_t appdata, char filename, char *name) {
135	harbaum	211	if(!filename \|\| !strlen(filename)) return;
136
137	harbaum	1	char *key = g_strdup_printf(GCONF_KEY_CLOSED, get_basename(filename));
138			gconf_client_set_string(appdata->gconf_client, key, name, NULL);
139			g_free(key);
140			}
141
142			char gconf_restore_closed_name(appdata_t appdata, char *filename) {
143	harbaum	211	if(!filename \|\| !strlen(filename)) return NULL;
144
145	harbaum	1	char *key = g_strdup_printf(GCONF_KEY_CLOSED, get_basename(filename));
146			char *ret = gconf_client_get_string(appdata->gconf_client, key, NULL);
147			g_free(key);
148			return ret;
149			}
150
151			void gconf_save_state(appdata_t *appdata) {
152			int entries = 0;
153
154	harbaum	221	printf("saving gconf state\n");
155
156	harbaum	158	/* free proxy settings */
157			if(appdata->proxy) {
158			proxy_t *proxy = appdata->proxy;
159
160			if(proxy->authentication_password) g_free(proxy->authentication_password);
161			if(proxy->authentication_user) g_free(proxy->authentication_user);
162			if(proxy->host) g_free(proxy->host);
163			if(proxy->ignore_hosts) g_free(proxy->ignore_hosts);
164
165			g_free(proxy);
166			appdata->proxy = NULL;
167			}
168
169	harbaum	1	gpx_t *gpx = appdata->gpx;
170			while(gpx) {
171			char str[128];
172			snprintf(str, sizeof(str), GCONF_KEY_GPX, entries++);
173			gconf_client_set_string(appdata->gconf_client, str, gpx->filename, NULL);
174			gpx = gpx->next;
175			}
176
177			gconf_client_set_int(appdata->gconf_client, GCONF_KEY_CNT, entries, NULL);
178
179			/* -------------- save locations (excl. home location) --------------- */
180			entries = 0;
181			location_t *loc = appdata->location;
182			while(loc) {
183			char str[128];
184			snprintf(str, sizeof(str), GCONF_KEY_LOC_NAME, entries);
185			gconf_client_set_string(appdata->gconf_client, str, loc->name, NULL);
186			snprintf(str, sizeof(str), GCONF_KEY_LOC_LAT, entries);
187			gconf_client_set_float(appdata->gconf_client, str, loc->pos.lat, NULL);
188			snprintf(str, sizeof(str), GCONF_KEY_LOC_LON, entries);
189			gconf_client_set_float(appdata->gconf_client, str, loc->pos.lon, NULL);
190			entries++;
191			loc = loc->next;
192			}
193
194			gconf_client_set_int(appdata->gconf_client, GCONF_KEY_LOC_CNT, entries, NULL);
195
196			/* store everything listed in the store table */
197			store_t *st = store;
198			while(st->key) {
199			void *ptr = ((void)appdata) + st->offset;
200	harbaum	34	char *key = g_strdup_printf(GCONF_PATH "%s", st->key);
201	harbaum	1
202			switch(st->type) {
203			case STORE_STRING:
204			if((char)(ptr)) {
205			gconf_client_set_string(appdata->gconf_client, key, (char)(ptr), NULL);
206			}
207	harbaum	196	g_free((char)(ptr));
208			*ptr = NULL;
209	harbaum	1	break;
210
211			case STORE_BOOL:
212			gconf_client_set_bool(appdata->gconf_client, key, ((int)ptr), NULL);
213			break;
214
215			case STORE_INT:
216			gconf_client_set_int(appdata->gconf_client, key, ((int)ptr), NULL);
217			break;
218
219			case STORE_FLOAT:
220	harbaum	34	if(!isnan(((float)ptr)))
221			gconf_client_set_float(appdata->gconf_client, key, ((float)ptr), NULL);
222	harbaum	1	break;
223
224			default:
225			printf("Unsupported type %d\n", st->type);
226			break;
227			}
228
229	harbaum	34	g_free(key);
230	harbaum	1	st++;
231			}
232			}
233
234			void gconf_load_state(appdata_t *appdata) {
235			gpx_t **gpx = &appdata->gpx;
236
237			while(gpx) gpx = &((gpx)->next);
238
239			gpx_dialog_t *dialog = NULL;
240
241	harbaum	34	/* default positions are invalid */
242			appdata->home.lat = appdata->home.lon = NAN;
243	harbaum	282	appdata->gps.saved.lat = appdata->gps.saved.lon = NAN;
244	harbaum	220	appdata->geomath.lat = appdata->geomath.lon = NAN;
245	harbaum	34
246	harbaum	196	appdata->gt.lat = appdata->gt.lon = NAN;
247	harbaum	198	appdata->gt.distance = 1.0; // in km/mil
248	harbaum	196
249	harbaum	158	/* ------------- get proxy settings -------------------- */
250			if(gconf_client_get_bool(appdata->gconf_client,
251			PROXY_KEY "use_http_proxy", NULL)) {
252			proxy_t *proxy = appdata->proxy = g_new0(proxy_t, 1);
253
254			/* get basic settings */
255			proxy->host = gconf_client_get_string(appdata->gconf_client,
256			PROXY_KEY "host", NULL);
257			proxy->port = gconf_client_get_int(appdata->gconf_client,
258			PROXY_KEY "port", NULL);
259			proxy->ignore_hosts =
260			gconf_client_get_string(appdata->gconf_client,
261			PROXY_KEY "ignore_hosts", NULL);
262
263			/* check for authentication */
264			proxy->use_authentication =
265			gconf_client_get_bool(appdata->gconf_client,
266			PROXY_KEY "use_authentication", NULL);
267
268			if(proxy->use_authentication) {
269			proxy->authentication_user =
270			gconf_client_get_string(appdata->gconf_client,
271			PROXY_KEY "authentication_user", NULL);
272			proxy->authentication_password =
273			gconf_client_get_string(appdata->gconf_client,
274			PROXY_KEY "authentication_password", NULL);
275			}
276			}
277
278	harbaum	204	/* restore everything listed in the store table */
279			store_t *st = store;
280			while(st->key) {
281			void *ptr = ((void)appdata) + st->offset;
282			char *key = g_strdup_printf(GCONF_PATH "%s", st->key);
283
284			/* check if key is present */
285			GConfValue *value = gconf_client_get(appdata->gconf_client, key, NULL);
286			if(value) {
287			gconf_value_free(value);
288
289			switch(st->type) {
290			case STORE_STRING: {
291			char str = (char)ptr;
292			*str = gconf_client_get_string(appdata->gconf_client, key, NULL);
293			} break;
294
295			case STORE_BOOL:
296			((int)ptr) = gconf_client_get_bool(appdata->gconf_client, key, NULL);
297			break;
298
299			case STORE_INT:
300			((int)ptr) = gconf_client_get_int(appdata->gconf_client, key, NULL);
301			break;
302
303			case STORE_FLOAT:
304			((float)ptr) = gconf_client_get_float(appdata->gconf_client, key, NULL);
305			break;
306
307			default:
308			printf("Unsupported type %d\n", st->type);
309			break;
310			}
311			}
312			g_free(key);
313			st++;
314			}
315
316	harbaum	1	int i, entries = gconf_client_get_int(appdata->gconf_client,
317			GCONF_KEY_CNT, NULL);
318
319			if(entries)
320			dialog = gpx_busy_dialog_new(GTK_WIDGET(appdata->window));
321
322			for(i=0;i<entries;i++) {
323			char str[128];
324			snprintf(str, sizeof(str), GCONF_KEY_GPX, i);
325			char *fname = gconf_client_get_string(appdata->gconf_client, str, NULL);
326			if(fname) {
327			/* check if there's a valid name stored for this file. */
328			/* if yes it's a "closed" file */
329			char *name = gconf_restore_closed_name(appdata, fname);
330			if(name) {
331			*gpx = g_new0(gpx_t, 1);
332			(*gpx)->filename = fname;
333			(*gpx)->name = g_strdup(name);
334			(*gpx)->closed = TRUE;
335			} else {
336			if(g_file_test(fname, G_FILE_TEST_IS_DIR))
337	harbaum	204	*gpx = gpx_parse_dir(dialog, fname, appdata->username);
338	harbaum	1	else
339	harbaum	204	*gpx = gpx_parse(dialog, fname, appdata->username);
340	harbaum	1
341	harbaum	74	if(!*gpx) {
342			/* restoring the gpx file failed, mark it as unusable, but save */
343			/* its presence for later use */
344
345	harbaum	113	/* create "closed" entry to remember this file for next */
346			/* load attempt */
347	harbaum	74	*gpx = g_new0(gpx_t, 1);
348			(*gpx)->filename = fname;
349	harbaum	113	char *p = fname;
350			if(strrchr(fname, '/'))
351			p = strrchr(fname, '/')+1;
352
353			(*gpx)->name = g_strdup_printf(_("Failed to load: %s"), p);
354			(*gpx)->closed = TRUE;
355	harbaum	74	} else
356			free(fname);
357	harbaum	1	}
358	harbaum	103	gpx = &((*gpx)->next);
359	harbaum	1	}
360			}
361
362			gpx_busy_dialog_destroy(dialog);
363
364			/* ------------- load locations --------------------- */
365			entries = gconf_client_get_int(appdata->gconf_client,
366			GCONF_KEY_LOC_CNT, NULL);
367
368			location_t **loc = &appdata->location;
369			for(i=0;i<entries;i++) {
370			*loc = g_new0(location_t, 1);
371			if(*loc) {
372			char str[128];
373			snprintf(str, sizeof(str), GCONF_KEY_LOC_NAME, i);
374			(*loc)->name = gconf_client_get_string(appdata->gconf_client, str, NULL);
375			snprintf(str, sizeof(str), GCONF_KEY_LOC_LAT, i);
376			(*loc)->pos.lat = gconf_client_get_float(appdata->gconf_client, str, NULL);
377			snprintf(str, sizeof(str), GCONF_KEY_LOC_LON, i);
378			(*loc)->pos.lon = gconf_client_get_float(appdata->gconf_client, str, NULL);
379
380			loc = &((*loc)->next);
381			}
382			}
383
384			/* ----- set all kinds of defaults ------- */
385
386			if(!appdata->compass_damping) appdata->compass_damping = 1;
387
388			if(!appdata->mmpoi_radius)
389			appdata->mmpoi_radius = 100.0; // 100 km
390
391			if(!appdata->search)
392			appdata->search = SEARCH_NAME \| SEARCH_ID;
393
394			if(!appdata->image_path) {
395	harbaum	122	#ifdef USE_MAEMO
396			/* update cachelist by default */
397			appdata->cachelist_update = TRUE;
398			#endif
399	harbaum	1
400	harbaum	14	/* use gps by default */
401			appdata->use_gps = TRUE;
402
403	harbaum	1	#ifndef USE_MAEMO
404			char *p = getenv("HOME");
405			if(p) {
406			/* build image path in home directory */
407			appdata->image_path =
408			malloc(strlen(p)+strlen(DEFAULT_IMAGE_PATH_HOME)+2);
409			strcpy(appdata->image_path, p);
410			if(appdata->image_path[strlen(appdata->image_path)-1] != '/')
411			strcat(appdata->image_path, "/");
412			strcat(appdata->image_path, DEFAULT_IMAGE_PATH_HOME);
413			} else
414			#endif
415			appdata->image_path = strdup(DEFAULT_IMAGE_PATH);
416
417	harbaum	62	/* check if this path is actually accessible */
418			/* and change it to the current users home if not */
419			/* (this should only happen on scratchbox) */
420			if(!g_file_test(appdata->image_path, G_FILE_TEST_IS_DIR)) {
421			if(g_mkdir_with_parents(appdata->image_path, 0700) != 0) {
422			char *p = getenv("HOME");
423			if(!p) p = "/tmp/";
424
425			appdata->image_path =
426			g_strdup_printf("%s%s%s", p,
427			(p[strlen(p)-1]!='/')?"/":"",
428			DEFAULT_IMAGE_PATH_HOME);
429			printf("using alt path %s\n", appdata->image_path);
430			}
431			}
432
433	harbaum	1	} else {
434			/* some versions old versions messed up the path */
435			if(appdata->image_path[strlen(appdata->image_path)-1] != '/') {
436			printf("adjusting image path\n");
437			appdata->image_path = realloc(appdata->image_path,
438			strlen(appdata->image_path)+2);
439			strcat(appdata->image_path, "/");
440			}
441			}
442
443			if(!appdata->mmpoi_path) {
444			char *p = getenv("HOME");
445			if(p) {
446			/* build mmpoi path in home directory */
447			appdata->mmpoi_path =
448			malloc(strlen(p)+strlen(DEFAULT_MMPOI_PATH)+2);
449			strcpy(appdata->mmpoi_path, p);
450			if(appdata->mmpoi_path[strlen(appdata->mmpoi_path)-1] != '/')
451			strcat(appdata->mmpoi_path, "/");
452			strcat(appdata->mmpoi_path, DEFAULT_MMPOI_PATH);
453			} else
454			appdata->mmpoi_path = strdup(DEFAULT_MMPOI_PATH);
455			}
456
457			if(!appdata->fieldnotes_path) {
458			char *p = getenv("HOME");
459			if(p) {
460			/* build fieldnotes path in home directory */
461			appdata->fieldnotes_path =
462			malloc(strlen(p)+strlen(DEFAULT_FIELDNOTES_PATH)+2);
463			strcpy(appdata->fieldnotes_path, p);
464			if(appdata->fieldnotes_path[strlen(appdata->fieldnotes_path)-1] != '/')
465			strcat(appdata->fieldnotes_path, "/");
466			strcat(appdata->fieldnotes_path, DEFAULT_FIELDNOTES_PATH);
467			} else
468			appdata->fieldnotes_path = strdup(DEFAULT_FIELDNOTES_PATH);
469			}
470
471			if(!appdata->garmin_path) {
472			char *p = getenv("HOME");
473			if(p) {
474			/* build image path in home directory */
475			appdata->garmin_path =
476			malloc(strlen(p)+strlen(DEFAULT_GARMIN_PATH)+2);
477			strcpy(appdata->garmin_path, p);
478			if(appdata->garmin_path[strlen(appdata->garmin_path)-1] != '/')
479			strcat(appdata->garmin_path, "/");
480			strcat(appdata->garmin_path, DEFAULT_GARMIN_PATH);
481			} else
482			appdata->garmin_path = strdup(DEFAULT_GARMIN_PATH);
483			}
484
485			/* make sure image path actually exists */
486			checkdir(appdata->image_path);
487
488			if(!appdata->gpxlist_items)
489			appdata->gpxlist_items = GPXLIST_ITEM_DEFAULT;
490
491			if(!appdata->cachelist_items)
492			appdata->cachelist_items = CACHELIST_ITEM_DEFAULT;
493
494	harbaum	13	/* if there are no entries in the main list, try to add the */
495			/* "welcome" one */
496			if(!appdata->gpx) {
497	harbaum	17	char *name = g_strdup(ICONPATH "welcome.gpx");
498	harbaum	13	dialog = gpx_busy_dialog_new(GTK_WIDGET(appdata->window));
499			printf("No GPX file loaded, trying to load demo\n");
500	harbaum	204	appdata->gpx = gpx_parse(dialog, name, appdata->username);
501	harbaum	13	gpx_busy_dialog_destroy(dialog);
502			g_free(name);
503			}
504	harbaum	1	}
505