trunk/src/geotoad.c

/*
 * Copyright (C) 2009 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"

#define __USE_GNU
#include <string.h>

#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <math.h>

#if defined(USE_MAEMO) && (MAEMO_VERSION_MAJOR >= 5)
#include <hildon/hildon-entry.h>
#endif

#define GEOTOAD "/usr/bin/geotoad"

#define COLOR_ERR     "red"
#define COLOR_OK      "darkgreen"
#define COLOR_SYSTEM  "darkblue"

#define BUFFER_SIZE  256

typedef enum {
  GT_STATE_ILLEGAL = 0,
  GT_STATE_STARTED,
  GT_STATE_PREMATURE_END,
  GT_STATE_SAVE_FOUND,
} gt_state_t;

typedef struct {
  appdata_t *appdata;
  
  GPtrArray *argv;
  gchar *info, *color;
  GMutex *update_mutex;
  GCond *update_cond;

  gt_state_t state;

  GtkWidget *dialog;

  long pid;

  struct log_s {
    GtkTextBuffer *buffer;
    GtkWidget *view;
  } log;

  GtkWidget *username, *password, *filename;
  GtkWidget *lat, *lon, *dst;
  
} gt_context_t;

static void arg_free(gpointer data, gpointer user_data) {
  if(data) g_free(data);
}

static void context_free(gt_context_t *context) {
  //  printf("freeing context\n");

  if(context->info) g_free(context->info);

  g_ptr_array_foreach(context->argv, arg_free, NULL);
  g_ptr_array_free (context->argv, TRUE);

  g_free(context);
}

static void appendf(struct log_s *log, char *colname, 
                    const char *fmt, ...) {
  va_list args;
  va_start( args, fmt );
  char *buf = g_strdup_vprintf(fmt, args);
  va_end( args );

  //  printf("append: %s", buf);

  GtkTextTag *tag = NULL;
  if(colname)
    tag = gtk_text_buffer_create_tag(log->buffer, NULL,
                                     "foreground", colname,
                                     NULL);
  
  GtkTextIter end;
  gtk_text_buffer_get_end_iter(log->buffer, &end);
  if(tag) 
    gtk_text_buffer_insert_with_tags(log->buffer, &end, buf, -1, tag, NULL);
  else    
    gtk_text_buffer_insert(log->buffer, &end, buf, -1);

  g_free(buf);

  gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(log->view),
                               &end, 0.0, TRUE, 0, 1.0); 
}

// This function receives a requst from a worker thread asking to
// update the gui with the required info.
gboolean cb_update_job(gt_context_t *context) {
  if (context->info) {

    /* check if client reports "saved to ..." */
    if(strstr(context->info, "Saved to "))
      context->state = GT_STATE_SAVE_FOUND;

    appendf(&context->log, context->color, context->info);
    
    g_free(context->info);
    context->info = NULL;
  }
  
  // Indicate that the update is done
  g_mutex_lock(context->update_mutex);
  g_cond_signal(context->update_cond);
  g_mutex_unlock(context->update_mutex);
  
  return FALSE;
}

// A helper function run in the job thread receiving the string that
// should be displayed in the textview.
void append_parentf(gt_context_t *context, char *colname, 
             const char *fmt, ...) {
  va_list args;
  va_start( args, fmt );
  context->info = g_strdup_vprintf(fmt, args);
  va_end( args );

  if(colname)
    context->color = colname;
  else
    context->color = NULL;

  // Lock mutex to make sure that we will receive the condition signal
  g_mutex_lock(context->update_mutex);

  g_idle_add((GSourceFunc)cb_update_job, context);
  
  // Wait for cb_update_job to tell me that the update is done
  g_cond_wait(context->update_cond, context->update_mutex);
  g_mutex_unlock(context->update_mutex);
}

/* custom version of popen to get access to the pid and to be able */
/* to slaughter the child process */
static FILE *gt_popen(gt_context_t *context, char **args, 
                      const char *type, long *tid) {
  int   p[2];
  FILE *fp;
  
  if (*type != 'r' && *type != 'w')
    return NULL;
  
  if (pipe(p) < 0)
    return NULL;
  
  if ((*tid = fork()) > 0) { /* then we are the parent */
    if (*type == 'r') {
      close(p[1]);
      fp = fdopen(p[0], type);
    } else {
      close(p[0]);
      fp = fdopen(p[1], type);
    }
    
    return fp;
  } else if (*tid == 0) {  /* we're the child */

    /* make our thread id the process group leader */
    setpgid(0, 0);
    
    if (*type == 'r') {
      fflush(stdout);
      fflush(stderr);
      close(1);
      if (dup(p[1]) < 0)
        perror("dup of write side of pipe failed");
      close(2);
      if (dup(p[1]) < 0)
        perror("dup of write side of pipe failed");
    } else {
      close(0);
      if (dup(p[0]) < 0)
        perror("dup of read side of pipe failed");
    }
    
    close(p[0]); /* close since we dup()'ed what we needed */
    close(p[1]);
    
    execve(args[0], args, NULL);
    
    /* this printf will actually be redirected through the pipe */
    printf("Error: Failed to execute!\n");
  } else {         /* we're having major problems... */
    close(p[0]);
    close(p[1]);

    /* this printf will actually be redirected through the pipe */
    printf("Error: Failed to fork!\n");
  }
  
  return NULL;
}

// The thread entry point. It will do the job, send the data to the
// GUI and self destruct when it is done.
static gpointer thread_worker(gt_context_t *context)
{
  FILE *fh;
  GIOStatus status;
  GError *error = NULL;
  gsize length;
  gsize terminator_pos;
  gchar *str_return;

  fh = gt_popen(context, (char**)(context->argv->pdata),"r", &context->pid);
  if(!fh) {
    append_parentf(context, COLOR_ERR, _("Failed to run GeoToad"));
    return NULL;
  }

  /* switch to line buffered mode */
  if(setvbuf(fh, NULL, _IOLBF, 0))
    perror("setvbuf(_IOLBF)");
  
  GIOChannel *gh = g_io_channel_unix_new(fileno(fh));

  while( (status = g_io_channel_read_line(gh,
                                          &str_return,
                                          &length,
                                          &terminator_pos,
                                          &error)) == G_IO_STATUS_NORMAL) {
    char *color = NULL;
    if(strstr(str_return, "Saved to "))  color = COLOR_OK;
    if(strcasestr(str_return, "error"))  color = COLOR_ERR;
    
    append_parentf(context, color, str_return);
    g_free(str_return);
  }
  
  g_io_channel_unref(gh);
  pclose(fh);
  append_parentf(context, COLOR_SYSTEM, "Job done!");
  
  g_thread_exit(NULL);
  context_free(context);
  
  return NULL;
}


static void arg_dsp(gpointer data, gpointer user_data) {
  gt_context_t *context = (gt_context_t*)user_data;
  
  if(data)
    appendf(&context->log, COLOR_SYSTEM, "%s\n", data);
}

static void run(gt_context_t *context) {
  GError *error = NULL;
  char str[8];

  /* build list of arguments to call geotoad */
  context->argv = g_ptr_array_new();
  g_ptr_array_add (context->argv, g_strdup_printf(GEOTOAD));
  g_ascii_dtostr(str, sizeof(str), context->appdata->gt.distance);
  g_ptr_array_add (context->argv, g_strdup_printf("--distanceMax=%s", str));
  g_ptr_array_add (context->argv, g_strdup_printf("--output=%s", context->appdata->gt.filename));
  g_ptr_array_add (context->argv, g_strdup_printf("--password=%s", context->appdata->gt.password));
  g_ptr_array_add (context->argv, g_strdup_printf("--queryType=coord"));
  g_ptr_array_add (context->argv, g_strdup_printf("--user=%s", context->appdata->username));

  /* check if we need to add proxy config */
  char *proxy = NULL;
  if(context->appdata->proxy && context->appdata->proxy->host) {
    if(context->appdata->proxy->use_authentication &&
       context->appdata->proxy->authentication_user &&
       context->appdata->proxy->authentication_password)
      proxy = g_strdup_printf("--proxy=http://%s:%s@%s:%d", 
                              context->appdata->proxy->authentication_user,
                              context->appdata->proxy->authentication_password,
                              context->appdata->proxy->host,
                              context->appdata->proxy->port);
    else
      proxy = g_strdup_printf("--proxy=http://%s:%d", 
                              context->appdata->proxy->host,
                              context->appdata->proxy->port);
    
    g_ptr_array_add (context->argv, proxy);
  }

  /* convert coordinates into simple ascii format */
  char n = (context->appdata->gt.lat >= 0)?'N':'S';
  char e = (context->appdata->gt.lon >= 0)?'E':'W';
  float lat = fabs(context->appdata->gt.lat);
  float lon = fabs(context->appdata->gt.lon);
  float lat_mint, lat_int, lat_frac = modff(lat, &lat_int);
  float lon_mint, lon_int, lon_frac = modff(lon, &lon_int);
  lat_frac = modff(lat_frac*60.0, &lat_mint);
  lon_frac = modff(lon_frac*60.0, &lon_mint);

  g_ptr_array_add (context->argv, 
           g_strdup_printf("%c%02u %02u.%03u %c%03u %02u.%03u",
           n, (int)lat_int, (int)lat_mint, (int)(lat_frac*1000.0+0.5),
           e, (int)lon_int, (int)lon_mint, (int)(lon_frac*1000.0+0.5)));

  //  g_ptr_array_add (context->argv, g_strdup_printf("2>&1"));
  g_ptr_array_add (context->argv, NULL);

  /* show all entries */
  g_ptr_array_foreach(context->argv, arg_dsp, context);

  g_thread_create((GThreadFunc)thread_worker, context, FALSE, &error);
  if (error) {
    appendf(&context->log, COLOR_ERR, "Error: %s\n", error->message);
    g_error_free(error);
  }
}
        
/* show text window and display output of running geotoad */
static void gui_run(gt_context_t *context) {
  GtkWidget *dialog = gtk_dialog_new_with_buttons(_("GeoToad - Run"),
                          GTK_WINDOW(context->appdata->window),
                          GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                          GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
                          NULL);

  gtk_window_set_default_size(GTK_WINDOW(dialog), 640, 480);

#ifndef USE_PANNABLE_AREA
  GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), 
                                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#else
  GtkWidget *pannable_area = hildon_pannable_area_new();
#endif
  
  context->log.buffer = gtk_text_buffer_new(NULL);

#ifndef USE_HILDON_TEXT_VIEW
  context->log.view = gtk_text_view_new_with_buffer(context->log.buffer);
#else
  context->log.view = hildon_text_view_new();
  hildon_text_view_set_buffer(HILDON_TEXT_VIEW(context->log.view), 
                              context->log.buffer);
#endif

#ifndef USE_PANNABLE_AREA
  gtk_container_add(GTK_CONTAINER(scrolled_window), context->log.view);
  gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scrolled_window),
                                       GTK_SHADOW_IN);

  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), 
                     scrolled_window, TRUE, TRUE, 0);
#else
  gtk_container_add(GTK_CONTAINER(pannable_area), context->log.view);
  gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), 
                     pannable_area, TRUE, TRUE, 0);
#endif

  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);

  gtk_widget_show_all(dialog);

  appendf(&context->log, COLOR_SYSTEM, "Running GeoToad\n");
  run(context);

  gtk_dialog_run(GTK_DIALOG(dialog));

  gtk_widget_destroy(dialog);

  errorf("Fertig!\n");

}

static void on_browse(GtkWidget *widget, gpointer data) {
  gt_context_t *context = (gt_context_t*)data;

  printf("Browse %p\n", context->dialog);

#ifdef USE_MAEMO
  GtkWidget *dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(context->dialog), 
                                          GTK_FILE_CHOOSER_ACTION_SAVE);
#else
  GtkWidget *dialog = gtk_file_chooser_dialog_new(_("Save GPX file"),
                                       GTK_WINDOW(context->dialog),
                                       GTK_FILE_CHOOSER_ACTION_SAVE,
                                       GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                       GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                       NULL);
#endif

  printf("set filename <%s>\n", context->appdata->gt.filename);

  if(!g_file_test(context->appdata->gt.filename, G_FILE_TEST_EXISTS)) {
    char *last_sep = strrchr(context->appdata->gt.filename, '/');
    if(last_sep) {
      *last_sep = 0;  // seperate path from file 

      /* the user just created a new document */
      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), 
                                          context->appdata->gt.filename);
      gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), last_sep+1);

      /* restore full filename */
      *last_sep = '/';
    }
  } else 
    gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), 
                                  context->appdata->gt.filename);

  if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {
    gchar *name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
    gtk_label_set_text(GTK_LABEL(context->filename), name);
  }
  
  gtk_widget_destroy (dialog);
}

static gboolean gui_setup(gt_context_t *context) {
  appdata_t *appdata = context->appdata;
  gboolean ok = FALSE;

  /* if no filename has been setup yet, create one */
  if(!appdata->gt.filename && appdata->path) {
    printf("creating path\n");
    appdata->gt.filename = 
      g_strdup_printf("%s/gtoad.gpx", appdata->path);
  }

  context->dialog = gtk_dialog_new_with_buttons(_("GeoToad - Setup"),
                        GTK_WINDOW(appdata->window),
                        GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                        GTK_STOCK_OK,     GTK_RESPONSE_OK,
                        NULL);

  /* ------------------- Coordinates ------------------------- */
  GtkWidget *hbox = gtk_hbox_new(FALSE, 0);

  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Position:")));
  gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Distance:")));
  gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);

  /* setup default positions */
  pos_t *refpos = get_pos(appdata);
  if((isnan(appdata->gt.lat) || isnan(appdata->gt.lat)) && refpos) {
    appdata->gt.lat = refpos->lat;
    appdata->gt.lon = refpos->lon;
  }

  vbox = gtk_vbox_new(FALSE, 0);
  GtkWidget *ihbox = gtk_hbox_new(FALSE, 0);
  context->lat = lat_entry_new(appdata->gt.lat);
  gtk_box_pack_start_defaults(GTK_BOX(ihbox), context->lat);
  context->lon = lon_entry_new(appdata->gt.lon);
  gtk_box_pack_start_defaults(GTK_BOX(ihbox), context->lon);
  gtk_box_pack_start_defaults(GTK_BOX(vbox), ihbox);
  float dst = appdata->gt.distance;  // distance is given in kilometers
  if(appdata->imperial) dst /= 1.609344;
  context->dst = dist_entry_new(dst, appdata->imperial);
  gtk_box_pack_start_defaults(GTK_BOX(vbox), context->dst);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), vbox);

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

  /* ------------------- file name ------------------------- */
  hbox = gtk_hbox_new(FALSE, 0);

  context->filename = gtk_label_new(appdata->gt.filename);
  gtk_misc_set_alignment(GTK_MISC(context->filename), 0.f, 0.5f);
  gtk_label_set_ellipsize(GTK_LABEL(context->filename), PANGO_ELLIPSIZE_MIDDLE);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), context->filename);

  GtkWidget *button = gtk_button_new_with_label(_("Browse"));
#if defined(USE_MAEMO) && (MAEMO_VERSION_MAJOR == 5)
  hildon_gtk_widget_set_theme_size(button, 
           (HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH));
#endif  
  gtk_signal_connect(GTK_OBJECT(button), "clicked",
                     GTK_SIGNAL_FUNC(on_browse), context);
  gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);

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


  /* ------------------- Username/Password ------------------------- */
  hbox = gtk_hbox_new(FALSE, 0);
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Username:")));
  gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Password:")));
  gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
  
  vbox = gtk_vbox_new(FALSE, 0);
#ifndef FREMANTLE
  context->username = gtk_entry_new();
  context->password = gtk_entry_new();
#else
  context->username = hildon_entry_new(HILDON_SIZE_AUTO);
  hildon_gtk_entry_set_input_mode(GTK_ENTRY(context->username),
                                  HILDON_GTK_INPUT_MODE_FULL);
  context->password = hildon_entry_new(HILDON_SIZE_AUTO);
  hildon_gtk_entry_set_input_mode(GTK_ENTRY(context->password),
                                  HILDON_GTK_INPUT_MODE_FULL);
#endif
  gtk_entry_set_visibility(GTK_ENTRY(context->password), FALSE);

  /* set saved defaults */
  if(appdata->username)
    gtk_entry_set_text(GTK_ENTRY(context->username), 
                       appdata->username);

  if(appdata->gt.password)
    gtk_entry_set_text(GTK_ENTRY(context->password), 
                       appdata->gt.password);

  gtk_box_pack_start_defaults(GTK_BOX(vbox), context->username);
  gtk_box_pack_start_defaults(GTK_BOX(vbox), context->password);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), vbox);

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

  gtk_dialog_set_default_response(GTK_DIALOG(context->dialog), GTK_RESPONSE_OK);

  gtk_widget_show_all(context->dialog);

  if(gtk_dialog_run(GTK_DIALOG(context->dialog)) == GTK_RESPONSE_OK) {

    /* parse coordinates */
    appdata->gt.lat = lat_get(context->lat);
    appdata->gt.lon = lon_get(context->lon);

    /* save values */
    if(appdata->username) g_free(appdata->username);
    appdata->username = 
      g_strdup(gtk_entry_get_text(GTK_ENTRY(context->username)));
                                             
    if(appdata->gt.password) g_free(appdata->gt.password);
    appdata->gt.password = 
      g_strdup(gtk_entry_get_text(GTK_ENTRY(context->password)));

    if(appdata->gt.filename) g_free(appdata->gt.filename);
    appdata->gt.filename = 
      g_strdup(gtk_label_get_text(GTK_LABEL(context->filename)));

    /* get distance in kilometers */
    appdata->gt.distance = dist_get(context->dst, FALSE);


    /* check for valid entries */
    if(isnan(appdata->gt.lat) || isnan(appdata->gt.lon) ||
       isnan(appdata->gt.distance) || !appdata->gt.filename ||
       !appdata->username || !appdata->gt.password) 
      errorf(_("GeoToad setup not complete"));
    else
      ok = TRUE;
  }

  gtk_widget_destroy(context->dialog);

  return ok;
}

void geotoad(appdata_t *appdata) {
  if(!geotoad_available()) {
    errorf(_("GeoToad is not installed on this device.\n"
             "You need to install it in order to be able to use it."));
    return;
  }

  gt_context_t *context = g_new0(gt_context_t, 1);
  context->appdata = appdata;

  context->update_mutex = g_mutex_new();
  context->update_cond = g_cond_new();
  //  context->mutex_to_run = mutex_to_run;

  printf("geoToad\n");

  if(gui_setup(context))
    gui_run(context);
}

gboolean geotoad_available(void) {
  /* before doing anything make sure geotoad is installed */
  return g_file_test(GEOTOAD, G_FILE_TEST_IS_EXECUTABLE);
}


1	harbaum	193	/*
2			* Copyright (C) 2009 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	harbaum	206	#define __USE_GNU
23			#include <string.h>
24
25	harbaum	193	#include <fcntl.h>
26			#include <sys/types.h>
27			#include <sys/wait.h>
28			#include <errno.h>
29	harbaum	198	#include <math.h>
30	harbaum	193
31	harbaum	198	#if defined(USE_MAEMO) && (MAEMO_VERSION_MAJOR >= 5)
32			#include <hildon/hildon-entry.h>
33			#endif
34
35	harbaum	196	#define GEOTOAD "/usr/bin/geotoad"
36
37	harbaum	195	#define COLOR_ERR "red"
38			#define COLOR_OK "darkgreen"
39			#define COLOR_SYSTEM "darkblue"
40	harbaum	194
41	harbaum	195	#define BUFFER_SIZE 256
42	harbaum	193
43	harbaum	206	typedef enum {
44			GT_STATE_ILLEGAL = 0,
45			GT_STATE_STARTED,
46			GT_STATE_PREMATURE_END,
47			GT_STATE_SAVE_FOUND,
48			} gt_state_t;
49
50	harbaum	193	typedef struct {
51	harbaum	194	appdata_t *appdata;
52	harbaum	206
53			GPtrArray *argv;
54	harbaum	207	gchar info, color;
55	harbaum	206	GMutex *update_mutex;
56			GCond *update_cond;
57	harbaum	194
58	harbaum	206	gt_state_t state;
59
60	harbaum	198	GtkWidget *dialog;
61
62	harbaum	206	long pid;
63	harbaum	193
64	harbaum	194	struct log_s {
65			GtkTextBuffer *buffer;
66			GtkWidget *view;
67			} log;
68	harbaum	196
69	harbaum	198	GtkWidget username, password, *filename;
70			GtkWidget lat, lon, *dst;
71	harbaum	194
72	harbaum	193	} gt_context_t;
73
74	harbaum	206	static void arg_free(gpointer data, gpointer user_data) {
75			if(data) g_free(data);
76			}
77
78			static void context_free(gt_context_t *context) {
79	harbaum	207	// printf("freeing context\n");
80	harbaum	206
81			if(context->info) g_free(context->info);
82
83			g_ptr_array_foreach(context->argv, arg_free, NULL);
84			g_ptr_array_free (context->argv, TRUE);
85
86			g_free(context);
87			}
88
89	harbaum	194	static void appendf(struct log_s log, char colname,
90			const char *fmt, ...) {
91			va_list args;
92			va_start( args, fmt );
93			char *buf = g_strdup_vprintf(fmt, args);
94			va_end( args );
95
96	harbaum	207	// printf("append: %s", buf);
97	harbaum	195
98	harbaum	194	GtkTextTag *tag = NULL;
99			if(colname)
100			tag = gtk_text_buffer_create_tag(log->buffer, NULL,
101			"foreground", colname,
102			NULL);
103
104			GtkTextIter end;
105			gtk_text_buffer_get_end_iter(log->buffer, &end);
106			if(tag)
107			gtk_text_buffer_insert_with_tags(log->buffer, &end, buf, -1, tag, NULL);
108			else
109			gtk_text_buffer_insert(log->buffer, &end, buf, -1);
110
111			g_free(buf);
112
113			gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(log->view),
114	harbaum	206	&end, 0.0, TRUE, 0, 1.0);
115	harbaum	194	}
116
117	harbaum	206	// This function receives a requst from a worker thread asking to
118			// update the gui with the required info.
119			gboolean cb_update_job(gt_context_t *context) {
120			if (context->info) {
121	harbaum	207
122			/* check if client reports "saved to ..." */
123			if(strstr(context->info, "Saved to "))
124	harbaum	206	context->state = GT_STATE_SAVE_FOUND;
125	harbaum	193
126	harbaum	207	appendf(&context->log, context->color, context->info);
127	harbaum	206
128			g_free(context->info);
129			context->info = NULL;
130			}
131
132			// Indicate that the update is done
133			g_mutex_lock(context->update_mutex);
134			g_cond_signal(context->update_cond);
135			g_mutex_unlock(context->update_mutex);
136
137			return FALSE;
138			}
139	harbaum	193
140	harbaum	206	// A helper function run in the job thread receiving the string that
141			// should be displayed in the textview.
142	harbaum	207	void append_parentf(gt_context_t context, char colname,
143			const char *fmt, ...) {
144			va_list args;
145			va_start( args, fmt );
146			context->info = g_strdup_vprintf(fmt, args);
147			va_end( args );
148
149			if(colname)
150			context->color = colname;
151			else
152			context->color = NULL;
153
154	harbaum	206	// Lock mutex to make sure that we will receive the condition signal
155			g_mutex_lock(context->update_mutex);
156	harbaum	207
157	harbaum	206	g_idle_add((GSourceFunc)cb_update_job, context);
158
159			// Wait for cb_update_job to tell me that the update is done
160	harbaum	207	g_cond_wait(context->update_cond, context->update_mutex);
161	harbaum	206	g_mutex_unlock(context->update_mutex);
162	harbaum	193	}
163
164	harbaum	206	/* custom version of popen to get access to the pid and to be able */
165			/* to slaughter the child process */
166	harbaum	207	static FILE gt_popen(gt_context_t context, char **args,
167			const char type, long tid) {
168	harbaum	206	int p[2];
169			FILE *fp;
170
171			if (type != 'r' && type != 'w')
172			return NULL;
173
174			if (pipe(p) < 0)
175			return NULL;
176
177			if ((tid = fork()) > 0) { / then we are the parent */
178			if (*type == 'r') {
179			close(p[1]);
180			fp = fdopen(p[0], type);
181			} else {
182			close(p[0]);
183			fp = fdopen(p[1], type);
184			}
185
186			return fp;
187			} else if (tid == 0) { / we're the child */
188	harbaum	193
189	harbaum	206	/* make our thread id the process group leader */
190			setpgid(0, 0);
191	harbaum	193
192	harbaum	206	if (*type == 'r') {
193			fflush(stdout);
194			fflush(stderr);
195			close(1);
196			if (dup(p[1]) < 0)
197			perror("dup of write side of pipe failed");
198			close(2);
199			if (dup(p[1]) < 0)
200			perror("dup of write side of pipe failed");
201			} else {
202			close(0);
203			if (dup(p[0]) < 0)
204			perror("dup of read side of pipe failed");
205	harbaum	193	}
206	harbaum	206
207			close(p[0]); /* close since we dup()'ed what we needed */
208			close(p[1]);
209
210			execve(args[0], args, NULL);
211
212	harbaum	207	/* this printf will actually be redirected through the pipe */
213			printf("Error: Failed to execute!\n");
214	harbaum	206	} else { /* we're having major problems... */
215			close(p[0]);
216			close(p[1]);
217	harbaum	207
218			/* this printf will actually be redirected through the pipe */
219			printf("Error: Failed to fork!\n");
220	harbaum	206	}
221
222			return NULL;
223			}
224	harbaum	193
225	harbaum	206	// The thread entry point. It will do the job, send the data to the
226			// GUI and self destruct when it is done.
227			static gpointer thread_worker(gt_context_t *context)
228			{
229			FILE *fh;
230			GIOStatus status;
231			GError *error = NULL;
232			gsize length;
233			gsize terminator_pos;
234			gchar *str_return;
235	harbaum	193
236	harbaum	207	fh = gt_popen(context, (char**)(context->argv->pdata),"r", &context->pid);
237	harbaum	206	if(!fh) {
238	harbaum	207	append_parentf(context, COLOR_ERR, _("Failed to run GeoToad"));
239	harbaum	206	return NULL;
240	harbaum	193	}
241
242	harbaum	206	/* switch to line buffered mode */
243			if(setvbuf(fh, NULL, _IOLBF, 0))
244			perror("setvbuf(_IOLBF)");
245
246			GIOChannel *gh = g_io_channel_unix_new(fileno(fh));
247	harbaum	193
248	harbaum	206	while( (status = g_io_channel_read_line(gh,
249			&str_return,
250			&length,
251			&terminator_pos,
252			&error)) == G_IO_STATUS_NORMAL) {
253	harbaum	207	char *color = NULL;
254			if(strstr(str_return, "Saved to ")) color = COLOR_OK;
255			if(strcasestr(str_return, "error")) color = COLOR_ERR;
256
257			append_parentf(context, color, str_return);
258	harbaum	206	g_free(str_return);
259			}
260
261			g_io_channel_unref(gh);
262			pclose(fh);
263	harbaum	207	append_parentf(context, COLOR_SYSTEM, "Job done!");
264	harbaum	206
265			g_thread_exit(NULL);
266			context_free(context);
267
268			return NULL;
269	harbaum	200	}
270
271	harbaum	206
272	harbaum	200	static void arg_dsp(gpointer data, gpointer user_data) {
273			gt_context_t context = (gt_context_t)user_data;
274
275			if(data)
276			appendf(&context->log, COLOR_SYSTEM, "%s\n", data);
277			}
278
279	harbaum	194	static void run(gt_context_t *context) {
280	harbaum	206	GError *error = NULL;
281	harbaum	200	char str[8];
282
283	harbaum	194	/* build list of arguments to call geotoad */
284	harbaum	206	context->argv = g_ptr_array_new();
285	harbaum	207	g_ptr_array_add (context->argv, g_strdup_printf(GEOTOAD));
286	harbaum	200	g_ascii_dtostr(str, sizeof(str), context->appdata->gt.distance);
287	harbaum	206	g_ptr_array_add (context->argv, g_strdup_printf("--distanceMax=%s", str));
288			g_ptr_array_add (context->argv, g_strdup_printf("--output=%s", context->appdata->gt.filename));
289			g_ptr_array_add (context->argv, g_strdup_printf("--password=%s", context->appdata->gt.password));
290			g_ptr_array_add (context->argv, g_strdup_printf("--queryType=coord"));
291			g_ptr_array_add (context->argv, g_strdup_printf("--user=%s", context->appdata->username));
292	harbaum	194
293			/* check if we need to add proxy config */
294			char *proxy = NULL;
295			if(context->appdata->proxy && context->appdata->proxy->host) {
296			if(context->appdata->proxy->use_authentication &&
297			context->appdata->proxy->authentication_user &&
298			context->appdata->proxy->authentication_password)
299			proxy = g_strdup_printf("--proxy=http://%s:%s@%s:%d",
300	harbaum	206	context->appdata->proxy->authentication_user,
301			context->appdata->proxy->authentication_password,
302			context->appdata->proxy->host,
303			context->appdata->proxy->port);
304	harbaum	194	else
305			proxy = g_strdup_printf("--proxy=http://%s:%d",
306	harbaum	206	context->appdata->proxy->host,
307			context->appdata->proxy->port);
308	harbaum	194
309	harbaum	206	g_ptr_array_add (context->argv, proxy);
310	harbaum	194	}
311
312	harbaum	206	/* convert coordinates into simple ascii format */
313			char n = (context->appdata->gt.lat >= 0)?'N':'S';
314			char e = (context->appdata->gt.lon >= 0)?'E':'W';
315			float lat = fabs(context->appdata->gt.lat);
316			float lon = fabs(context->appdata->gt.lon);
317			float lat_mint, lat_int, lat_frac = modff(lat, &lat_int);
318			float lon_mint, lon_int, lon_frac = modff(lon, &lon_int);
319			lat_frac = modff(lat_frac*60.0, &lat_mint);
320			lon_frac = modff(lon_frac*60.0, &lon_mint);
321	harbaum	194
322	harbaum	206	g_ptr_array_add (context->argv,
323			g_strdup_printf("%c%02u %02u.%03u %c%03u %02u.%03u",
324			n, (int)lat_int, (int)lat_mint, (int)(lat_frac*1000.0+0.5),
325			e, (int)lon_int, (int)lon_mint, (int)(lon_frac*1000.0+0.5)));
326
327			// g_ptr_array_add (context->argv, g_strdup_printf("2>&1"));
328			g_ptr_array_add (context->argv, NULL);
329
330	harbaum	200	/* show all entries */
331	harbaum	206	g_ptr_array_foreach(context->argv, arg_dsp, context);
332	harbaum	200
333	harbaum	206	g_thread_create((GThreadFunc)thread_worker, context, FALSE, &error);
334			if (error) {
335			appendf(&context->log, COLOR_ERR, "Error: %s\n", error->message);
336	harbaum	193	g_error_free(error);
337			}
338			}
339	harbaum	194
340	harbaum	196	/* show text window and display output of running geotoad */
341			static void gui_run(gt_context_t *context) {
342			GtkWidget *dialog = gtk_dialog_new_with_buttons(_("GeoToad - Run"),
343			GTK_WINDOW(context->appdata->window),
344	harbaum	194	GTK_DIALOG_MODAL \| GTK_DIALOG_DESTROY_WITH_PARENT,
345			GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
346			NULL);
347
348			gtk_window_set_default_size(GTK_WINDOW(dialog), 640, 480);
349
350			#ifndef USE_PANNABLE_AREA
351			GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
352			gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
353			GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
354			#else
355			GtkWidget *pannable_area = hildon_pannable_area_new();
356			#endif
357
358			context->log.buffer = gtk_text_buffer_new(NULL);
359
360			#ifndef USE_HILDON_TEXT_VIEW
361			context->log.view = gtk_text_view_new_with_buffer(context->log.buffer);
362			#else
363			context->log.view = hildon_text_view_new();
364			hildon_text_view_set_buffer(HILDON_TEXT_VIEW(context->log.view),
365			context->log.buffer);
366			#endif
367
368			#ifndef USE_PANNABLE_AREA
369			gtk_container_add(GTK_CONTAINER(scrolled_window), context->log.view);
370			gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scrolled_window),
371			GTK_SHADOW_IN);
372
373			gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
374			scrolled_window, TRUE, TRUE, 0);
375			#else
376			gtk_container_add(GTK_CONTAINER(pannable_area), context->log.view);
377			gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
378			pannable_area, TRUE, TRUE, 0);
379			#endif
380
381			gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
382
383			gtk_widget_show_all(dialog);
384
385	harbaum	195	appendf(&context->log, COLOR_SYSTEM, "Running GeoToad\n");
386	harbaum	194	run(context);
387
388			gtk_dialog_run(GTK_DIALOG(dialog));
389
390			gtk_widget_destroy(dialog);
391	harbaum	206
392			errorf("Fertig!\n");
393
394	harbaum	194	}
395	harbaum	196
396	harbaum	198	static void on_browse(GtkWidget *widget, gpointer data) {
397			gt_context_t context = (gt_context_t)data;
398
399			printf("Browse %p\n", context->dialog);
400
401			#ifdef USE_MAEMO
402			GtkWidget *dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(context->dialog),
403			GTK_FILE_CHOOSER_ACTION_SAVE);
404			#else
405			GtkWidget *dialog = gtk_file_chooser_dialog_new(_("Save GPX file"),
406			GTK_WINDOW(context->dialog),
407			GTK_FILE_CHOOSER_ACTION_SAVE,
408			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
409			GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
410			NULL);
411			#endif
412
413			printf("set filename <%s>\n", context->appdata->gt.filename);
414
415			if(!g_file_test(context->appdata->gt.filename, G_FILE_TEST_EXISTS)) {
416			char *last_sep = strrchr(context->appdata->gt.filename, '/');
417			if(last_sep) {
418			*last_sep = 0; // seperate path from file
419
420			/* the user just created a new document */
421			gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
422			context->appdata->gt.filename);
423			gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), last_sep+1);
424
425			/* restore full filename */
426			*last_sep = '/';
427			}
428			} else
429			gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
430			context->appdata->gt.filename);
431
432			if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {
433			gchar *name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
434			gtk_label_set_text(GTK_LABEL(context->filename), name);
435			}
436
437			gtk_widget_destroy (dialog);
438			}
439
440	harbaum	196	static gboolean gui_setup(gt_context_t *context) {
441	harbaum	198	appdata_t *appdata = context->appdata;
442	harbaum	196	gboolean ok = FALSE;
443
444	harbaum	198	/* if no filename has been setup yet, create one */
445			if(!appdata->gt.filename && appdata->path) {
446			printf("creating path\n");
447			appdata->gt.filename =
448			g_strdup_printf("%s/gtoad.gpx", appdata->path);
449			}
450	harbaum	196
451	harbaum	198	context->dialog = gtk_dialog_new_with_buttons(_("GeoToad - Setup"),
452			GTK_WINDOW(appdata->window),
453			GTK_DIALOG_MODAL \| GTK_DIALOG_DESTROY_WITH_PARENT,
454			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
455			GTK_STOCK_OK, GTK_RESPONSE_OK,
456			NULL);
457
458			/* ------------------- Coordinates ------------------------- */
459	harbaum	196	GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
460	harbaum	198
461	harbaum	196	GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
462	harbaum	199	gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Position:")));
463	harbaum	198	gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Distance:")));
464			gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
465
466			/* setup default positions */
467			pos_t *refpos = get_pos(appdata);
468			if((isnan(appdata->gt.lat) \|\| isnan(appdata->gt.lat)) && refpos) {
469			appdata->gt.lat = refpos->lat;
470			appdata->gt.lon = refpos->lon;
471			}
472
473			vbox = gtk_vbox_new(FALSE, 0);
474	harbaum	199	GtkWidget *ihbox = gtk_hbox_new(FALSE, 0);
475	harbaum	198	context->lat = lat_entry_new(appdata->gt.lat);
476	harbaum	199	gtk_box_pack_start_defaults(GTK_BOX(ihbox), context->lat);
477			context->lon = lon_entry_new(appdata->gt.lon);
478			gtk_box_pack_start_defaults(GTK_BOX(ihbox), context->lon);
479			gtk_box_pack_start_defaults(GTK_BOX(vbox), ihbox);
480	harbaum	200	float dst = appdata->gt.distance; // distance is given in kilometers
481			if(appdata->imperial) dst /= 1.609344;
482			context->dst = dist_entry_new(dst, appdata->imperial);
483	harbaum	198	gtk_box_pack_start_defaults(GTK_BOX(vbox), context->dst);
484	harbaum	196	gtk_box_pack_start_defaults(GTK_BOX(hbox), vbox);
485	harbaum	198
486			gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(context->dialog)->vbox), hbox);
487
488			/* ------------------- file name ------------------------- */
489			hbox = gtk_hbox_new(FALSE, 0);
490
491			context->filename = gtk_label_new(appdata->gt.filename);
492			gtk_misc_set_alignment(GTK_MISC(context->filename), 0.f, 0.5f);
493			gtk_label_set_ellipsize(GTK_LABEL(context->filename), PANGO_ELLIPSIZE_MIDDLE);
494			gtk_box_pack_start_defaults(GTK_BOX(hbox), context->filename);
495
496			GtkWidget *button = gtk_button_new_with_label(_("Browse"));
497	harbaum	199	#if defined(USE_MAEMO) && (MAEMO_VERSION_MAJOR == 5)
498			hildon_gtk_widget_set_theme_size(button,
499			(HILDON_SIZE_FINGER_HEIGHT \| HILDON_SIZE_AUTO_WIDTH));
500			#endif
501	harbaum	198	gtk_signal_connect(GTK_OBJECT(button), "clicked",
502			GTK_SIGNAL_FUNC(on_browse), context);
503			gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
504
505			gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(context->dialog)->vbox), hbox);
506
507
508			/* ------------------- Username/Password ------------------------- */
509			hbox = gtk_hbox_new(FALSE, 0);
510			vbox = gtk_vbox_new(FALSE, 0);
511			gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Username:")));
512			gtk_box_pack_start_defaults(GTK_BOX(vbox), left_label_new(_("Password:")));
513			gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
514	harbaum	196
515			vbox = gtk_vbox_new(FALSE, 0);
516	harbaum	206	#ifndef FREMANTLE
517	harbaum	196	context->username = gtk_entry_new();
518			context->password = gtk_entry_new();
519			#else
520			context->username = hildon_entry_new(HILDON_SIZE_AUTO);
521			hildon_gtk_entry_set_input_mode(GTK_ENTRY(context->username),
522			HILDON_GTK_INPUT_MODE_FULL);
523			context->password = hildon_entry_new(HILDON_SIZE_AUTO);
524			hildon_gtk_entry_set_input_mode(GTK_ENTRY(context->password),
525			HILDON_GTK_INPUT_MODE_FULL);
526			#endif
527			gtk_entry_set_visibility(GTK_ENTRY(context->password), FALSE);
528
529			/* set saved defaults */
530	harbaum	204	if(appdata->username)
531	harbaum	196	gtk_entry_set_text(GTK_ENTRY(context->username),
532	harbaum	204	appdata->username);
533	harbaum	196
534	harbaum	198	if(appdata->gt.password)
535	harbaum	196	gtk_entry_set_text(GTK_ENTRY(context->password),
536	harbaum	198	appdata->gt.password);
537	harbaum	196
538			gtk_box_pack_start_defaults(GTK_BOX(vbox), context->username);
539			gtk_box_pack_start_defaults(GTK_BOX(vbox), context->password);
540			gtk_box_pack_start_defaults(GTK_BOX(hbox), vbox);
541
542	harbaum	198	gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(context->dialog)->vbox), hbox);
543	harbaum	196
544	harbaum	198	gtk_dialog_set_default_response(GTK_DIALOG(context->dialog), GTK_RESPONSE_OK);
545	harbaum	196
546	harbaum	198	gtk_widget_show_all(context->dialog);
547	harbaum	196
548	harbaum	198	if(gtk_dialog_run(GTK_DIALOG(context->dialog)) == GTK_RESPONSE_OK) {
549	harbaum	196
550	harbaum	200	/* parse coordinates */
551	harbaum	206	appdata->gt.lat = lat_get(context->lat);
552			appdata->gt.lon = lon_get(context->lon);
553	harbaum	200
554	harbaum	196	/* save values */
555	harbaum	204	if(appdata->username) g_free(appdata->username);
556			appdata->username =
557	harbaum	196	g_strdup(gtk_entry_get_text(GTK_ENTRY(context->username)));
558
559	harbaum	198	if(appdata->gt.password) g_free(appdata->gt.password);
560			appdata->gt.password =
561	harbaum	196	g_strdup(gtk_entry_get_text(GTK_ENTRY(context->password)));
562
563	harbaum	198	if(appdata->gt.filename) g_free(appdata->gt.filename);
564			appdata->gt.filename =
565			g_strdup(gtk_label_get_text(GTK_LABEL(context->filename)));
566
567	harbaum	200	/* get distance in kilometers */
568			appdata->gt.distance = dist_get(context->dst, FALSE);
569
570	harbaum	206
571			/* check for valid entries */
572			if(isnan(appdata->gt.lat) \|\| isnan(appdata->gt.lon) \|\|
573			isnan(appdata->gt.distance) \|\| !appdata->gt.filename \|\|
574			!appdata->username \|\| !appdata->gt.password)
575			errorf(_("GeoToad setup not complete"));
576			else
577			ok = TRUE;
578	harbaum	196	}
579
580	harbaum	198	gtk_widget_destroy(context->dialog);
581	harbaum	196
582			return ok;
583			}
584
585			void geotoad(appdata_t *appdata) {
586			if(!geotoad_available()) {
587			errorf(_("GeoToad is not installed on this device.\n"
588			"You need to install it in order to be able to use it."));
589			return;
590			}
591
592			gt_context_t *context = g_new0(gt_context_t, 1);
593			context->appdata = appdata;
594
595	harbaum	206	context->update_mutex = g_mutex_new();
596			context->update_cond = g_cond_new();
597			// context->mutex_to_run = mutex_to_run;
598
599	harbaum	196	printf("geoToad\n");
600
601			if(gui_setup(context))
602			gui_run(context);
603			}
604
605			gboolean geotoad_available(void) {
606			/* before doing anything make sure geotoad is installed */
607			return g_file_test(GEOTOAD, G_FILE_TEST_IS_EXECUTABLE);
608			}
609
610