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;
// extern VikDataSourceInterface vik_datasource_google_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;
gchar *filter_track_name = 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->interface->cleanup_func )
      w->interface->cleanup_func( w->user_data );
    g_free ( w );
    gdk_threads_leave();
    g_thread_exit ( NULL );
  }
  gdk_threads_leave ();

  if ( w->interface->progress_func )
    w->interface->progress_func ( (gpointer) 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;
  VikTrwLayer *vtl;

  gboolean creating_new_layer = TRUE;

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

  gdk_threads_enter();
  if (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 ), _(interface->layer_title) );
    gtk_label_set_text ( GTK_LABEL(w->status), _("Working...") );
  }
  gdk_threads_leave();

  if ( interface->type == VIK_DATASOURCE_GPSBABEL_DIRECT )
    result = a_babel_convert_from (vtl, cmd, (BabelStatusFunc) progress_func, extra, w);
  else
    result = a_babel_convert_from_shellcommand ( vtl, cmd, extra, (BabelStatusFunc) progress_func, w);

  g_free ( cmd );
  g_free ( extra );

  if (!result) {
    gdk_threads_enter();
    gtk_label_set_text ( GTK_LABEL(w->status), _("Error: couldn't find gpsbabel.") );
    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 )
	vik_aggregate_layer_add_layer( vik_layers_panel_get_top_layer(w->vlp), VIK_LAYER(vtl));
      if ( 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 ( interface->cleanup_func )
    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);
  f = fdopen(fd_src, "w");
  a_gpx_write_file(vtl, f);
  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);
  f = fdopen(fd_src, "w");
  a_gpx_write_track_file("track", track, f); /* 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 *interface,
		      VikTrwLayer *vtl, VikTrack *track )
{
  /* for manual dialogs */
  GtkWidget *dialog = NULL;
  GtkWidget *status;
  gchar *cmd, *extra;
  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 ( interface->init_func )
    user_data = interface->init_func();
  else
    user_data = NULL;
  pass_along_data = user_data;

  if ( interface->check_existence_func ) {
    gchar *error_str = 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 ( 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 );

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

    if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
      interface->cleanup_func(user_data);
      gtk_widget_destroy(dialog);
      return;
    }
  }
  /* POSSIBILITY 2: UI BUILDER */
  else if ( interface->params ) {
    paramdatas = a_uibuilder_run_dialog ( GTK_WINDOW(vw),
			interface->params, interface->params_count,
			interface->params_groups, interface->params_groups_count,
			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 ( interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER ) {
    gchar *name_src = write_tmp_trwlayer ( vtl );

    ((VikDataSourceGetCmdStringFuncWithInput) 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 ( interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK ) {
    gchar *name_src = write_tmp_trwlayer ( vtl );
    gchar *name_src_track = write_tmp_track ( track );

    ((VikDataSourceGetCmdStringFuncWithInputInput) 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 ( interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRACK ) {
    gchar *name_src_track = write_tmp_track ( track );

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

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

  /* cleanup for option dialogs */
  if ( interface->add_setup_widgets_func ) {
    gtk_widget_destroy(dialog);
    dialog = NULL;
  } else if ( interface->params ) {
    a_uibuilder_free_paramdatas ( paramdatas, interface->params, 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->interface = 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), _(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_widget_show_all(status);
  w->status = status;

  w->vw = vw;
  w->vlp = vlp;
  w->vvp = vvp;
  if ( interface->add_progress_widgets_func ) {
    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 {
    g_free ( w ); /* thread has finished; free w */
  }
  gtk_widget_destroy ( dialog );
}

void a_acquire ( VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikDataSourceInterface *interface ) {
  acquire ( vw, vlp, vvp, 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[4];
  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_label ( 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, const gchar *name )
{
  if ( filter_track )
    vik_track_free ( filter_track );
  if ( filter_track_name )
    g_free ( filter_track_name );

  filter_track = tr;
  vik_track_ref ( tr );

  filter_track_name = g_strdup(name);
}
Commit	Line	Data
	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	*/
	21	#ifdef HAVE_CONFIG_H
	22	#include "config.h"
	23	#endif
	24
	25	#include <stdio.h>
	26	#include <string.h>
	27	#include <glib/gprintf.h>
	28	#include <glib/gi18n.h>
	29
	30	#include "viking.h"
	31	#include "babel.h"
	32	#include "gpx.h"
	33	#include "acquire.h"
	34
	35	/********************** FILTER LIST *****************/
	36	// extern VikDataSourceInterface vik_datasource_gps_interface;
	37	// extern VikDataSourceInterface vik_datasource_google_interface;
	38
	39	/* Input is TRWLayer */
	40	extern VikDataSourceInterface vik_datasource_bfilter_simplify_interface;
	41	extern VikDataSourceInterface vik_datasource_bfilter_dup_interface;
	42
	43	/* Input is a track and a TRWLayer */
	44	extern VikDataSourceInterface vik_datasource_bfilter_polygon_interface;
	45	extern VikDataSourceInterface vik_datasource_bfilter_exclude_polygon_interface;
	46
	47	/* Input is a track */
	48
	49	const VikDataSourceInterface *filters[] = {
	50	&vik_datasource_bfilter_simplify_interface,
	51	&vik_datasource_bfilter_dup_interface,
	52	&vik_datasource_bfilter_polygon_interface,
	53	&vik_datasource_bfilter_exclude_polygon_interface,
	54	};
	55
	56	const guint N_FILTERS = sizeof(filters) / sizeof(filters[0]);
	57
	58	VikTrack *filter_track = NULL;
	59	gchar *filter_track_name = NULL;
	60
	61	/********************************************************/
	62
	63	/* passed along to worker thread */
	64	typedef struct {
	65	acq_dialog_widgets_t *w;
	66	gchar *cmd;
	67	gchar *extra;
	68	} w_and_interface_t;
	69
	70
	71	/*********************************************************
	72	* Definitions and routines for acquiring data from Data Sources in general
	73	*********************************************************/
	74
	75	static void progress_func ( BabelProgressCode c, gpointer data, acq_dialog_widgets_t *w )
	76	{
	77	gdk_threads_enter ();
	78	if (!w->ok) {
	79	if ( w->interface->cleanup_func )
	80	w->interface->cleanup_func( w->user_data );
	81	g_free ( w );
	82	gdk_threads_leave();
	83	g_thread_exit ( NULL );
	84	}
	85	gdk_threads_leave ();
	86
	87	if ( w->interface->progress_func )
	88	w->interface->progress_func ( (gpointer) c, data, w );
	89	}
	90
	91
	92	/* this routine is the worker thread. there is only one simultaneous download allowed */
	93	static void get_from_anything ( w_and_interface_t *wi )
	94	{
	95	gchar *cmd = wi->cmd;
	96	gchar *extra = wi->extra;
	97	gboolean result;
	98	VikTrwLayer *vtl;
	99
	100	gboolean creating_new_layer = TRUE;
	101
	102	acq_dialog_widgets_t *w = wi->w;
	103	VikDataSourceInterface *interface = wi->w->interface;
	104	g_free ( wi );
	105	wi = NULL;
	106
	107	gdk_threads_enter();
	108	if (interface->mode == VIK_DATASOURCE_ADDTOLAYER) {
	109	VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp );
	110	if ( IS_VIK_TRW_LAYER(current_selected) ) {
	111	vtl = VIK_TRW_LAYER(current_selected);
	112	creating_new_layer = FALSE;
	113	}
	114	}
	115	if ( creating_new_layer ) {
	116	vtl = VIK_TRW_LAYER ( vik_layer_create ( VIK_LAYER_TRW, w->vvp, NULL, FALSE ) );
	117	vik_layer_rename ( VIK_LAYER ( vtl ), _(interface->layer_title) );
	118	gtk_label_set_text ( GTK_LABEL(w->status), _("Working...") );
	119	}
	120	gdk_threads_leave();
	121
	122	if ( interface->type == VIK_DATASOURCE_GPSBABEL_DIRECT )
	123	result = a_babel_convert_from (vtl, cmd, (BabelStatusFunc) progress_func, extra, w);
	124	else
	125	result = a_babel_convert_from_shellcommand ( vtl, cmd, extra, (BabelStatusFunc) progress_func, w);
	126
	127	g_free ( cmd );
	128	g_free ( extra );
	129
	130	if (!result) {
	131	gdk_threads_enter();
	132	gtk_label_set_text ( GTK_LABEL(w->status), _("Error: couldn't find gpsbabel.") );
	133	if ( creating_new_layer )
	134	g_object_unref ( G_OBJECT ( vtl ) );
	135	gdk_threads_leave();
	136	}
	137	else {
	138	gdk_threads_enter();
	139	if (w->ok) {
	140	gtk_label_set_text ( GTK_LABEL(w->status), _("Done.") );
	141	if ( creating_new_layer )
	142	vik_aggregate_layer_add_layer( vik_layers_panel_get_top_layer(w->vlp), VIK_LAYER(vtl));
	143	if ( interface->keep_dialog_open ) {
	144	gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT, TRUE );
	145	gtk_dialog_set_response_sensitive ( GTK_DIALOG(w->dialog), GTK_RESPONSE_REJECT, FALSE );
	146	} else {
	147	gtk_dialog_response ( GTK_DIALOG(w->dialog), GTK_RESPONSE_ACCEPT );
	148	}
	149	} else {
	150	/* canceled */
	151	if ( creating_new_layer )
	152	g_object_unref(vtl);
	153	}
	154	}
	155	if ( interface->cleanup_func )
	156	interface->cleanup_func ( w->user_data );
	157
	158	if ( w->ok ) {
	159	w->ok = FALSE;
	160	} else {
	161	g_free ( w );
	162	}
	163
	164	gdk_threads_leave();
	165	g_thread_exit ( NULL );
	166	}
	167
	168
	169	static gchar write_tmp_trwlayer ( VikTrwLayer vtl )
	170	{
	171	int fd_src;
	172	gchar *name_src;
	173	FILE *f;
	174	g_assert ((fd_src = g_file_open_tmp("tmp-viking.XXXXXX", &name_src, NULL)) >= 0);
	175	f = fdopen(fd_src, "w");
	176	a_gpx_write_file(vtl, f);
	177	fclose(f);
	178	f = NULL;
	179	return name_src;
	180	}
	181
	182	/* TODO: write with name of old track */
	183	static gchar write_tmp_track ( VikTrack track )
	184	{
	185	int fd_src;
	186	gchar *name_src;
	187	FILE *f;
	188	g_assert ((fd_src = g_file_open_tmp("tmp-viking.XXXXXX", &name_src, NULL)) >= 0);
	189	f = fdopen(fd_src, "w");
	190	a_gpx_write_track_file("track", track, f); /* Thank you Guilhem! Just when I needed this function... -- Evan */
	191	fclose(f);
	192	f = NULL;
	193	return name_src;
	194	}
	195
	196	/* TODO: cleanup, getr rid of redundancy */
	197
	198	/* depending on type of filter, often only vtl or track will be given.
	199	* the other can be NULL.
	200	*/
	201	static void acquire ( VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikDataSourceInterface interface,
	202	VikTrwLayer vtl, VikTrack track )
	203	{
	204	/* for manual dialogs */
	205	GtkWidget *dialog = NULL;
	206	GtkWidget *status;
	207	gchar cmd, extra;
	208	acq_dialog_widgets_t *w;
	209	gpointer user_data;
	210
	211	/* for UI builder */
	212	gpointer pass_along_data;
	213	VikLayerParamData *paramdatas = NULL;
	214
	215	w_and_interface_t *wi;
	216
	217	/* INIT AND CHECK EXISTENCE */
	218	if ( interface->init_func )
	219	user_data = interface->init_func();
	220	else
	221	user_data = NULL;
	222	pass_along_data = user_data;
	223
	224	if ( interface->check_existence_func ) {
	225	gchar *error_str = interface->check_existence_func();
	226	if ( error_str ) {
	227	a_dialog_error_msg ( GTK_WINDOW(vw), error_str );
	228	g_free ( error_str );
	229	return;
	230	}
	231	}
	232
	233	/* BUILD UI & GET OPTIONS IF NECESSARY. */
	234
	235	/* POSSIBILITY 0: NO OPTIONS. DO NOTHING HERE. */
	236	/* POSSIBILITY 1: ADD_SETUP_WIDGETS_FUNC */
	237	if ( interface->add_setup_widgets_func ) {
	238	dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
	239
	240	interface->add_setup_widgets_func(dialog, vvp, user_data);
	241	gtk_window_set_title ( GTK_WINDOW(dialog), _(interface->window_title) );
	242
	243	if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
	244	interface->cleanup_func(user_data);
	245	gtk_widget_destroy(dialog);
	246	return;
	247	}
	248	}
	249	/* POSSIBILITY 2: UI BUILDER */
	250	else if ( interface->params ) {
	251	paramdatas = a_uibuilder_run_dialog ( GTK_WINDOW(vw),
	252	interface->params, interface->params_count,
	253	interface->params_groups, interface->params_groups_count,
	254	interface->params_defaults );
	255	if ( paramdatas )
	256	pass_along_data = paramdatas;
	257	else
	258	return; /* TODO: do we have to free anything here? */
	259	}
	260
	261	/* CREATE INPUT DATA & GET COMMAND STRING */
	262
	263	if ( interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER ) {
	264	gchar *name_src = write_tmp_trwlayer ( vtl );
	265
	266	((VikDataSourceGetCmdStringFuncWithInput) interface->get_cmd_string_func)
	267	( pass_along_data, &cmd, &extra, name_src );
	268
	269	g_free ( name_src );
	270	/* TODO: delete the tmp file? or delete it only after we're done with it? */
	271	} else if ( interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK ) {
	272	gchar *name_src = write_tmp_trwlayer ( vtl );
	273	gchar *name_src_track = write_tmp_track ( track );
	274
	275	((VikDataSourceGetCmdStringFuncWithInputInput) interface->get_cmd_string_func)
	276	( pass_along_data, &cmd, &extra, name_src, name_src_track );
	277
	278	g_free ( name_src );
	279	g_free ( name_src_track );
	280	} else if ( interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRACK ) {
	281	gchar *name_src_track = write_tmp_track ( track );
	282
	283	((VikDataSourceGetCmdStringFuncWithInput) interface->get_cmd_string_func)
	284	( pass_along_data, &cmd, &extra, name_src_track );
	285
	286	g_free ( name_src_track );
	287	} else
	288	interface->get_cmd_string_func ( pass_along_data, &cmd, &extra );
	289
	290	/* cleanup for option dialogs */
	291	if ( interface->add_setup_widgets_func ) {
	292	gtk_widget_destroy(dialog);
	293	dialog = NULL;
	294	} else if ( interface->params ) {
	295	a_uibuilder_free_paramdatas ( paramdatas, interface->params, interface->params_count );
	296	}
	297
	298	/* LET'S DO IT! */
	299
	300	if ( ! cmd )
	301	return;
	302
	303	w = g_malloc(sizeof(*w));
	304	wi = g_malloc(sizeof(*wi));
	305	wi->w = w;
	306	wi->w->interface = interface;
	307	wi->cmd = cmd;
	308	wi->extra = extra; /* usually input data type (?) */
	309
	310	dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
	311	gtk_dialog_set_response_sensitive ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, FALSE );
	312	gtk_window_set_title ( GTK_WINDOW(dialog), _(interface->window_title) );
	313
	314
	315	w->dialog = dialog;
	316	w->ok = TRUE;
	317	status = gtk_label_new (_("Status: detecting gpsbabel"));
	318	gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), status, FALSE, FALSE, 5 );
	319	gtk_widget_show_all(status);
	320	w->status = status;
	321
	322	w->vw = vw;
	323	w->vlp = vlp;
	324	w->vvp = vvp;
	325	if ( interface->add_progress_widgets_func ) {
	326	interface->add_progress_widgets_func ( dialog, user_data );
	327	}
	328	w->user_data = user_data;
	329
	330
	331	g_thread_create((GThreadFunc)get_from_anything, wi, FALSE, NULL );
	332
	333	gtk_dialog_run ( GTK_DIALOG(dialog) );
	334	if ( w->ok )
	335	w->ok = FALSE; /* tell thread to stop. TODO: add mutex */
	336	else {
	337	g_free ( w ); /* thread has finished; free w */
	338	}
	339	gtk_widget_destroy ( dialog );
	340	}
	341
	342	void a_acquire ( VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikDataSourceInterface interface ) {
	343	acquire ( vw, vlp, vvp, interface, NULL, NULL );
	344	}
	345
	346	static void acquire_trwlayer_callback ( GObject menuitem, gpointer pass_along )
	347	{
	348	VikDataSourceInterface *iface = g_object_get_data ( menuitem, "vik_acq_iface" );
	349	VikWindow *vw = pass_along[0];
	350	VikLayersPanel *vlp = pass_along[1];
	351	VikViewport *vvp = pass_along[2];
	352	VikTrwLayer *vtl = pass_along[3];
	353	VikTrack *tr = pass_along[4];
	354
	355	acquire ( vw, vlp, vvp, iface, vtl, tr );
	356	}
	357
	358	static GtkWidget acquire_build_menu ( VikWindow vw, VikLayersPanel vlp, VikViewport vvp,
	359	VikTrwLayer vtl, VikTrack track, /* both passed to acquire, although for many filters only one ness */
	360	const gchar *menu_title, vik_datasource_inputtype_t inputtype )
	361	{
	362	static gpointer pass_along[4];
	363	GtkWidget menu_item=NULL, menu=NULL;
	364	GtkWidget *item=NULL;
	365	int i;
	366
	367	pass_along[0] = vw;
	368	pass_along[1] = vlp;
	369	pass_along[2] = vvp;
	370	pass_along[3] = vtl;
	371	pass_along[4] = track;
	372
	373	for ( i = 0; i < N_FILTERS; i++ ) {
	374	if ( filters[i]->inputtype == inputtype ) {
	375	if ( ! menu_item ) { /* do this just once, but return NULL if no filters */
	376	menu = gtk_menu_new();
	377	menu_item = gtk_menu_item_new_with_label ( menu_title );
	378	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu );
	379	}
	380
	381	item = gtk_menu_item_new_with_label ( filters[i]->window_title );
	382	g_object_set_data ( G_OBJECT(item), "vik_acq_iface", (gpointer) filters[i] );
	383	g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(acquire_trwlayer_callback), pass_along );
	384	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	385	gtk_widget_show ( item );
	386	}
	387	}
	388
	389	return menu_item;
	390	}
	391
	392	GtkWidget a_acquire_trwlayer_menu (VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikTrwLayer *vtl)
	393	{
	394	return acquire_build_menu ( vw, vlp, vvp, vtl, NULL, "Filter", VIK_DATASOURCE_INPUTTYPE_TRWLAYER );
	395	}
	396
	397	GtkWidget a_acquire_trwlayer_track_menu (VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikTrwLayer *vtl)
	398	{
	399	if ( filter_track == NULL )
	400	return NULL;
	401	else {
	402	gchar *menu_title = g_strdup_printf ( "Filter with %s", filter_track_name );
	403	GtkWidget *rv = acquire_build_menu ( vw, vlp, vvp, vtl, filter_track,
	404	menu_title, VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK );
	405	g_free ( menu_title );
	406	return rv;
	407	}
	408	}
	409
	410	GtkWidget a_acquire_track_menu (VikWindow vw, VikLayersPanel vlp, VikViewport vvp, VikTrack *tr)
	411	{
	412	return acquire_build_menu ( vw, vlp, vvp, NULL, tr, "Filter", VIK_DATASOURCE_INPUTTYPE_TRACK );
	413	}
	414
	415	void a_acquire_set_filter_track ( VikTrack tr, const gchar name )
	416	{
	417	if ( filter_track )
	418	vik_track_free ( filter_track );
	419	if ( filter_track_name )
	420	g_free ( filter_track_name );
	421
	422	filter_track = tr;
	423	vik_track_ref ( tr );
	424
	425	filter_track_name = g_strdup(name);
	426	}