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

/*
 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
 *
 * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <string.h>
#include <glib/gprintf.h>
#include <glib/gi18n.h>

#include "viking.h"
#include "babel.h"
#include "gpx.h"
#include "acquire.h"

/************************ FILTER LIST *******************/
// extern VikDataSourceInterface vik_datasource_gps_interface;

/*** Input is TRWLayer ***/
extern VikDataSourceInterface vik_datasource_bfilter_simplify_interface;
extern VikDataSourceInterface vik_datasource_bfilter_dup_interface;

/*** Input is a track and a TRWLayer ***/
extern VikDataSourceInterface vik_datasource_bfilter_polygon_interface;
extern VikDataSourceInterface vik_datasource_bfilter_exclude_polygon_interface;

/*** Input is a track ***/

const VikDataSourceInterface *filters[] = {
  &vik_datasource_bfilter_simplify_interface,
  &vik_datasource_bfilter_dup_interface,
  &vik_datasource_bfilter_polygon_interface,
  &vik_datasource_bfilter_exclude_polygon_interface,
};

const guint N_FILTERS = sizeof(filters) / sizeof(filters[0]);

VikTrack *filter_track = NULL;

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

/* passed along to worker thread */
typedef struct {
  acq_dialog_widgets_t *w;
  gchar *cmd;
  gchar *extra;
} w_and_interface_t;


/*********************************************************
 * Definitions and routines for acquiring data from Data Sources in general
 *********************************************************/

static void progress_func ( BabelProgressCode c, gpointer data, acq_dialog_widgets_t *w )
{
  gdk_threads_enter ();
  if (!w->ok) {
    if ( w->source_interface->cleanup_func )
      w->source_interface->cleanup_func( w->user_data );
    g_free ( w );
    gdk_threads_leave();
    g_thread_exit ( NULL );
  }
  gdk_threads_leave ();

  if ( w->source_interface->progress_func )
    w->source_interface->progress_func ( c, data, w );
}


/* this routine is the worker thread.  there is only one simultaneous download allowed */
static void get_from_anything ( w_and_interface_t *wi )
{
  gchar *cmd = wi->cmd;
  gchar *extra = wi->extra;
  gboolean result = TRUE;
  VikTrwLayer *vtl = NULL;

  gboolean creating_new_layer = TRUE;

  acq_dialog_widgets_t *w = wi->w;
  VikDataSourceInterface *source_interface = wi->w->source_interface;
  g_free ( wi );
  wi = NULL;

  gdk_threads_enter();
  if (source_interface->mode == VIK_DATASOURCE_ADDTOLAYER) {
    VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp );
    if ( IS_VIK_TRW_LAYER(current_selected) ) {
      vtl = VIK_TRW_LAYER(current_selected);
      creating_new_layer = FALSE;
    }
  }
  if ( creating_new_layer ) {
    vtl = VIK_TRW_LAYER ( vik_layer_create ( VIK_LAYER_TRW, w->vvp, NULL, FALSE ) );
    vik_layer_rename ( VIK_LAYER ( vtl ), _(source_interface->layer_title) );
    gtk_label_set_text ( GTK_LABEL(w->status), _("Working...") );
  }
  gdk_threads_leave();

  // TODO consider removing 'type' and make everything run via the specficied process function
  switch ( source_interface->type ) {
  case VIK_DATASOURCE_GPSBABEL_DIRECT:
    result = a_babel_convert_from (vtl, cmd, extra, (BabelStatusFunc) progress_func, w);
    break;
  case VIK_DATASOURCE_URL:
    result = a_babel_convert_from_url (vtl, cmd, extra, (BabelStatusFunc) progress_func, w);
    break;
  case VIK_DATASOURCE_SHELL_CMD:
    result = a_babel_convert_from_shellcommand ( vtl, cmd, extra, (BabelStatusFunc) progress_func, w);
    break;
  case VIK_DATASOURCE_INTERNAL:
    if ( source_interface->process_func )
      result = source_interface->process_func ( vtl, cmd, extra, (BabelStatusFunc) progress_func, w );
    break;
  default:
    g_critical("Houston, we've had a problem.");
  }

  g_free ( cmd );
  g_free ( extra );

  if (!result) {
    gdk_threads_enter();
    gtk_label_set_text ( GTK_LABEL(w->status), _("Error: acquisition failed.") );
    if ( creating_new_layer )
      g_object_unref ( G_OBJECT ( vtl ) );
    gdk_threads_leave();
  } 
  else {
    gdk_threads_enter();
    if (w->ok) {
      gtk_label_set_text ( GTK_LABEL(w->status), _("Done.") );
      if ( creating_new_layer ) {
	/* Only create the layer if it actually contains anything useful */
	// TODO: create function for this operation to hide detail:
	if ( g_hash_table_size (vik_trw_layer_get_tracks(vtl)) ||
	     g_hash_table_size (vik_trw_layer_get_waypoints(vtl)) ||
	     g_hash_table_size (vik_trw_layer_get_routes(vtl)) ) {
	  vik_layer_post_read ( VIK_LAYER(vtl), w->vvp, TRUE );
	  vik_aggregate_layer_add_layer( vik_layers_panel_get_top_layer(w->vlp), VIK_LAYER(vtl));
	}
	else
	  gtk_label_set_text ( GTK_LABEL(w->status), _("No data.") );
      }
      /* View this data if available and is desired */
      if ( vtl && source_interface->autoview ) {
	vik_trw_layer_auto_set_view ( vtl, vik_layers_panel_get_viewport(w->vlp) );
	vik_layers_panel_emit_update (w->vlp);
      }
      if ( source_interface->keep_dialog_open ) {
        gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT, TRUE );
        gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_REJECT, FALSE );
      } else {
        gtk_dialog_response ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT );     
      }
    } else {
      /* canceled */
      if ( creating_new_layer )
	g_object_unref(vtl);
    }
  }
  if ( source_interface->cleanup_func )
    source_interface->cleanup_func ( w->user_data );

  if ( w->ok ) {
    w->ok = FALSE;
  } else {
    g_free ( w );
  }

  gdk_threads_leave();
  g_thread_exit ( NULL );
}


static gchar *write_tmp_trwlayer ( VikTrwLayer *vtl )
{
  int fd_src;
  gchar *name_src;
  FILE *f;
  g_assert ((fd_src = g_file_open_tmp("tmp-viking.XXXXXX", &name_src, NULL)) >= 0);
  g_debug ("%s: temporary file: %s", __FUNCTION__, name_src);
  f = fdopen(fd_src, "w");
  a_gpx_write_file(vtl, f, NULL);
  fclose(f);
  f = NULL;
  return name_src;
}

/* TODO: write with name of old track */
static gchar *write_tmp_track ( VikTrack *track )
{
  int fd_src;
  gchar *name_src;
  FILE *f;
  g_assert ((fd_src = g_file_open_tmp("tmp-viking.XXXXXX", &name_src, NULL)) >= 0);
  g_debug ("%s: temporary file: %s", __FUNCTION__, name_src);
  f = fdopen(fd_src, "w");
  a_gpx_write_track_file(track, f, NULL); /* Thank you Guilhem! Just when I needed this function... -- Evan */
  fclose(f);
  f = NULL;
  return name_src;
}

/* TODO: cleanup, getr rid of redundancy */

/* depending on type of filter, often only vtl or track will be given.
 * the other can be NULL.
 */
static void acquire ( VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikDataSourceInterface *source_interface,
		      VikTrwLayer *vtl, VikTrack *track )
{
  /* for manual dialogs */
  GtkWidget *dialog = NULL;
  GtkWidget *status;
  gchar *cmd = NULL;
  gchar *extra = NULL;
  gchar *cmd_off = NULL;
  gchar *extra_off = NULL;
  acq_dialog_widgets_t *w;
  gpointer user_data;

  /* for UI builder */
  gpointer pass_along_data;
  VikLayerParamData *paramdatas = NULL;

  w_and_interface_t *wi;

  /*** INIT AND CHECK EXISTENCE ***/
  if ( source_interface->init_func )
    user_data = source_interface->init_func();
  else
    user_data = NULL;
  pass_along_data = user_data;

  if ( source_interface->check_existence_func ) {
    gchar *error_str = source_interface->check_existence_func();
    if ( error_str ) {
      a_dialog_error_msg ( GTK_WINDOW(vw), error_str );
      g_free ( error_str );
      return;
    }
  }    

  /* BUILD UI & GET OPTIONS IF NECESSARY. */

  /* POSSIBILITY 0: NO OPTIONS. DO NOTHING HERE. */
  /* POSSIBILITY 1: ADD_SETUP_WIDGETS_FUNC */
  if ( source_interface->add_setup_widgets_func ) {
    dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );

    gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
    GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
    response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
#endif

    source_interface->add_setup_widgets_func(dialog, vvp, user_data);
    gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );

    if ( response_w )
      gtk_widget_grab_focus ( response_w );

    if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
      source_interface->cleanup_func(user_data);
      gtk_widget_destroy(dialog);
      return;
    }
  }
  /* POSSIBILITY 2: UI BUILDER */
  else if ( source_interface->params ) {
    paramdatas = a_uibuilder_run_dialog ( source_interface->window_title, GTK_WINDOW(vw),
			source_interface->params, source_interface->params_count,
			source_interface->params_groups, source_interface->params_groups_count,
			source_interface->params_defaults );
    if ( paramdatas )
      pass_along_data = paramdatas;
    else
      return; /* TODO: do we have to free anything here? */
  }

  /* CREATE INPUT DATA & GET COMMAND STRING */

  if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER ) {
    gchar *name_src = write_tmp_trwlayer ( vtl );

    ((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
	( pass_along_data, &cmd, &extra, name_src );

    g_free ( name_src );
    /* TODO: delete the tmp file? or delete it only after we're done with it? */
  } else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK ) {
    gchar *name_src = write_tmp_trwlayer ( vtl );
    gchar *name_src_track = write_tmp_track ( track );

    ((VikDataSourceGetCmdStringFuncWithInputInput) source_interface->get_cmd_string_func)
	( pass_along_data, &cmd, &extra, name_src, name_src_track );

    g_free ( name_src );
    g_free ( name_src_track );
  } else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRACK ) {
    gchar *name_src_track = write_tmp_track ( track );

    ((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
	( pass_along_data, &cmd, &extra, name_src_track );

    g_free ( name_src_track );
  } else if ( source_interface->get_cmd_string_func )
      source_interface->get_cmd_string_func ( pass_along_data, &cmd, &extra );

  /* Get data for Off command */
  if ( source_interface->off_func ) {
    source_interface->off_func ( pass_along_data, &cmd_off, &extra_off );
  }

  /* cleanup for option dialogs */
  if ( source_interface->add_setup_widgets_func ) {
    gtk_widget_destroy(dialog);
    dialog = NULL;
  } else if ( source_interface->params ) {
    a_uibuilder_free_paramdatas ( paramdatas, source_interface->params, source_interface->params_count );
  }

  /*** LET'S DO IT! ***/

  if ( ! cmd )
    return;

  w = g_malloc(sizeof(*w));
  wi = g_malloc(sizeof(*wi));
  wi->w = w;
  wi->w->source_interface = source_interface;
  wi->cmd = cmd;
  wi->extra = extra; /* usually input data type (?) */

  dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
  gtk_dialog_set_response_sensitive ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, FALSE );
  gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );


  w->dialog = dialog;
  w->ok = TRUE;
  status = gtk_label_new (_("Status: detecting gpsbabel"));
  gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), status, FALSE, FALSE, 5 );
  gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
  gtk_widget_show_all(status);
  w->status = status;

  w->vw = vw;
  w->vlp = vlp;
  w->vvp = vvp;
  if ( source_interface->add_progress_widgets_func ) {
    source_interface->add_progress_widgets_func ( dialog, user_data );
  }
  w->user_data = user_data;


  g_thread_create((GThreadFunc)get_from_anything, wi, FALSE, NULL );

  gtk_dialog_run ( GTK_DIALOG(dialog) );
  if ( w->ok )
    w->ok = FALSE; /* tell thread to stop. TODO: add mutex */
  else {
    if ( cmd_off ) {
      /* Turn off */
      a_babel_convert_from (NULL, cmd_off, extra_off, NULL, NULL);
    }
    g_free ( w ); /* thread has finished; free w */
  }
  gtk_widget_destroy ( dialog );
}

void a_acquire ( VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikDataSourceInterface *source_interface ) {
  acquire ( vw, vlp, vvp, source_interface, NULL, NULL );
}

static void acquire_trwlayer_callback ( GObject *menuitem, gpointer *pass_along )
{
  VikDataSourceInterface *iface = g_object_get_data ( menuitem, "vik_acq_iface" );
  VikWindow *vw =	pass_along[0];
  VikLayersPanel *vlp =	pass_along[1];
  VikViewport *vvp =	pass_along[2];
  VikTrwLayer *vtl =	pass_along[3];
  VikTrack *tr =	pass_along[4];

  acquire ( vw, vlp, vvp, iface, vtl, tr );
}

static GtkWidget *acquire_build_menu ( VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp,
				VikTrwLayer *vtl, VikTrack *track, /* both passed to acquire, although for many filters only one ness */
				const gchar *menu_title, vik_datasource_inputtype_t inputtype )
{
  static gpointer pass_along[5];
  GtkWidget *menu_item=NULL, *menu=NULL;
  GtkWidget *item=NULL;
  int i;

  pass_along[0] = vw;
  pass_along[1] = vlp;
  pass_along[2] = vvp;
  pass_along[3] = vtl;
  pass_along[4] = track;

  for ( i = 0; i < N_FILTERS; i++ ) {
    if ( filters[i]->inputtype == inputtype ) {
      if ( ! menu_item ) { /* do this just once, but return NULL if no filters */
        menu = gtk_menu_new();
        menu_item = gtk_menu_item_new_with_mnemonic ( menu_title );
        gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu );
      }

      item = gtk_menu_item_new_with_label ( filters[i]->window_title );
      g_object_set_data ( G_OBJECT(item), "vik_acq_iface", (gpointer) filters[i] );
      g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(acquire_trwlayer_callback), pass_along );
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
      gtk_widget_show ( item );
    }
  }

  return menu_item;
}

GtkWidget *a_acquire_trwlayer_menu (VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikTrwLayer *vtl)
{
  return acquire_build_menu ( vw, vlp, vvp, vtl, NULL, _("_Filter"), VIK_DATASOURCE_INPUTTYPE_TRWLAYER );
}

GtkWidget *a_acquire_trwlayer_track_menu (VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikTrwLayer *vtl)
{
  if ( filter_track == NULL )
    return NULL;
  else {
    gchar *menu_title = g_strdup_printf ( _("Filter with %s"), filter_track->name );
    GtkWidget *rv = acquire_build_menu ( vw, vlp, vvp, vtl, filter_track,
			menu_title, VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK );
    g_free ( menu_title );
    return rv;
  }
}

GtkWidget *a_acquire_track_menu (VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikTrack *tr)
{
  return acquire_build_menu ( vw, vlp, vvp, NULL, tr, _("Filter"), VIK_DATASOURCE_INPUTTYPE_TRACK );
}

void a_acquire_set_filter_track ( VikTrack *tr )
{
  if ( filter_track )
    vik_track_free ( filter_track );

  filter_track = tr;
  vik_track_ref ( tr );
}
Commit	Line	Data
1d1bc3c1 EB	1	/*
	2	* viking -- GPS Data and Topo Analyzer, Explorer, and Manager
	3	*
	4	* Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
4c77d5e0 GB	21	#ifdef HAVE_CONFIG_H
	22	#include "config.h"
	23	#endif
	24
8c060406	25	#include <stdio.h>
1d1bc3c1 EB	26	#include <string.h>
1d1bc3c1 EB	27	#include <glib/gprintf.h>
4c77d5e0	28	#include <glib/gi18n.h>
1d1bc3c1 EB	29
	30	#include "viking.h"
	31	#include "babel.h"
	32	#include "gpx.h"
7b3479e3	33	#include "acquire.h"
1d1bc3c1	34
28c82d8b EB	35	/********************** FILTER LIST *****************/
28c82d8b EB	36	// extern VikDataSourceInterface vik_datasource_gps_interface;
28c82d8b EB	37
	38	/* Input is TRWLayer */
	39	extern VikDataSourceInterface vik_datasource_bfilter_simplify_interface;
	40	extern VikDataSourceInterface vik_datasource_bfilter_dup_interface;
	41
	42	/* Input is a track and a TRWLayer */
	43	extern VikDataSourceInterface vik_datasource_bfilter_polygon_interface;
	44	extern VikDataSourceInterface vik_datasource_bfilter_exclude_polygon_interface;
	45
	46	/* Input is a track */
	47
	48	const VikDataSourceInterface *filters[] = {
	49	&vik_datasource_bfilter_simplify_interface,
	50	&vik_datasource_bfilter_dup_interface,
	51	&vik_datasource_bfilter_polygon_interface,
	52	&vik_datasource_bfilter_exclude_polygon_interface,
	53	};
	54
	55	const guint N_FILTERS = sizeof(filters) / sizeof(filters[0]);
	56
	57	VikTrack *filter_track = NULL;
28c82d8b EB	58
	59	/********************************************************/
	60
7b3479e3	61	/* passed along to worker thread */
1d1bc3c1	62	typedef struct {
7b3479e3	63	acq_dialog_widgets_t *w;
7b3479e3 EB	64	gchar *cmd;
	65	gchar *extra;
	66	} w_and_interface_t;
1d1bc3c1	67
1d1bc3c1	68
7b3479e3	69	/*********************************************************
cf697cc2	70	* Definitions and routines for acquiring data from Data Sources in general
7b3479e3	71	*********************************************************/
1d1bc3c1	72
cf697cc2 EB	73	static void progress_func ( BabelProgressCode c, gpointer data, acq_dialog_widgets_t *w )
	74	{
	75	gdk_threads_enter ();
	76	if (!w->ok) {
62ddf770 MA	77	if ( w->source_interface->cleanup_func )
62ddf770 MA	78	w->source_interface->cleanup_func( w->user_data );
65f0ccab	79	g_free ( w );
cf697cc2 EB	80	gdk_threads_leave();
	81	g_thread_exit ( NULL );
	82	}
	83	gdk_threads_leave ();
	84
62ddf770	85	if ( w->source_interface->progress_func )
5564dd66	86	w->source_interface->progress_func ( c, data, w );
cf697cc2 EB	87	}
cf697cc2 EB	88
28c82d8b	89
1d1bc3c1	90	/* this routine is the worker thread. there is only one simultaneous download allowed */
7b3479e3	91	static void get_from_anything ( w_and_interface_t *wi )
1d1bc3c1	92	{
7b3479e3 EB	93	gchar *cmd = wi->cmd;
7b3479e3 EB	94	gchar *extra = wi->extra;
0d337f27	95	gboolean result = TRUE;
d2525524	96	VikTrwLayer *vtl = NULL;
805d282e EB	97
805d282e EB	98	gboolean creating_new_layer = TRUE;
7b3479e3 EB	99
7b3479e3 EB	100	acq_dialog_widgets_t *w = wi->w;
62ddf770	101	VikDataSourceInterface *source_interface = wi->w->source_interface;
7b3479e3	102	g_free ( wi );
28c82d8b	103	wi = NULL;
1d1bc3c1 EB	104
1d1bc3c1 EB	105	gdk_threads_enter();
62ddf770	106	if (source_interface->mode == VIK_DATASOURCE_ADDTOLAYER) {
805d282e EB	107	VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp );
	108	if ( IS_VIK_TRW_LAYER(current_selected) ) {
	109	vtl = VIK_TRW_LAYER(current_selected);
	110	creating_new_layer = FALSE;
	111	}
	112	}
	113	if ( creating_new_layer ) {
	114	vtl = VIK_TRW_LAYER ( vik_layer_create ( VIK_LAYER_TRW, w->vvp, NULL, FALSE ) );
62ddf770	115	vik_layer_rename ( VIK_LAYER ( vtl ), _(source_interface->layer_title) );
4c77d5e0	116	gtk_label_set_text ( GTK_LABEL(w->status), _("Working...") );
805d282e	117	}
1d1bc3c1 EB	118	gdk_threads_leave();
1d1bc3c1 EB	119
0944940f	120	// TODO consider removing 'type' and make everything run via the specficied process function
62ddf770	121	switch ( source_interface->type ) {
533bbf34	122	case VIK_DATASOURCE_GPSBABEL_DIRECT:
9181183a	123	result = a_babel_convert_from (vtl, cmd, extra, (BabelStatusFunc) progress_func, w);
533bbf34 MA	124	break;
	125	case VIK_DATASOURCE_URL:
	126	result = a_babel_convert_from_url (vtl, cmd, extra, (BabelStatusFunc) progress_func, w);
	127	break;
	128	case VIK_DATASOURCE_SHELL_CMD:
cf697cc2	129	result = a_babel_convert_from_shellcommand ( vtl, cmd, extra, (BabelStatusFunc) progress_func, w);
533bbf34	130	break;
0944940f RN	131	case VIK_DATASOURCE_INTERNAL:
	132	if ( source_interface->process_func )
	133	result = source_interface->process_func ( vtl, cmd, extra, (BabelStatusFunc) progress_func, w );
	134	break;
533bbf34 MA	135	default:
	136	g_critical("Houston, we've had a problem.");
	137	}
7b3479e3 EB	138
	139	g_free ( cmd );
	140	g_free ( extra );
	141
	142	if (!result) {
1d1bc3c1	143	gdk_threads_enter();
841a6e71	144	gtk_label_set_text ( GTK_LABEL(w->status), _("Error: acquisition failed.") );
805d282e EB	145	if ( creating_new_layer )
805d282e EB	146	g_object_unref ( G_OBJECT ( vtl ) );
1d1bc3c1 EB	147	gdk_threads_leave();
1d1bc3c1 EB	148	}
5f304fd7	149	else {
65f0ccab AF	150	gdk_threads_enter();
65f0ccab AF	151	if (w->ok) {
4c77d5e0	152	gtk_label_set_text ( GTK_LABEL(w->status), _("Done.") );
743ffb91 RN	153	if ( creating_new_layer ) {
743ffb91 RN	154	/* Only create the layer if it actually contains anything useful */
0d2b891f	155	// TODO: create function for this operation to hide detail:
743ffb91	156	if ( g_hash_table_size (vik_trw_layer_get_tracks(vtl)) \|\|
0d2b891f RN	157	g_hash_table_size (vik_trw_layer_get_waypoints(vtl)) \|\|
0d2b891f RN	158	g_hash_table_size (vik_trw_layer_get_routes(vtl)) ) {
ae341715	159	vik_layer_post_read ( VIK_LAYER(vtl), w->vvp, TRUE );
743ffb91	160	vik_aggregate_layer_add_layer( vik_layers_panel_get_top_layer(w->vlp), VIK_LAYER(vtl));
ae341715	161	}
743ffb91 RN	162	else
	163	gtk_label_set_text ( GTK_LABEL(w->status), _("No data.") );
	164	}
d2525524 RN	165	/* View this data if available and is desired */
	166	if ( vtl && source_interface->autoview ) {
	167	vik_trw_layer_auto_set_view ( vtl, vik_layers_panel_get_viewport(w->vlp) );
	168	vik_layers_panel_emit_update (w->vlp);
	169	}
62ddf770	170	if ( source_interface->keep_dialog_open ) {
28c82d8b EB	171	gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT, TRUE );
	172	gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_REJECT, FALSE );
	173	} else {
	174	gtk_dialog_response ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT );
	175	}
65f0ccab AF	176	} else {
	177	/* canceled */
	178	if ( creating_new_layer )
	179	g_object_unref(vtl);
	180	}
1d1bc3c1	181	}
62ddf770 MA	182	if ( source_interface->cleanup_func )
62ddf770 MA	183	source_interface->cleanup_func ( w->user_data );
7b3479e3 EB	184
	185	if ( w->ok ) {
	186	w->ok = FALSE;
	187	} else {
	188	g_free ( w );
	189	}
	190
1d1bc3c1 EB	191	gdk_threads_leave();
	192	g_thread_exit ( NULL );
	193	}
	194
7b3479e3	195
28c82d8b EB	196	static gchar write_tmp_trwlayer ( VikTrwLayer vtl )
	197	{
	198	int fd_src;
	199	gchar *name_src;
	200	FILE *f;
	201	g_assert ((fd_src = g_file_open_tmp("tmp-viking.XXXXXX", &name_src, NULL)) >= 0);
e45b3da1	202	g_debug ("%s: temporary file: %s", __FUNCTION__, name_src);
28c82d8b	203	f = fdopen(fd_src, "w");
208d2084	204	a_gpx_write_file(vtl, f, NULL);
28c82d8b	205	fclose(f);
8c060406	206	f = NULL;
28c82d8b EB	207	return name_src;
	208	}
	209
	210	/* TODO: write with name of old track */
	211	static gchar write_tmp_track ( VikTrack track )
	212	{
	213	int fd_src;
	214	gchar *name_src;
	215	FILE *f;
	216	g_assert ((fd_src = g_file_open_tmp("tmp-viking.XXXXXX", &name_src, NULL)) >= 0);
e45b3da1	217	g_debug ("%s: temporary file: %s", __FUNCTION__, name_src);
28c82d8b	218	f = fdopen(fd_src, "w");
208d2084	219	a_gpx_write_track_file(track, f, NULL); /* Thank you Guilhem! Just when I needed this function... -- Evan */
28c82d8b	220	fclose(f);
8c060406	221	f = NULL;
28c82d8b EB	222	return name_src;
	223	}
	224
	225	/* TODO: cleanup, getr rid of redundancy */
	226
	227	/* depending on type of filter, often only vtl or track will be given.
	228	* the other can be NULL.
	229	*/
62ddf770	230	static void acquire ( VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikDataSourceInterface source_interface,
28c82d8b	231	VikTrwLayer vtl, VikTrack track )
1d1bc3c1	232	{
28c82d8b	233	/* for manual dialogs */
1d1bc3c1	234	GtkWidget *dialog = NULL;
7b3479e3	235	GtkWidget *status;
0944940f RN	236	gchar *cmd = NULL;
0944940f RN	237	gchar *extra = NULL;
c9a36bd6 RN	238	gchar *cmd_off = NULL;
c9a36bd6 RN	239	gchar *extra_off = NULL;
7b3479e3	240	acq_dialog_widgets_t *w;
65f0ccab	241	gpointer user_data;
7b3479e3	242
28c82d8b EB	243	/* for UI builder */
28c82d8b EB	244	gpointer pass_along_data;
7ee4103e	245	VikLayerParamData *paramdatas = NULL;
28c82d8b	246
7b3479e3 EB	247	w_and_interface_t *wi;
7b3479e3 EB	248
28c82d8b	249	/* INIT AND CHECK EXISTENCE */
62ddf770 MA	250	if ( source_interface->init_func )
62ddf770 MA	251	user_data = source_interface->init_func();
28c82d8b EB	252	else
	253	user_data = NULL;
	254	pass_along_data = user_data;
	255
62ddf770 MA	256	if ( source_interface->check_existence_func ) {
62ddf770 MA	257	gchar *error_str = source_interface->check_existence_func();
92255687 EB	258	if ( error_str ) {
	259	a_dialog_error_msg ( GTK_WINDOW(vw), error_str );
	260	g_free ( error_str );
	261	return;
	262	}
	263	}
	264
28c82d8b EB	265	/* BUILD UI & GET OPTIONS IF NECESSARY. */
	266
	267	/* POSSIBILITY 0: NO OPTIONS. DO NOTHING HERE. */
	268	/* POSSIBILITY 1: ADD_SETUP_WIDGETS_FUNC */
62ddf770	269	if ( source_interface->add_setup_widgets_func ) {
f4b1d29b	270	dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
92255687	271
5f7a8ef6 RN	272	gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
	273	GtkWidget *response_w = NULL;
	274	#if GTK_CHECK_VERSION (2, 20, 0)
	275	response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
	276	#endif
	277
62ddf770 MA	278	source_interface->add_setup_widgets_func(dialog, vvp, user_data);
62ddf770 MA	279	gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );
a8d46e0b	280
5f7a8ef6 RN	281	if ( response_w )
	282	gtk_widget_grab_focus ( response_w );
	283
7b3479e3	284	if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
62ddf770	285	source_interface->cleanup_func(user_data);
7b3479e3 EB	286	gtk_widget_destroy(dialog);
	287	return;
	288	}
28c82d8b EB	289	}
28c82d8b EB	290	/* POSSIBILITY 2: UI BUILDER */
62ddf770	291	else if ( source_interface->params ) {
13fde155	292	paramdatas = a_uibuilder_run_dialog ( source_interface->window_title, GTK_WINDOW(vw),
62ddf770 MA	293	source_interface->params, source_interface->params_count,
	294	source_interface->params_groups, source_interface->params_groups_count,
	295	source_interface->params_defaults );
28c82d8b EB	296	if ( paramdatas )
	297	pass_along_data = paramdatas;
	298	else
	299	return; /* TODO: do we have to free anything here? */
	300	}
	301
	302	/* CREATE INPUT DATA & GET COMMAND STRING */
	303
62ddf770	304	if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER ) {
28c82d8b EB	305	gchar *name_src = write_tmp_trwlayer ( vtl );
28c82d8b EB	306
62ddf770	307	((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
28c82d8b EB	308	( pass_along_data, &cmd, &extra, name_src );
	309
	310	g_free ( name_src );
	311	/* TODO: delete the tmp file? or delete it only after we're done with it? */
62ddf770	312	} else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK ) {
28c82d8b EB	313	gchar *name_src = write_tmp_trwlayer ( vtl );
	314	gchar *name_src_track = write_tmp_track ( track );
	315
62ddf770	316	((VikDataSourceGetCmdStringFuncWithInputInput) source_interface->get_cmd_string_func)
28c82d8b EB	317	( pass_along_data, &cmd, &extra, name_src, name_src_track );
	318
	319	g_free ( name_src );
	320	g_free ( name_src_track );
62ddf770	321	} else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRACK ) {
28c82d8b EB	322	gchar *name_src_track = write_tmp_track ( track );
28c82d8b EB	323
62ddf770	324	((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
28c82d8b EB	325	( pass_along_data, &cmd, &extra, name_src_track );
	326
	327	g_free ( name_src_track );
0944940f RN	328	} else if ( source_interface->get_cmd_string_func )
0944940f RN	329	source_interface->get_cmd_string_func ( pass_along_data, &cmd, &extra );
28c82d8b	330
2b756ea0 RN	331	/* Get data for Off command */
	332	if ( source_interface->off_func ) {
	333	source_interface->off_func ( pass_along_data, &cmd_off, &extra_off );
	334	}
	335
28c82d8b	336	/* cleanup for option dialogs */
62ddf770	337	if ( source_interface->add_setup_widgets_func ) {
7b3479e3 EB	338	gtk_widget_destroy(dialog);
7b3479e3 EB	339	dialog = NULL;
62ddf770 MA	340	} else if ( source_interface->params ) {
62ddf770 MA	341	a_uibuilder_free_paramdatas ( paramdatas, source_interface->params, source_interface->params_count );
28c82d8b EB	342	}
	343
	344	/* LET'S DO IT! */
7b3479e3 EB	345
	346	if ( ! cmd )
	347	return;
	348
	349	w = g_malloc(sizeof(*w));
	350	wi = g_malloc(sizeof(*wi));
	351	wi->w = w;
62ddf770	352	wi->w->source_interface = source_interface;
7b3479e3	353	wi->cmd = cmd;
28c82d8b	354	wi->extra = extra; /* usually input data type (?) */
1d1bc3c1	355
f4b1d29b	356	dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
1d1bc3c1	357	gtk_dialog_set_response_sensitive ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, FALSE );
62ddf770	358	gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );
1d1bc3c1	359
1d1bc3c1 EB	360
1d1bc3c1 EB	361	w->dialog = dialog;
7b3479e3	362	w->ok = TRUE;
4c77d5e0	363	status = gtk_label_new (_("Status: detecting gpsbabel"));
7b3479e3	364	gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), status, FALSE, FALSE, 5 );
5f7a8ef6	365	gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
7b3479e3	366	gtk_widget_show_all(status);
1d1bc3c1	367	w->status = status;
7b3479e3	368
1d1bc3c1 EB	369	w->vw = vw;
	370	w->vlp = vlp;
	371	w->vvp = vvp;
62ddf770 MA	372	if ( source_interface->add_progress_widgets_func ) {
62ddf770 MA	373	source_interface->add_progress_widgets_func ( dialog, user_data );
65f0ccab AF	374	}
65f0ccab AF	375	w->user_data = user_data;
7b3479e3	376
a8d46e0b	377
7b3479e3	378	g_thread_create((GThreadFunc)get_from_anything, wi, FALSE, NULL );
1d1bc3c1 EB	379
1d1bc3c1 EB	380	gtk_dialog_run ( GTK_DIALOG(dialog) );
7b3479e3 EB	381	if ( w->ok )
	382	w->ok = FALSE; /* tell thread to stop. TODO: add mutex */
	383	else {
2b756ea0 RN	384	if ( cmd_off ) {
2b756ea0 RN	385	/* Turn off */
9181183a	386	a_babel_convert_from (NULL, cmd_off, extra_off, NULL, NULL);
2b756ea0	387	}
7b3479e3 EB	388	g_free ( w ); /* thread has finished; free w */
7b3479e3 EB	389	}
1d1bc3c1 EB	390	gtk_widget_destroy ( dialog );
1d1bc3c1 EB	391	}
7b3479e3	392
62ddf770 MA	393	void a_acquire ( VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikDataSourceInterface source_interface ) {
62ddf770 MA	394	acquire ( vw, vlp, vvp, source_interface, NULL, NULL );
28c82d8b EB	395	}
	396
	397	static void acquire_trwlayer_callback ( GObject menuitem, gpointer pass_along )
	398	{
	399	VikDataSourceInterface *iface = g_object_get_data ( menuitem, "vik_acq_iface" );
	400	VikWindow *vw = pass_along[0];
	401	VikLayersPanel *vlp = pass_along[1];
	402	VikViewport *vvp = pass_along[2];
	403	VikTrwLayer *vtl = pass_along[3];
	404	VikTrack *tr = pass_along[4];
	405
	406	acquire ( vw, vlp, vvp, iface, vtl, tr );
	407	}
	408
	409	static GtkWidget acquire_build_menu ( VikWindow vw, VikLayersPanel vlp, VikViewport vvp,
	410	VikTrwLayer vtl, VikTrack track, /* both passed to acquire, although for many filters only one ness */
	411	const gchar *menu_title, vik_datasource_inputtype_t inputtype )
	412	{
0d337f27	413	static gpointer pass_along[5];
7ee4103e GB	414	GtkWidget menu_item=NULL, menu=NULL;
7ee4103e GB	415	GtkWidget *item=NULL;
28c82d8b EB	416	int i;
28c82d8b EB	417
28c82d8b EB	418	pass_along[0] = vw;
	419	pass_along[1] = vlp;
	420	pass_along[2] = vvp;
	421	pass_along[3] = vtl;
	422	pass_along[4] = track;
	423
	424	for ( i = 0; i < N_FILTERS; i++ ) {
	425	if ( filters[i]->inputtype == inputtype ) {
	426	if ( ! menu_item ) { /* do this just once, but return NULL if no filters */
	427	menu = gtk_menu_new();
c6fb43ba	428	menu_item = gtk_menu_item_new_with_mnemonic ( menu_title );
28c82d8b EB	429	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu );
	430	}
	431
	432	item = gtk_menu_item_new_with_label ( filters[i]->window_title );
	433	g_object_set_data ( G_OBJECT(item), "vik_acq_iface", (gpointer) filters[i] );
	434	g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(acquire_trwlayer_callback), pass_along );
	435	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	436	gtk_widget_show ( item );
	437	}
	438	}
	439
	440	return menu_item;
	441	}
	442
	443	GtkWidget a_acquire_trwlayer_menu (VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikTrwLayer *vtl)
	444	{
0d6911da	445	return acquire_build_menu ( vw, vlp, vvp, vtl, NULL, _("_Filter"), VIK_DATASOURCE_INPUTTYPE_TRWLAYER );
28c82d8b EB	446	}
	447
	448	GtkWidget a_acquire_trwlayer_track_menu (VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikTrwLayer *vtl)
	449	{
	450	if ( filter_track == NULL )
	451	return NULL;
	452	else {
0d6911da	453	gchar *menu_title = g_strdup_printf ( _("Filter with %s"), filter_track->name );
28c82d8b EB	454	GtkWidget *rv = acquire_build_menu ( vw, vlp, vvp, vtl, filter_track,
	455	menu_title, VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK );
	456	g_free ( menu_title );
	457	return rv;
	458	}
	459	}
	460
	461	GtkWidget a_acquire_track_menu (VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikTrack *tr)
	462	{
0d6911da	463	return acquire_build_menu ( vw, vlp, vvp, NULL, tr, _("Filter"), VIK_DATASOURCE_INPUTTYPE_TRACK );
28c82d8b EB	464	}
28c82d8b EB	465
ce4bd1cf	466	void a_acquire_set_filter_track ( VikTrack *tr )
28c82d8b EB	467	{
	468	if ( filter_track )
	469	vik_track_free ( filter_track );
28c82d8b EB	470
	471	filter_track = tr;
	472	vik_track_ref ( tr );
28c82d8b	473	}