trunk/src/mm_poi.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 "gpxview.h"

#include <math.h>
#include <sqlite3.h>

static const char *cache_type_icons[] = { 
  "traditional",  "multi",  "mystery",  "virtual",
  "webcam",  "event",  "letterbox",  "earthcache",
  "wherigo",  "megaevent",  "cito",  "" };

static const char *cache_type_str[] = { 
  "Traditional", "Multi", "Mystery","Virtual", "Webcam", "Event",
  "Letterbox", "Earthcache", "Wherigo","Megaevent", "CITO",""};

static const char *cache_type_desc[] = {
  "Traditional Caches", "Multi-Caches", "Unknown Caches",
  "Virtual Caches", "Webcam Caches", "Event Caches",
  "Letterbox Hybrids", "Earthcaches", "Wherigo Caches",
  "Mega-Event Caches", "Cache In Trash Out Events",""};

static const char *mode_str[] = { 
  "???", "the cache listing", "the list of caches", "all GPX files" };

static int callback(void *NotUsed, int argc, char **argv, char **azColName){
  int i;
  NotUsed=0;

  for(i=0; i<argc; i++){
    printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
  }
  printf("\n");
  return 0;
}

char *escape(char *str) {
  if(!str) return NULL;

  char *result = malloc(strlen(str)+1);
  char *p = result;

  while(*str) {
    if(*str != '\'') *p++=*str++;
    else             {  *p++='`'; str++; }
  }
  *p = 0;

  return result;
}

/* export a single cache to the database */
static void cache_export(sqlite3 *db, int id, cache_t *cache) {
  char *zErrMsg = 0;
  char cmd[256];

  //  printf("exporting %s: %s\n", cache->id, cache->name);

  char *desc = escape(cache->id);  // short_description
  if(!desc) desc = strdup(_("<none>"));

  char *name = escape(cache->name);
  if(!name) desc = strdup(_("<none>"));

  pos_t pos = gpx_cache_pos(cache);
  char strlon[32], strlat[32];
  g_ascii_dtostr(strlat, sizeof(strlat), pos.lat);
  g_ascii_dtostr(strlon, sizeof(strlon), pos.lon);

  snprintf(cmd, sizeof(cmd), 
           "insert into poi values (%d,%s,%s,'%s','%s',%d)",
           id, strlat, strlon, name, desc, cache->type+12);

  if(sqlite3_exec(db,cmd, callback, 0, &zErrMsg) != SQLITE_OK)
    errorf(_("Creating POI entry:\n\n%s"), zErrMsg);

  if(desc) free(desc);
  if(name) free(name);
}

/* add a cache to the chain of caches to be exported */
static void chain_cache(gpx_t *gpx, cache_t *cache) {
  cache_t **cur = &gpx->cache;

  /* search end of chain */
  while(*cur) {
    if(strcmp(cache->id, (*cur)->id) == 0) 
      return;

    cur = &(*cur)->next;
  }

  *cur = malloc(sizeof(cache_t));
  if(!(*cur)) return;

  memcpy(*cur, cache, sizeof(cache_t));
  (*cur)->next = NULL;
}

static gpx_t *export_list_create(appdata_t *appdata, int *mode) {
  gpx_t *gpx = g_new0(gpx_t,1);
  *mode = 0;

  if(!gpx) return gpx;

#ifdef USE_MAEMO
  if(appdata->cur_cache) {
    printf("cache display, exporting cache only!\n");
    /* appdata->cur_cache */
    chain_cache(gpx, appdata->cur_cache);
    *mode = 1;
  } else if(appdata->search_results) {
    printf("search result display, exporting entire search result\n");
    cache_t *cache = appdata->search_results->cache;
    while(cache) { chain_cache(gpx, cache); cache = cache->next; }
    *mode = 2;
  } else if(appdata->cur_gpx) {
    printf("cachelist display, exporting entire cachelist\n");
    cache_t *cache = appdata->cur_gpx->cache;
    while(cache) { chain_cache(gpx, cache); cache = cache->next; }
    *mode = 2;
  } else
#endif
  {
    printf("gpxlist display, exporting all caches\n");
    gpx_t *lgpx = appdata->gpx;
    while(lgpx) {
      /* make sure notes are imported */
      if(!lgpx->notes_loaded) {
        notes_load_all(appdata, lgpx);
        lgpx->notes_loaded = TRUE;
      }

      cache_t *cache = lgpx->cache;
      while(cache) { chain_cache(gpx, cache); cache = cache->next; }
      lgpx = lgpx->next;
    }
    *mode = 3;
  }

  return gpx;
}

static void export_list_free(gpx_t *gpx) {
  printf("freeing export list\n");

  cache_t *cache = gpx->cache;
  while(cache) {
    cache_t *tmp = cache;
    cache = cache->next;
    free(tmp);
  }
  free(gpx);
}

static int export_list_count(appdata_t *appdata, gpx_t *gpx) {
  pos_t *refpos = get_pos(appdata);
  int cnt = 0;

  cache_t *cache = gpx->cache;
  while(cache) {
    /* no disabled/archived if requested */
    if(!(appdata->mmpoi_dont_export_disabled && 
         (!cache->available || cache->archived))) {

      /* no found if requested */
      if(!(appdata->mmpoi_dont_export_found && 
           cache->notes && cache->notes->found)) {
           
        if(appdata->mmpoi_use_radius && !isnan(appdata->mmpoi_radius)) {
          /* count all caches within given radius around current position */
          if(gpx_pos_get_distance(*refpos, gpx_cache_pos(cache), 0) < 
             appdata->mmpoi_radius)
            cnt++;
        } else
          cnt++;
      }
      
    }

    cache = cache->next;
  }
  return cnt;
}

typedef struct {
  GtkWidget *use_radius;
  GtkWidget *no_found;
  GtkWidget *no_disabled;
  GtkWidget *entry;
  GtkWidget *info_label;
  GtkWidget *dialog;
  appdata_t *appdata;
  guint handler_id;
  int mode;
  gpx_t *gpx;
#ifdef USE_MAEMO
  GtkWidget *launch;
#endif
} export_context_t;

static gboolean export_list_update(gpointer data) {
  char str[256];
  export_context_t *context = (export_context_t*)data;

  printf("updating list ...\n");

  int cnum = export_list_count(context->appdata, context->gpx);
  printf("About to export %d caches\n", cnum);

  snprintf(str, sizeof(str), 
           _("This will export %d caches from %s."),
           cnum, _(mode_str[context->mode]));

  gtk_label_set_text(GTK_LABEL(context->info_label), str);

  return FALSE;
}

/* Our usual callback function */
static void export_update(GtkWidget *widget, gpointer data) {
  export_context_t *context = (export_context_t *)data;

  if(check_button_get_active(context->use_radius)) {
    textbox_enable(context->entry);
    context->appdata->mmpoi_use_radius = TRUE;
  } else { 
    textbox_disable(context->entry);
    context->appdata->mmpoi_use_radius = FALSE;
  }

  context->appdata->mmpoi_dont_export_found = 
      toggle_button_get_active(context->no_found);

  context->appdata->mmpoi_dont_export_disabled = 
      toggle_button_get_active(context->no_disabled);

  export_list_update(context);
}

static void export_radius_modified(GtkWidget *widget, gpointer data ) {
  export_context_t *context = (export_context_t*)data;

  context->appdata->mmpoi_radius = 
    dist_entry_get(context->entry, context->appdata->imperial);

  printf("Distance is %.2f km\n", context->appdata->mmpoi_radius);

  if(context->handler_id) {
    printf("resetting running timer\n");
    gtk_timeout_remove(context->handler_id);
    context->handler_id = 0;
  }

  if(!isnan(context->appdata->mmpoi_radius))
    context->handler_id = 
      gtk_timeout_add(1000, export_list_update, context);  
}

/* Our usual callback function */
static void on_cancel(GtkWidget *widget, gpointer data) {
  int *flag = (int*)data;
  *flag = TRUE;
}

void mmpoi_export(appdata_t *appdata) {
  sqlite3 *db;
  char *zErrMsg = 0;
  char cmd[256];
  int rc, i;
  char *old_mmpoi_path = strdup(appdata->mmpoi_path);

  export_context_t context;
  memset(&context, 0, sizeof(export_context_t));
  context.appdata = appdata;

  printf("export poi\n");

  /* first create a new faked gpx file containing all caches to */
  /* be exported */
  context.gpx = export_list_create(appdata, &context.mode);
  if(!context.gpx) {
    errorf(_("Out of memory"));
    return;
  }

  /* --------- do confirmation dialog ----------- */
  context.dialog = gtk_dialog_new_with_buttons(_("Maemo Mapper POI export"),
          GTK_WINDOW(appdata->window), GTK_DIALOG_MODAL,
          GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
          GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
          NULL);

#if defined(USE_MAEMO) && defined(HILDON_HELP)
  hildon_help_dialog_help_enable(GTK_DIALOG(context.dialog), 
                 HELP_ID_EXPORT, appdata->osso_context);
#endif 

  GtkWidget *vbox = gtk_vbox_new(FALSE,0);

  /* ------------------ radius limit gui ------------------ */
                              
  GtkWidget *label, *hbox = gtk_hbox_new(FALSE,2);
  context.use_radius = check_button_new_with_label(
               _("Limit export radius to:"));
  context.entry = dist_entry_new(appdata->mmpoi_radius, appdata->imperial);

  gtk_box_pack_start_defaults(GTK_BOX(hbox), context.use_radius);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), context.entry);
  gtk_box_pack_start_defaults(GTK_BOX(vbox), hbox);

  check_button_set_active(context.use_radius, appdata->mmpoi_use_radius);

  /* Connect the "clicked" signal of the button to our callback */
  gtk_signal_connect (GTK_OBJECT(context.use_radius), "clicked",
                      GTK_SIGNAL_FUNC(export_update), (gpointer)&context);

  g_signal_connect(G_OBJECT(context.entry), "changed",
                   G_CALLBACK(export_radius_modified), (gpointer)&context);

  /* ------------------ don't export found/disabled/archived -------------- */
  hbox = gtk_hbox_new(FALSE,2); 

  label = gtk_label_new(_("Don't export"));
  gtk_misc_set_alignment(GTK_MISC(label), 0.f, 0.5f);
  GtkWidget *ihbox = gtk_hbox_new(FALSE,0); 
  context.no_found = toggle_button_new_with_label(_("found"));
  context.no_disabled = toggle_button_new_with_label(_("disabled/archived"));

  toggle_button_set_active(context.no_found, 
                          appdata->mmpoi_dont_export_found);

  toggle_button_set_active(context.no_disabled, 
                          appdata->mmpoi_dont_export_disabled);

  gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
  gtk_box_pack_start_defaults(GTK_BOX(ihbox), context.no_found);
  gtk_box_pack_start_defaults(GTK_BOX(ihbox), context.no_disabled);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), ihbox);

  gtk_signal_connect (GTK_OBJECT(context.no_found), "clicked",
                      GTK_SIGNAL_FUNC(export_update), (gpointer)&context);
  gtk_signal_connect (GTK_OBJECT(context.no_disabled), "clicked",
                      GTK_SIGNAL_FUNC(export_update), (gpointer)&context);

  gtk_box_pack_start_defaults(GTK_BOX(vbox),hbox);

  /* ------------------ info text -------------- */

  context.info_label = gtk_label_new("");
  gtk_label_set_line_wrap_mode(GTK_LABEL(context.info_label), PANGO_WRAP_WORD);
  gtk_label_set_line_wrap(GTK_LABEL(context.info_label), TRUE);
  gtk_misc_set_alignment(GTK_MISC(context.info_label), 0.f, 0.5f);
  gtk_box_pack_start_defaults(GTK_BOX(vbox), context.info_label);

  export_update(NULL, &context);

#ifdef USE_MAEMO
  gtk_box_pack_start_defaults(GTK_BOX(vbox),
                      context.launch = check_button_new_with_label(
                      _("Launch Maemo Mapper after export")));
  check_button_set_active(context.launch, !appdata->mmpoi_dontlaunch);
#endif

  /* ------------------ path/file ------------------ */
  gtk_box_pack_start_defaults(GTK_BOX(vbox), gtk_hseparator_new());

  gtk_box_pack_start_defaults(GTK_BOX(vbox), 
      export_file(_("Save POI database"), &appdata->mmpoi_path));

  /* ------------------ info ------------------ */

  gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(context.dialog)->vbox), vbox);

  gtk_widget_show_all(context.dialog);

  if(GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(context.dialog))) {
#ifdef USE_MAEMO
    appdata->mmpoi_dontlaunch = 
      !check_button_get_active(context.launch);
#endif

    /* remove existing database */
    remove(appdata->mmpoi_path);

    if(checkdir(appdata->mmpoi_path) != 0) 
      errorf(_("Unable to access or create output directory!"));
    else {

      /* build a progress dialog which can even be stopped */
      
      GtkWidget *pbar, *wait_dialog = gtk_dialog_new();
      gtk_dialog_set_has_separator(GTK_DIALOG(wait_dialog), FALSE);
      gtk_window_set_default_size(GTK_WINDOW(wait_dialog), 250, 100);
      gtk_window_set_title(GTK_WINDOW(wait_dialog), _("Exporting"));
      gtk_window_set_modal(GTK_WINDOW(wait_dialog), TRUE);
      gtk_window_set_transient_for(GTK_WINDOW(wait_dialog), 
                                   GTK_WINDOW(context.dialog));
      gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(wait_dialog)->vbox),
                                  pbar = gtk_progress_bar_new());
      
      GtkWidget *button = button_new_with_label(_("Cancel"));
      int cancelled = 0;
      gtk_signal_connect(GTK_OBJECT(button), "clicked",
                         GTK_SIGNAL_FUNC(on_cancel), (gpointer)&cancelled);
      gtk_container_add(GTK_CONTAINER(GTK_DIALOG(wait_dialog)->action_area),
                        button);
      
      gtk_widget_show_all(wait_dialog);
      
      /* ---------------------- copy icons --------------------- */
      for(i=0;cache_type_icons[i][0];i++) {
        char *src = malloc(strlen(ICONPATH)+strlen(cache_type_icons[i])+
                           strlen("cache_type_.png")+1);
        sprintf(src, ICONPATH "cache_type_%s.png", cache_type_icons[i]);
        if(!g_file_test(src, G_FILE_TEST_EXISTS)) 
          sprintf(src, "./icons/cache_type_%s.png", cache_type_icons[i]);
        
        if(g_file_test(src, G_FILE_TEST_EXISTS)) {
          char *dest = malloc(strlen(appdata->mmpoi_path)+
                              strlen(cache_type_icons[i])+strlen(".jpg")+1);
          strcpy(dest, appdata->mmpoi_path);
          *(strrchr(dest, '/')+1) = 0;
          sprintf(dest+strlen(dest), "%s.jpg", cache_type_icons[i]);
          
          /* read source file */
          FILE *file = fopen(src, "rb");
          fseek(file, 0, SEEK_END);
          int len = ftell(file);
          fseek(file, 0, SEEK_SET);
          char *buffer = malloc(len);
          fread(buffer, 1l, len, file);
          fclose(file);
        
          /* write destination file */
          file = fopen(dest, "wb");
          fwrite(buffer, 1l, len, file);
          fclose(file);
          
          free(buffer);
          free(dest);
        }
        
        free(src);
      }
    
      /* ---------------------- database export --------------------- */
      
      printf("exporting to %s\n", appdata->mmpoi_path);
      rc = sqlite3_open(appdata->mmpoi_path, &db);
      if( rc ){
        errorf(_("Can't open SQL database:\n\n%s"), sqlite3_errmsg(db));
        sqlite3_close(db);
        export_list_free(context.gpx);
        return;
      }
      
      /* create the table */
      rc = sqlite3_exec(db, "create table category (cat_id integer PRIMARY "
                        "KEY, label text, desc text, enabled integer)", 
                        callback, 0, &zErrMsg);
      if( rc!=SQLITE_OK ) {
        errorf(_("Creating cathegory table:\n\n%s"), zErrMsg);
        sqlite3_close(db);
        export_list_free(context.gpx);
        return;
      }
      
      /* create all types */
      i = 0;
      while(cache_type_str[i][0]) {
        snprintf(cmd, sizeof(cmd), 
                 "insert into category values (%d, '%s', '%s', 1)", 
                 12+i, cache_type_str[i], cache_type_desc[i]);
        
        rc = sqlite3_exec(db, cmd, callback, 0, &zErrMsg);
        if( rc != SQLITE_OK ){
          errorf(_("Creating cathegory:\n\n%s"), zErrMsg);
          sqlite3_close(db);
          export_list_free(context.gpx);
          return;
        }
        i++;
      }
      
      rc = sqlite3_exec(db, "create table poi (poi_id integer PRIMARY KEY, "
                        "lat real, lon real, label text, desc text, "
                        "cat_id integer)", callback, 0, &zErrMsg);
      if( rc!=SQLITE_OK ){
        errorf(_("Creating POI table:\n\n%s"), zErrMsg);
        sqlite3_close(db);
        export_list_free(context.gpx);
        return;
      }

      pos_t *refpos = get_pos(appdata);
      
      /* export the caches */
      int id = 1;
      cache_t *cache = context.gpx->cache;
      int total = export_list_count(appdata, context.gpx);
      
      while(cache && !cancelled) {
        
        /* no disabled/archived if requested */
        if(!(appdata->mmpoi_dont_export_disabled && 
             (!cache->available || cache->archived))) {
          
          /* no found if requested */
          if(!(appdata->mmpoi_dont_export_found && 
               cache->notes && cache->notes->found)) {

            if(appdata->mmpoi_use_radius && !isnan(appdata->mmpoi_radius)) {
              /* count all caches within given radius around current position */
              if(gpx_pos_get_distance(*refpos, gpx_cache_pos(cache), 0) < 
                 appdata->mmpoi_radius) {
                printf("%d exporting %s\n", id, cache->id);
                cache_export(db, id++, cache);
              }
            } else {
              printf("%d exporting %s\n", id, cache->id);
              cache_export(db, id++, cache);
            }
          }
        }
        cache = cache->next;
        
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar), 
                                      (float)(id-2)/(float)total);
        
        while(gtk_events_pending ())
          gtk_main_iteration ();
      }
      sqlite3_close(db);

      gtk_widget_destroy(wait_dialog);
      
#ifdef USE_MAEMO
      if(!cancelled && !appdata->mmpoi_dontlaunch)
        dbus_mm_set_position(appdata, NULL);
#endif
    }
  } else {
    /* restore old mmpoi_path, in case it has been altered but not been used */
    free(appdata->mmpoi_path);
    appdata->mmpoi_path = strdup(old_mmpoi_path);
  }

  gtk_widget_destroy(context.dialog);
  
  if(context.handler_id) {
    printf("removing timer\n");
    gtk_timeout_remove(context.handler_id);
  }

  export_list_free(context.gpx);

  free(old_mmpoi_path);
}
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 "gpxview.h"
21
22	#include <math.h>
23	#include <sqlite3.h>
24
25	static const char *cache_type_icons[] = {
26	"traditional", "multi", "mystery", "virtual",
27	"webcam", "event", "letterbox", "earthcache",
28	"wherigo", "megaevent", "cito", "" };
29
30	static const char *cache_type_str[] = {
31	"Traditional", "Multi", "Mystery","Virtual", "Webcam", "Event",
32	"Letterbox", "Earthcache", "Wherigo","Megaevent", "CITO",""};
33
34	static const char *cache_type_desc[] = {
35	"Traditional Caches", "Multi-Caches", "Unknown Caches",
36	"Virtual Caches", "Webcam Caches", "Event Caches",
37	"Letterbox Hybrids", "Earthcaches", "Wherigo Caches",
38	"Mega-Event Caches", "Cache In Trash Out Events",""};
39
40	static const char *mode_str[] = {
41	"???", "the cache listing", "the list of caches", "all GPX files" };
42
43	static int callback(void NotUsed, int argc, char argv, char *azColName){
44	int i;
45	NotUsed=0;
46
47	for(i=0; i<argc; i++){
48	printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
49	}
50	printf("\n");
51	return 0;
52	}
53
54	char escape(char str) {
55	if(!str) return NULL;
56
57	char *result = malloc(strlen(str)+1);
58	char *p = result;
59
60	while(*str) {
61	if(str != '\'') p++=*str++;
62	else { *p++='`'; str++; }
63	}
64	*p = 0;
65
66	return result;
67	}
68
69	/* export a single cache to the database */
70	static void cache_export(sqlite3 db, int id, cache_t cache) {
71	char *zErrMsg = 0;
72	char cmd[256];
73
74	// printf("exporting %s: %s\n", cache->id, cache->name);
75
76	char *desc = escape(cache->id); // short_description
77	if(!desc) desc = strdup(_("<none>"));
78
79	char *name = escape(cache->name);
80	if(!name) desc = strdup(_("<none>"));
81
82	pos_t pos = gpx_cache_pos(cache);
83	char strlon[32], strlat[32];
84	g_ascii_dtostr(strlat, sizeof(strlat), pos.lat);
85	g_ascii_dtostr(strlon, sizeof(strlon), pos.lon);
86
87	snprintf(cmd, sizeof(cmd),
88	"insert into poi values (%d,%s,%s,'%s','%s',%d)",
89	id, strlat, strlon, name, desc, cache->type+12);
90
91	if(sqlite3_exec(db,cmd, callback, 0, &zErrMsg) != SQLITE_OK)
92	errorf(_("Creating POI entry:\n\n%s"), zErrMsg);
93
94	if(desc) free(desc);
95	if(name) free(name);
96	}
97
98	/* add a cache to the chain of caches to be exported */
99	static void chain_cache(gpx_t gpx, cache_t cache) {
100	cache_t **cur = &gpx->cache;
101
102	/* search end of chain */
103	while(*cur) {
104	if(strcmp(cache->id, (*cur)->id) == 0)
105	return;
106
107	cur = &(*cur)->next;
108	}
109
110	*cur = malloc(sizeof(cache_t));
111	if(!(*cur)) return;
112
113	memcpy(*cur, cache, sizeof(cache_t));
114	(*cur)->next = NULL;
115	}
116
117	static gpx_t export_list_create(appdata_t appdata, int *mode) {
118	gpx_t *gpx = g_new0(gpx_t,1);
119	*mode = 0;
120
121	if(!gpx) return gpx;
122
123	#ifdef USE_MAEMO
124	if(appdata->cur_cache) {
125	printf("cache display, exporting cache only!\n");
126	/* appdata->cur_cache */
127	chain_cache(gpx, appdata->cur_cache);
128	*mode = 1;
129	} else if(appdata->search_results) {
130	printf("search result display, exporting entire search result\n");
131	cache_t *cache = appdata->search_results->cache;
132	while(cache) { chain_cache(gpx, cache); cache = cache->next; }
133	*mode = 2;
134	} else if(appdata->cur_gpx) {
135	printf("cachelist display, exporting entire cachelist\n");
136	cache_t *cache = appdata->cur_gpx->cache;
137	while(cache) { chain_cache(gpx, cache); cache = cache->next; }
138	*mode = 2;
139	} else
140	#endif
141	{
142	printf("gpxlist display, exporting all caches\n");
143	gpx_t *lgpx = appdata->gpx;
144	while(lgpx) {
145	/* make sure notes are imported */
146	if(!lgpx->notes_loaded) {
147	notes_load_all(appdata, lgpx);
148	lgpx->notes_loaded = TRUE;
149	}
150
151	cache_t *cache = lgpx->cache;
152	while(cache) { chain_cache(gpx, cache); cache = cache->next; }
153	lgpx = lgpx->next;
154	}
155	*mode = 3;
156	}
157
158	return gpx;
159	}
160
161	static void export_list_free(gpx_t *gpx) {
162	printf("freeing export list\n");
163
164	cache_t *cache = gpx->cache;
165	while(cache) {
166	cache_t *tmp = cache;
167	cache = cache->next;
168	free(tmp);
169	}
170	free(gpx);
171	}
172
173	static int export_list_count(appdata_t appdata, gpx_t gpx) {
174	pos_t *refpos = get_pos(appdata);
175	int cnt = 0;
176
177	cache_t *cache = gpx->cache;
178	while(cache) {
179	/* no disabled/archived if requested */
180	if(!(appdata->mmpoi_dont_export_disabled &&
181	(!cache->available \|\| cache->archived))) {
182
183	/* no found if requested */
184	if(!(appdata->mmpoi_dont_export_found &&
185	cache->notes && cache->notes->found)) {
186
187	if(appdata->mmpoi_use_radius && !isnan(appdata->mmpoi_radius)) {
188	/* count all caches within given radius around current position */
189	if(gpx_pos_get_distance(*refpos, gpx_cache_pos(cache), 0) <
190	appdata->mmpoi_radius)
191	cnt++;
192	} else
193	cnt++;
194	}
195
196	}
197
198	cache = cache->next;
199	}
200	return cnt;
201	}
202
203	typedef struct {
204	GtkWidget *use_radius;
205	GtkWidget *no_found;
206	GtkWidget *no_disabled;
207	GtkWidget *entry;
208	GtkWidget *info_label;
209	GtkWidget *dialog;
210	appdata_t *appdata;
211	guint handler_id;
212	int mode;
213	gpx_t *gpx;
214	#ifdef USE_MAEMO
215	GtkWidget *launch;
216	#endif
217	} export_context_t;
218
219	static gboolean export_list_update(gpointer data) {
220	char str[256];
221	export_context_t context = (export_context_t)data;
222
223	printf("updating list ...\n");
224
225	int cnum = export_list_count(context->appdata, context->gpx);
226	printf("About to export %d caches\n", cnum);
227
228	snprintf(str, sizeof(str),
229	_("This will export %d caches from %s."),
230	cnum, _(mode_str[context->mode]));
231
232	gtk_label_set_text(GTK_LABEL(context->info_label), str);
233
234	return FALSE;
235	}
236
237	/* Our usual callback function */
238	static void export_update(GtkWidget *widget, gpointer data) {
239	export_context_t context = (export_context_t )data;
240
241	if(check_button_get_active(context->use_radius)) {
242	textbox_enable(context->entry);
243	context->appdata->mmpoi_use_radius = TRUE;
244	} else {
245	textbox_disable(context->entry);
246	context->appdata->mmpoi_use_radius = FALSE;
247	}
248
249	context->appdata->mmpoi_dont_export_found =
250	toggle_button_get_active(context->no_found);
251
252	context->appdata->mmpoi_dont_export_disabled =
253	toggle_button_get_active(context->no_disabled);
254
255	export_list_update(context);
256	}
257
258	static void export_radius_modified(GtkWidget *widget, gpointer data ) {
259	export_context_t context = (export_context_t)data;
260
261	context->appdata->mmpoi_radius =
262	dist_entry_get(context->entry, context->appdata->imperial);
263
264	printf("Distance is %.2f km\n", context->appdata->mmpoi_radius);
265
266	if(context->handler_id) {
267	printf("resetting running timer\n");
268	gtk_timeout_remove(context->handler_id);
269	context->handler_id = 0;
270	}
271
272	if(!isnan(context->appdata->mmpoi_radius))
273	context->handler_id =
274	gtk_timeout_add(1000, export_list_update, context);
275	}
276
277	/* Our usual callback function */
278	static void on_cancel(GtkWidget *widget, gpointer data) {
279	int flag = (int)data;
280	*flag = TRUE;
281	}
282
283	void mmpoi_export(appdata_t *appdata) {
284	sqlite3 *db;
285	char *zErrMsg = 0;
286	char cmd[256];
287	int rc, i;
288	char *old_mmpoi_path = strdup(appdata->mmpoi_path);
289
290	export_context_t context;
291	memset(&context, 0, sizeof(export_context_t));
292	context.appdata = appdata;
293
294	printf("export poi\n");
295
296	/* first create a new faked gpx file containing all caches to */
297	/* be exported */
298	context.gpx = export_list_create(appdata, &context.mode);
299	if(!context.gpx) {
300	errorf(_("Out of memory"));
301	return;
302	}
303
304	/* --------- do confirmation dialog ----------- */
305	context.dialog = gtk_dialog_new_with_buttons(_("Maemo Mapper POI export"),
306	GTK_WINDOW(appdata->window), GTK_DIALOG_MODAL,
307	GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
308	GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
309	NULL);
310
311	#if defined(USE_MAEMO) && defined(HILDON_HELP)
312	hildon_help_dialog_help_enable(GTK_DIALOG(context.dialog),
313	HELP_ID_EXPORT, appdata->osso_context);
314	#endif
315
316	GtkWidget *vbox = gtk_vbox_new(FALSE,0);
317
318	/* ------------------ radius limit gui ------------------ */
319
320	GtkWidget label, hbox = gtk_hbox_new(FALSE,2);
321	context.use_radius = check_button_new_with_label(
322	_("Limit export radius to:"));
323	context.entry = dist_entry_new(appdata->mmpoi_radius, appdata->imperial);
324
325	gtk_box_pack_start_defaults(GTK_BOX(hbox), context.use_radius);
326	gtk_box_pack_start_defaults(GTK_BOX(hbox), context.entry);
327	gtk_box_pack_start_defaults(GTK_BOX(vbox), hbox);
328
329	check_button_set_active(context.use_radius, appdata->mmpoi_use_radius);
330
331	/* Connect the "clicked" signal of the button to our callback */
332	gtk_signal_connect (GTK_OBJECT(context.use_radius), "clicked",
333	GTK_SIGNAL_FUNC(export_update), (gpointer)&context);
334
335	g_signal_connect(G_OBJECT(context.entry), "changed",
336	G_CALLBACK(export_radius_modified), (gpointer)&context);
337
338	/* ------------------ don't export found/disabled/archived -------------- */
339	hbox = gtk_hbox_new(FALSE,2);
340
341	label = gtk_label_new(_("Don't export"));
342	gtk_misc_set_alignment(GTK_MISC(label), 0.f, 0.5f);
343	GtkWidget *ihbox = gtk_hbox_new(FALSE,0);
344	context.no_found = toggle_button_new_with_label(_("found"));
345	context.no_disabled = toggle_button_new_with_label(_("disabled/archived"));
346
347	toggle_button_set_active(context.no_found,
348	appdata->mmpoi_dont_export_found);
349
350	toggle_button_set_active(context.no_disabled,
351	appdata->mmpoi_dont_export_disabled);
352
353	gtk_box_pack_start_defaults(GTK_BOX(hbox), label);
354	gtk_box_pack_start_defaults(GTK_BOX(ihbox), context.no_found);
355	gtk_box_pack_start_defaults(GTK_BOX(ihbox), context.no_disabled);
356	gtk_box_pack_start_defaults(GTK_BOX(hbox), ihbox);
357
358	gtk_signal_connect (GTK_OBJECT(context.no_found), "clicked",
359	GTK_SIGNAL_FUNC(export_update), (gpointer)&context);
360	gtk_signal_connect (GTK_OBJECT(context.no_disabled), "clicked",
361	GTK_SIGNAL_FUNC(export_update), (gpointer)&context);
362
363	gtk_box_pack_start_defaults(GTK_BOX(vbox),hbox);
364
365	/* ------------------ info text -------------- */
366
367	context.info_label = gtk_label_new("");
368	gtk_label_set_line_wrap_mode(GTK_LABEL(context.info_label), PANGO_WRAP_WORD);
369	gtk_label_set_line_wrap(GTK_LABEL(context.info_label), TRUE);
370	gtk_misc_set_alignment(GTK_MISC(context.info_label), 0.f, 0.5f);
371	gtk_box_pack_start_defaults(GTK_BOX(vbox), context.info_label);
372
373	export_update(NULL, &context);
374
375	#ifdef USE_MAEMO
376	gtk_box_pack_start_defaults(GTK_BOX(vbox),
377	context.launch = check_button_new_with_label(
378	_("Launch Maemo Mapper after export")));
379	check_button_set_active(context.launch, !appdata->mmpoi_dontlaunch);
380	#endif
381
382	/* ------------------ path/file ------------------ */
383	gtk_box_pack_start_defaults(GTK_BOX(vbox), gtk_hseparator_new());
384
385	gtk_box_pack_start_defaults(GTK_BOX(vbox),
386	export_file(_("Save POI database"), &appdata->mmpoi_path));
387
388	/* ------------------ info ------------------ */
389
390	gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(context.dialog)->vbox), vbox);
391
392	gtk_widget_show_all(context.dialog);
393
394	if(GTK_RESPONSE_ACCEPT == gtk_dialog_run(GTK_DIALOG(context.dialog))) {
395	#ifdef USE_MAEMO
396	appdata->mmpoi_dontlaunch =
397	!check_button_get_active(context.launch);
398	#endif
399
400	/* remove existing database */
401	remove(appdata->mmpoi_path);
402
403	if(checkdir(appdata->mmpoi_path) != 0)
404	errorf(_("Unable to access or create output directory!"));
405	else {
406
407	/* build a progress dialog which can even be stopped */
408
409	GtkWidget pbar, wait_dialog = gtk_dialog_new();
410	gtk_dialog_set_has_separator(GTK_DIALOG(wait_dialog), FALSE);
411	gtk_window_set_default_size(GTK_WINDOW(wait_dialog), 250, 100);
412	gtk_window_set_title(GTK_WINDOW(wait_dialog), _("Exporting"));
413	gtk_window_set_modal(GTK_WINDOW(wait_dialog), TRUE);
414	gtk_window_set_transient_for(GTK_WINDOW(wait_dialog),
415	GTK_WINDOW(context.dialog));
416	gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(wait_dialog)->vbox),
417	pbar = gtk_progress_bar_new());
418
419	GtkWidget *button = button_new_with_label(_("Cancel"));
420	int cancelled = 0;
421	gtk_signal_connect(GTK_OBJECT(button), "clicked",
422	GTK_SIGNAL_FUNC(on_cancel), (gpointer)&cancelled);
423	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(wait_dialog)->action_area),
424	button);
425
426	gtk_widget_show_all(wait_dialog);
427
428	/* ---------------------- copy icons --------------------- */
429	for(i=0;cache_type_icons[i][0];i++) {
430	char *src = malloc(strlen(ICONPATH)+strlen(cache_type_icons[i])+
431	strlen("cache_type_.png")+1);
432	sprintf(src, ICONPATH "cache_type_%s.png", cache_type_icons[i]);
433	if(!g_file_test(src, G_FILE_TEST_EXISTS))
434	sprintf(src, "./icons/cache_type_%s.png", cache_type_icons[i]);
435
436	if(g_file_test(src, G_FILE_TEST_EXISTS)) {
437	char *dest = malloc(strlen(appdata->mmpoi_path)+
438	strlen(cache_type_icons[i])+strlen(".jpg")+1);
439	strcpy(dest, appdata->mmpoi_path);
440	*(strrchr(dest, '/')+1) = 0;
441	sprintf(dest+strlen(dest), "%s.jpg", cache_type_icons[i]);
442
443	/* read source file */
444	FILE *file = fopen(src, "rb");
445	fseek(file, 0, SEEK_END);
446	int len = ftell(file);
447	fseek(file, 0, SEEK_SET);
448	char *buffer = malloc(len);
449	fread(buffer, 1l, len, file);
450	fclose(file);
451
452	/* write destination file */
453	file = fopen(dest, "wb");
454	fwrite(buffer, 1l, len, file);
455	fclose(file);
456
457	free(buffer);
458	free(dest);
459	}
460
461	free(src);
462	}
463
464	/* ---------------------- database export --------------------- */
465
466	printf("exporting to %s\n", appdata->mmpoi_path);
467	rc = sqlite3_open(appdata->mmpoi_path, &db);
468	if( rc ){
469	errorf(_("Can't open SQL database:\n\n%s"), sqlite3_errmsg(db));
470	sqlite3_close(db);
471	export_list_free(context.gpx);
472	return;
473	}
474
475	/* create the table */
476	rc = sqlite3_exec(db, "create table category (cat_id integer PRIMARY "
477	"KEY, label text, desc text, enabled integer)",
478	callback, 0, &zErrMsg);
479	if( rc!=SQLITE_OK ) {
480	errorf(_("Creating cathegory table:\n\n%s"), zErrMsg);
481	sqlite3_close(db);
482	export_list_free(context.gpx);
483	return;
484	}
485
486	/* create all types */
487	i = 0;
488	while(cache_type_str[i][0]) {
489	snprintf(cmd, sizeof(cmd),
490	"insert into category values (%d, '%s', '%s', 1)",
491	12+i, cache_type_str[i], cache_type_desc[i]);
492
493	rc = sqlite3_exec(db, cmd, callback, 0, &zErrMsg);
494	if( rc != SQLITE_OK ){
495	errorf(_("Creating cathegory:\n\n%s"), zErrMsg);
496	sqlite3_close(db);
497	export_list_free(context.gpx);
498	return;
499	}
500	i++;
501	}
502
503	rc = sqlite3_exec(db, "create table poi (poi_id integer PRIMARY KEY, "
504	"lat real, lon real, label text, desc text, "
505	"cat_id integer)", callback, 0, &zErrMsg);
506	if( rc!=SQLITE_OK ){
507	errorf(_("Creating POI table:\n\n%s"), zErrMsg);
508	sqlite3_close(db);
509	export_list_free(context.gpx);
510	return;
511	}
512
513	pos_t *refpos = get_pos(appdata);
514
515	/* export the caches */
516	int id = 1;
517	cache_t *cache = context.gpx->cache;
518	int total = export_list_count(appdata, context.gpx);
519
520	while(cache && !cancelled) {
521
522	/* no disabled/archived if requested */
523	if(!(appdata->mmpoi_dont_export_disabled &&
524	(!cache->available \|\| cache->archived))) {
525
526	/* no found if requested */
527	if(!(appdata->mmpoi_dont_export_found &&
528	cache->notes && cache->notes->found)) {
529
530	if(appdata->mmpoi_use_radius && !isnan(appdata->mmpoi_radius)) {
531	/* count all caches within given radius around current position */
532	if(gpx_pos_get_distance(*refpos, gpx_cache_pos(cache), 0) <
533	appdata->mmpoi_radius) {
534	printf("%d exporting %s\n", id, cache->id);
535	cache_export(db, id++, cache);
536	}
537	} else {
538	printf("%d exporting %s\n", id, cache->id);
539	cache_export(db, id++, cache);
540	}
541	}
542	}
543	cache = cache->next;
544
545	gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar),
546	(float)(id-2)/(float)total);
547
548	while(gtk_events_pending ())
549	gtk_main_iteration ();
550	}
551	sqlite3_close(db);
552
553	gtk_widget_destroy(wait_dialog);
554
555	#ifdef USE_MAEMO
556	if(!cancelled && !appdata->mmpoi_dontlaunch)
557	dbus_mm_set_position(appdata, NULL);
558	#endif
559	}
560	} else {
561	/* restore old mmpoi_path, in case it has been altered but not been used */
562	free(appdata->mmpoi_path);
563	appdata->mmpoi_path = strdup(old_mmpoi_path);
564	}
565
566	gtk_widget_destroy(context.dialog);
567
568	if(context.handler_id) {
569	printf("removing timer\n");
570	gtk_timeout_remove(context.handler_id);
571	}
572
573	export_list_free(context.gpx);
574
575	free(old_mmpoi_path);
576	}