src/vikwebtool_datasource.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
 *
 * Copyright (C) 2013, Rob Norris <rw_norris@hotmail.com>
 *
 * 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 "vikwebtool_datasource.h"
#include <ctype.h>
#include <string.h>

#include <glib.h>
#include <glib/gi18n.h>

#include "globals.h"
#include "acquire.h"
#include "maputils.h"
#include "dialog.h"

static GObjectClass *parent_class;
static GHashTable *last_user_strings = NULL;

static void webtool_datasource_finalize ( GObject *gob );

static gchar *webtool_datasource_get_url ( VikWebtool *self, VikWindow *vw );

static gboolean webtool_needs_user_string ( VikWebtool *self );

typedef struct _VikWebtoolDatasourcePrivate VikWebtoolDatasourcePrivate;

struct _VikWebtoolDatasourcePrivate
{
	gchar *url;
	gchar *url_format_code;
	gchar *file_type;
	gchar *babel_filter_args;
    gchar *input_label;
	gchar *user_string;
};

#define WEBTOOL_DATASOURCE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
                                           VIK_WEBTOOL_DATASOURCE_TYPE,      \
                                           VikWebtoolDatasourcePrivate))

G_DEFINE_TYPE (VikWebtoolDatasource, vik_webtool_datasource, VIK_WEBTOOL_TYPE)

enum
{
	PROP_0,
	PROP_URL,
	PROP_URL_FORMAT_CODE,
	PROP_FILE_TYPE,
	PROP_BABEL_FILTER_ARGS,
    PROP_INPUT_LABEL
};

static void webtool_datasource_set_property (GObject      *object,
                                             guint         property_id,
                                             const GValue *value,
                                             GParamSpec   *pspec)
{
	VikWebtoolDatasource *self = VIK_WEBTOOL_DATASOURCE ( object );
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );

	switch ( property_id ) {

    case PROP_URL:
		g_free ( priv->url );
		priv->url = g_value_dup_string ( value );
		g_debug ( "VikWebtoolDatasource.url: %s", priv->url );
		break;

	case PROP_URL_FORMAT_CODE:
		g_free ( priv->url_format_code );
		priv->url_format_code = g_value_dup_string ( value );
		g_debug ( "VikWebtoolDatasource.url_format_code: %s", priv->url_format_code );
		break;

	case PROP_FILE_TYPE:
		g_free ( priv->file_type );
		priv->file_type = g_value_dup_string ( value );
		g_debug ( "VikWebtoolDatasource.file_type: %s", priv->url_format_code );
		break;

	case PROP_BABEL_FILTER_ARGS:
		g_free ( priv->babel_filter_args );
		priv->babel_filter_args = g_value_dup_string ( value );
		g_debug ( "VikWebtoolDatasource.babel_filter_args: %s", priv->babel_filter_args );
		break;

    case PROP_INPUT_LABEL:
		g_free ( priv->input_label );
		priv->input_label = g_value_dup_string ( value );
		g_debug ( "VikWebtoolDatasource.input_label: %s", priv->input_label );
		break;

	default:
		/* We don't have any other property... */
		G_OBJECT_WARN_INVALID_PROPERTY_ID ( object, property_id, pspec );
		break;
	}
}

static void webtool_datasource_get_property (GObject    *object,
                                             guint       property_id,
                                             GValue     *value,
                                             GParamSpec *pspec)
{
	VikWebtoolDatasource *self = VIK_WEBTOOL_DATASOURCE ( object );
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );

	switch ( property_id ) {

	case PROP_URL:               g_value_set_string ( value, priv->url ); break;
	case PROP_URL_FORMAT_CODE:	 g_value_set_string ( value, priv->url_format_code ); break;
	case PROP_FILE_TYPE:         g_value_set_string ( value, priv->url ); break;
	case PROP_BABEL_FILTER_ARGS: g_value_set_string ( value, priv->babel_filter_args ); break;
	case PROP_INPUT_LABEL:       g_value_set_string ( value, priv->input_label ); break;

	default:
		/* We don't have any other property... */
		G_OBJECT_WARN_INVALID_PROPERTY_ID ( object, property_id, pspec );
		break;
	}
}

typedef struct {
	VikExtTool *self;
	VikWindow *vw;
	VikViewport *vvp;
	GtkWidget *user_string;
} datasource_t;


static void ensure_last_user_strings_hash() {
    if ( last_user_strings == NULL ) {
        last_user_strings = g_hash_table_new_full ( g_str_hash,
                                                    g_str_equal,
                                                    g_free,
                                                    g_free );
    }
}


static gchar *get_last_user_string ( const datasource_t *source ) {
    ensure_last_user_strings_hash();
    gchar *label = vik_ext_tool_get_label ( source->self );
    gchar *last_str = g_hash_table_lookup ( last_user_strings, label );
    g_free( label );
    return last_str;
}


static void set_last_user_string ( const datasource_t *source, const gchar *s ) {
    ensure_last_user_strings_hash();
    g_hash_table_insert ( last_user_strings,
                          vik_ext_tool_get_label ( source->self ),
                          g_strdup ( s ) );
}

static gpointer datasource_init ( acq_vik_t *avt )
{
	datasource_t *data = g_malloc(sizeof(*data));
	data->self = avt->userdata;
	data->vw = avt->vw;
	data->vvp = avt->vvp;
	data->user_string = NULL;
	return data;
}

static void datasource_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
	datasource_t *widgets = (datasource_t *)user_data;
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( widgets->self );
	GtkWidget *user_string_label;
    gchar *label = g_strdup_printf( "%s:", priv->input_label );
	user_string_label = gtk_label_new ( label );
	widgets->user_string = gtk_entry_new ( );

    gchar *last_str = get_last_user_string ( widgets );
    if ( last_str )
        gtk_entry_set_text( GTK_ENTRY( widgets->user_string ), last_str );

	// 'ok' when press return in the entry
	g_signal_connect_swapped (widgets->user_string, "activate", G_CALLBACK(a_dialog_response_accept), dialog);

	/* Packing all widgets */
	GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
	gtk_box_pack_start ( box, user_string_label, FALSE, FALSE, 5 );
	gtk_box_pack_start ( box, widgets->user_string, FALSE, FALSE, 5 );
	gtk_widget_show_all ( dialog );
	gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
	// NB presently the focus is overridden later on by the acquire.c code.
	gtk_widget_grab_focus ( widgets->user_string );

    g_free ( label );
}


static void datasource_get_cmd_string ( gpointer user_data, gchar **cmd, gchar **extra, DownloadMapOptions *options )
{
	datasource_t *data = (datasource_t*) user_data;

	VikWebtool *vwd = VIK_WEBTOOL ( data->self );
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( data->self );

	if ( webtool_needs_user_string ( vwd ) ) {
		priv->user_string = g_strdup ( gtk_entry_get_text ( GTK_ENTRY ( data->user_string ) ) );

        if ( priv->user_string[0] != '\0' ) {
            set_last_user_string ( data, priv->user_string );
        }
    }

	gchar *url = vik_webtool_get_url ( vwd, data->vw );
	g_debug ("%s: %s", __FUNCTION__, url );

	*cmd = g_strdup ( url );

	// Only use first section of the file_type string
	// One can't use values like 'kml -x transform,rte=wpt' in order to do fancy things
	//  since it won't be in the right order for the overall GPSBabel command
	// So prevent any potentially dangerous behaviour
	gchar **parts = NULL;
	if ( priv->file_type )
		parts = g_strsplit ( priv->file_type, " ", 0);
	if ( parts )
		*extra = g_strdup ( parts[0] );
	else
		*extra = NULL;
	g_strfreev ( parts );

	options = NULL;
}

static gboolean datasource_process ( VikTrwLayer *vtl, const gchar *cmd, const gchar *extra, BabelStatusFunc status_cb, acq_dialog_widgets_t *adw, DownloadMapOptions *options )
{
	datasource_t *data = (datasource_t *)adw->user_data;
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( data->self );
	// Dependent on the ExtTool / what extra has been set to...
	// When extra is NULL - then it interprets results as a GPX
	gboolean result = a_babel_convert_from_url_filter ( vtl, cmd, extra, priv->babel_filter_args, status_cb, adw, options);
	return result;
}

static void cleanup ( gpointer data )
{
	g_free ( data );
}

static void webtool_datasource_open ( VikExtTool *self, VikWindow *vw )
{
	gboolean search = webtool_needs_user_string ( VIK_WEBTOOL ( self ) );

	// Use VikDataSourceInterface to give thready goodness controls of downloading stuff (i.e. can cancel the request)

	// Can now create a 'VikDataSourceInterface' on the fly...
	VikDataSourceInterface *vik_datasource_interface = g_malloc(sizeof(VikDataSourceInterface));

	// An 'easy' way of assigning values
	VikDataSourceInterface data = {
		vik_ext_tool_get_label (self),
		vik_ext_tool_get_label (self),
		VIK_DATASOURCE_ADDTOLAYER,
		VIK_DATASOURCE_INPUTTYPE_NONE,
		FALSE, // Maintain current view - rather than setting it to the acquired points
		TRUE,
		TRUE,
		(VikDataSourceInitFunc)               datasource_init,
		(VikDataSourceCheckExistenceFunc)     NULL,
		(VikDataSourceAddSetupWidgetsFunc)    (search ? datasource_add_setup_widgets : NULL),
		(VikDataSourceGetCmdStringFunc)       datasource_get_cmd_string,
		(VikDataSourceProcessFunc)            datasource_process,
		(VikDataSourceProgressFunc)           NULL,
		(VikDataSourceAddProgressWidgetsFunc) NULL,
		(VikDataSourceCleanupFunc)            cleanup,
		(VikDataSourceOffFunc)                NULL,
		NULL,
		0,
		NULL,
		NULL,
		0
	};
	memcpy ( vik_datasource_interface, &data, sizeof(VikDataSourceInterface) );

	a_acquire ( vw, vik_window_layers_panel(vw), vik_window_viewport (vw), data.mode, vik_datasource_interface, self, cleanup );
}

static void vik_webtool_datasource_class_init ( VikWebtoolDatasourceClass *klass )
{
	GObjectClass *gobject_class;
	VikWebtoolClass *base_class;
	GParamSpec *pspec;

	gobject_class = G_OBJECT_CLASS (klass);

	gobject_class->finalize = webtool_datasource_finalize;
	gobject_class->set_property = webtool_datasource_set_property;
	gobject_class->get_property = webtool_datasource_get_property;

	pspec = g_param_spec_string ("url",
	                             "Template URL",
	                             "Set the template URL",
	                             VIKING_URL /* default value */,
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
	                                 PROP_URL,
	                                 pspec);

	pspec = g_param_spec_string ("url_format_code",
	                             "Template URL Format Code",
	                             "Set the template URL format code",
	                             "LRBT", // default value
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
	                                 PROP_URL_FORMAT_CODE,
	                                 pspec);

	pspec = g_param_spec_string ("file_type",
	                             "The file type expected",
	                             "Set the file type",
	                             NULL, // default value ~ equates to internal GPX reading
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
	                                 PROP_FILE_TYPE,
	                                 pspec);

	pspec = g_param_spec_string ("babel_filter_args",
	                             "The command line filter options to pass to gpsbabel",
	                             "Set the command line filter options for gpsbabel",
	                             NULL, // default value
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
	                                 PROP_BABEL_FILTER_ARGS,
	                                 pspec);

	pspec = g_param_spec_string ("input_label",
	                             "The label for the user input box if input is required.",
	                             "Set the label to be shown next to the user input box if an input term is required",
	                             _("Search Term"),
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (gobject_class,
	                                 PROP_INPUT_LABEL,
	                                 pspec);

	parent_class = g_type_class_peek_parent (klass);

	base_class = VIK_WEBTOOL_CLASS ( klass );
	base_class->get_url = webtool_datasource_get_url;

	// Override default open function here:
	VikExtToolClass *ext_tool_class = VIK_EXT_TOOL_CLASS ( klass );
	ext_tool_class->open = webtool_datasource_open;

	g_type_class_add_private (klass, sizeof (VikWebtoolDatasourcePrivate));
}

VikWebtoolDatasource *vik_webtool_datasource_new ()
{
	return VIK_WEBTOOL_DATASOURCE ( g_object_new ( VIK_WEBTOOL_DATASOURCE_TYPE, NULL ) );
}

VikWebtoolDatasource *vik_webtool_datasource_new_with_members ( const gchar *label,
                                                                const gchar *url,
                                                                const gchar *url_format_code,
                                                                const gchar *file_type,
                                                                const gchar *babel_filter_args,
                                                                const gchar *input_label )
{
	VikWebtoolDatasource *result = VIK_WEBTOOL_DATASOURCE ( g_object_new ( VIK_WEBTOOL_DATASOURCE_TYPE,
	                                                        "label", label,
	                                                        "url", url,
	                                                        "url_format_code", url_format_code,
	                                                        "file_type", file_type,
	                                                        "babel_filter_args", babel_filter_args,
                                                            "input_label", input_label,
	                                                        NULL ) );

	return result;
}

static void vik_webtool_datasource_init ( VikWebtoolDatasource *self )
{
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE (self);
	priv->url = NULL;
	priv->url_format_code = NULL;
	priv->file_type = NULL;
	priv->babel_filter_args = NULL;
    priv->input_label = NULL;
	priv->user_string = NULL;
}

static void webtool_datasource_finalize ( GObject *gob )
{
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( gob );
	g_free ( priv->url ); priv->url = NULL;
	g_free ( priv->url_format_code ); priv->url_format_code = NULL;
	g_free ( priv->file_type ); priv->file_type = NULL;
	g_free ( priv->babel_filter_args ); priv->babel_filter_args = NULL;
	g_free ( priv->input_label ); priv->input_label = NULL;
	g_free ( priv->user_string); priv->user_string = NULL;
	G_OBJECT_CLASS(parent_class)->finalize(gob);
}

#define MAX_NUMBER_CODES 7

/**
 * Calculate individual elements (similarly to the VikWebtool Bounds & Center) for *all* potential values
 * Then only values specified by the URL format are used in parameterizing the URL
 */
static gchar *webtool_datasource_get_url ( VikWebtool *self, VikWindow *vw )
{
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );
	VikViewport *viewport = vik_window_viewport ( vw );

	// Get top left and bottom right lat/lon pairs from the viewport
	gdouble min_lat, max_lat, min_lon, max_lon;
	gchar sminlon[G_ASCII_DTOSTR_BUF_SIZE];
	gchar smaxlon[G_ASCII_DTOSTR_BUF_SIZE];
	gchar sminlat[G_ASCII_DTOSTR_BUF_SIZE];
	gchar smaxlat[G_ASCII_DTOSTR_BUF_SIZE];
	vik_viewport_get_min_max_lat_lon ( viewport, &min_lat, &max_lat, &min_lon, &max_lon );

	// Cannot simply use g_strdup_printf and gdouble due to locale.
	// As we compute an URL, we have to think in C locale.
	g_ascii_dtostr (sminlon, G_ASCII_DTOSTR_BUF_SIZE, min_lon);
	g_ascii_dtostr (smaxlon, G_ASCII_DTOSTR_BUF_SIZE, max_lon);
	g_ascii_dtostr (sminlat, G_ASCII_DTOSTR_BUF_SIZE, min_lat);
	g_ascii_dtostr (smaxlat, G_ASCII_DTOSTR_BUF_SIZE, max_lat);

	// Center values
	const VikCoord *coord = vik_viewport_get_center ( viewport );
	struct LatLon ll;
	vik_coord_to_latlon ( coord, &ll );

	gchar scenterlat[G_ASCII_DTOSTR_BUF_SIZE];
	gchar scenterlon[G_ASCII_DTOSTR_BUF_SIZE];
	g_ascii_dtostr (scenterlat, G_ASCII_DTOSTR_BUF_SIZE, ll.lat);
	g_ascii_dtostr (scenterlon, G_ASCII_DTOSTR_BUF_SIZE, ll.lon);

	guint8 zoom = 17; // A zoomed in default
	// zoom - ideally x & y factors need to be the same otherwise use the default
	if ( vik_viewport_get_xmpp ( viewport ) == vik_viewport_get_ympp ( viewport ) )
		zoom = map_utils_mpp_to_zoom_level ( vik_viewport_get_zoom ( viewport ) );

	gchar szoom[G_ASCII_DTOSTR_BUF_SIZE];
	g_snprintf ( szoom, G_ASCII_DTOSTR_BUF_SIZE, "%d", zoom );

	gint len = 0;
	if ( priv->url_format_code )
		len = strlen ( priv->url_format_code );
	if ( len > MAX_NUMBER_CODES )
		len = MAX_NUMBER_CODES;

	gchar* values[MAX_NUMBER_CODES];
	int i;
	for ( i = 0; i < MAX_NUMBER_CODES; i++ ) {
		values[i] = '\0';
	}

	for ( i = 0; i < len; i++ ) {
		switch ( g_ascii_toupper ( priv->url_format_code[i] ) ) {
		case 'L': values[i] = g_strdup ( sminlon ); break;
		case 'R': values[i] = g_strdup ( smaxlon ); break;
		case 'B': values[i] = g_strdup ( sminlat ); break;
		case 'T': values[i] = g_strdup ( smaxlat ); break;
		case 'A': values[i] = g_strdup ( scenterlat ); break;
		case 'O': values[i] = g_strdup ( scenterlon ); break;
		case 'Z': values[i] = g_strdup ( szoom ); break;
		case 'S': values[i] = g_strdup ( priv->user_string ); break;
		default: break;
		}
	}

	gchar *url = g_strdup_printf ( priv->url, values[0], values[1], values[2], values[3], values[4], values[5], values[6] );

	for ( i = 0; i < MAX_NUMBER_CODES; i++ ) {
		if ( values[i] != '\0' )
			g_free ( values[i] );
	}

	return url;
}

// NB Only works for ascii strings
char* strcasestr2(const char *dst, const char *src)
{
	if ( !dst || !src )
		return NULL;

	if(src[0] == '\0')
		return (char*)dst;

	int len = strlen(src) - 1;
	char sc = tolower(src[0]);
	for(char dc = *dst; (dc = *dst); dst++) {
		dc = tolower(dc);
		if(sc == dc && (len == 0 || !strncasecmp(dst+1, src+1, len)))
			return (char*)dst;
	}

	return NULL;
}

/**
 * Returns true if the URL format contains 'S' -- that is, a search term entry
 * box needs to be displayed
 */
static gboolean webtool_needs_user_string ( VikWebtool *self )
{
	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );
	// For some reason (my) Windows build gets built with -D_GNU_SOURCE
#if (_GNU_SOURCE && !WINDOWS)
	return (strcasestr(priv->url_format_code, "S") != NULL);
#else
	return (strcasestr2(priv->url_format_code, "S") != NULL);
#endif
}
Commit	Line	Data
	1	/* -- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -- */
	2	/*
	3	* viking -- GPS Data and Topo Analyzer, Explorer, and Manager
	4	*
	5	* Copyright (C) 2013, Rob Norris <rw_norris@hotmail.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*
	21	*/
	22
	23	#ifdef HAVE_CONFIG_H
	24	#include "config.h"
	25	#endif
	26
	27	#include "vikwebtool_datasource.h"
	28	#include <ctype.h>
	29	#include <string.h>
	30
	31	#include <glib.h>
	32	#include <glib/gi18n.h>
	33
	34	#include "globals.h"
	35	#include "acquire.h"
	36	#include "maputils.h"
	37	#include "dialog.h"
	38
	39	static GObjectClass *parent_class;
	40	static GHashTable *last_user_strings = NULL;
	41
	42	static void webtool_datasource_finalize ( GObject *gob );
	43
	44	static gchar webtool_datasource_get_url ( VikWebtool self, VikWindow *vw );
	45
	46	static gboolean webtool_needs_user_string ( VikWebtool *self );
	47
	48	typedef struct _VikWebtoolDatasourcePrivate VikWebtoolDatasourcePrivate;
	49
	50	struct _VikWebtoolDatasourcePrivate
	51	{
	52	gchar *url;
	53	gchar *url_format_code;
	54	gchar *file_type;
	55	gchar *babel_filter_args;
	56	gchar *input_label;
	57	gchar *user_string;
	58	};
	59
	60	#define WEBTOOL_DATASOURCE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
	61	VIK_WEBTOOL_DATASOURCE_TYPE, \
	62	VikWebtoolDatasourcePrivate))
	63
	64	G_DEFINE_TYPE (VikWebtoolDatasource, vik_webtool_datasource, VIK_WEBTOOL_TYPE)
	65
	66	enum
	67	{
	68	PROP_0,
	69	PROP_URL,
	70	PROP_URL_FORMAT_CODE,
	71	PROP_FILE_TYPE,
	72	PROP_BABEL_FILTER_ARGS,
	73	PROP_INPUT_LABEL
	74	};
	75
	76	static void webtool_datasource_set_property (GObject *object,
	77	guint property_id,
	78	const GValue *value,
	79	GParamSpec *pspec)
	80	{
	81	VikWebtoolDatasource *self = VIK_WEBTOOL_DATASOURCE ( object );
	82	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );
	83
	84	switch ( property_id ) {
	85
	86	case PROP_URL:
	87	g_free ( priv->url );
	88	priv->url = g_value_dup_string ( value );
	89	g_debug ( "VikWebtoolDatasource.url: %s", priv->url );
	90	break;
	91
	92	case PROP_URL_FORMAT_CODE:
	93	g_free ( priv->url_format_code );
	94	priv->url_format_code = g_value_dup_string ( value );
	95	g_debug ( "VikWebtoolDatasource.url_format_code: %s", priv->url_format_code );
	96	break;
	97
	98	case PROP_FILE_TYPE:
	99	g_free ( priv->file_type );
	100	priv->file_type = g_value_dup_string ( value );
	101	g_debug ( "VikWebtoolDatasource.file_type: %s", priv->url_format_code );
	102	break;
	103
	104	case PROP_BABEL_FILTER_ARGS:
	105	g_free ( priv->babel_filter_args );
	106	priv->babel_filter_args = g_value_dup_string ( value );
	107	g_debug ( "VikWebtoolDatasource.babel_filter_args: %s", priv->babel_filter_args );
	108	break;
	109
	110	case PROP_INPUT_LABEL:
	111	g_free ( priv->input_label );
	112	priv->input_label = g_value_dup_string ( value );
	113	g_debug ( "VikWebtoolDatasource.input_label: %s", priv->input_label );
	114	break;
	115
	116	default:
	117	/* We don't have any other property... */
	118	G_OBJECT_WARN_INVALID_PROPERTY_ID ( object, property_id, pspec );
	119	break;
	120	}
	121	}
	122
	123	static void webtool_datasource_get_property (GObject *object,
	124	guint property_id,
	125	GValue *value,
	126	GParamSpec *pspec)
	127	{
	128	VikWebtoolDatasource *self = VIK_WEBTOOL_DATASOURCE ( object );
	129	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );
	130
	131	switch ( property_id ) {
	132
	133	case PROP_URL: g_value_set_string ( value, priv->url ); break;
	134	case PROP_URL_FORMAT_CODE: g_value_set_string ( value, priv->url_format_code ); break;
	135	case PROP_FILE_TYPE: g_value_set_string ( value, priv->url ); break;
	136	case PROP_BABEL_FILTER_ARGS: g_value_set_string ( value, priv->babel_filter_args ); break;
	137	case PROP_INPUT_LABEL: g_value_set_string ( value, priv->input_label ); break;
	138
	139	default:
	140	/* We don't have any other property... */
	141	G_OBJECT_WARN_INVALID_PROPERTY_ID ( object, property_id, pspec );
	142	break;
	143	}
	144	}
	145
	146	typedef struct {
	147	VikExtTool *self;
	148	VikWindow *vw;
	149	VikViewport *vvp;
	150	GtkWidget *user_string;
	151	} datasource_t;
	152
	153
	154	static void ensure_last_user_strings_hash() {
	155	if ( last_user_strings == NULL ) {
	156	last_user_strings = g_hash_table_new_full ( g_str_hash,
	157	g_str_equal,
	158	g_free,
	159	g_free );
	160	}
	161	}
	162
	163
	164	static gchar get_last_user_string ( const datasource_t source ) {
	165	ensure_last_user_strings_hash();
	166	gchar *label = vik_ext_tool_get_label ( source->self );
	167	gchar *last_str = g_hash_table_lookup ( last_user_strings, label );
	168	g_free( label );
	169	return last_str;
	170	}
	171
	172
	173	static void set_last_user_string ( const datasource_t source, const gchar s ) {
	174	ensure_last_user_strings_hash();
	175	g_hash_table_insert ( last_user_strings,
	176	vik_ext_tool_get_label ( source->self ),
	177	g_strdup ( s ) );
	178	}
	179
	180	static gpointer datasource_init ( acq_vik_t *avt )
	181	{
	182	datasource_t data = g_malloc(sizeof(data));
	183	data->self = avt->userdata;
	184	data->vw = avt->vw;
	185	data->vvp = avt->vvp;
	186	data->user_string = NULL;
	187	return data;
	188	}
	189
	190	static void datasource_add_setup_widgets ( GtkWidget dialog, VikViewport vvp, gpointer user_data )
	191	{
	192	datasource_t widgets = (datasource_t )user_data;
	193	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( widgets->self );
	194	GtkWidget *user_string_label;
	195	gchar *label = g_strdup_printf( "%s:", priv->input_label );
	196	user_string_label = gtk_label_new ( label );
	197	widgets->user_string = gtk_entry_new ( );
	198
	199	gchar *last_str = get_last_user_string ( widgets );
	200	if ( last_str )
	201	gtk_entry_set_text( GTK_ENTRY( widgets->user_string ), last_str );
	202
	203	// 'ok' when press return in the entry
	204	g_signal_connect_swapped (widgets->user_string, "activate", G_CALLBACK(a_dialog_response_accept), dialog);
	205
	206	/* Packing all widgets */
	207	GtkBox *box = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
	208	gtk_box_pack_start ( box, user_string_label, FALSE, FALSE, 5 );
	209	gtk_box_pack_start ( box, widgets->user_string, FALSE, FALSE, 5 );
	210	gtk_widget_show_all ( dialog );
	211	gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
	212	// NB presently the focus is overridden later on by the acquire.c code.
	213	gtk_widget_grab_focus ( widgets->user_string );
	214
	215	g_free ( label );
	216	}
	217
	218
	219
	220	static void datasource_get_cmd_string ( gpointer user_data, gchar cmd, gchar extra, DownloadMapOptions *options )
	221	{
	222	datasource_t data = (datasource_t) user_data;
	223
	224	VikWebtool *vwd = VIK_WEBTOOL ( data->self );
	225	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( data->self );
	226
	227	if ( webtool_needs_user_string ( vwd ) ) {
	228	priv->user_string = g_strdup ( gtk_entry_get_text ( GTK_ENTRY ( data->user_string ) ) );
	229
	230	if ( priv->user_string[0] != '\0' ) {
	231	set_last_user_string ( data, priv->user_string );
	232	}
	233	}
	234
	235	gchar *url = vik_webtool_get_url ( vwd, data->vw );
	236	g_debug ("%s: %s", __FUNCTION__, url );
	237
	238	*cmd = g_strdup ( url );
	239
	240	// Only use first section of the file_type string
	241	// One can't use values like 'kml -x transform,rte=wpt' in order to do fancy things
	242	// since it won't be in the right order for the overall GPSBabel command
	243	// So prevent any potentially dangerous behaviour
	244	gchar **parts = NULL;
	245	if ( priv->file_type )
	246	parts = g_strsplit ( priv->file_type, " ", 0);
	247	if ( parts )
	248	*extra = g_strdup ( parts[0] );
	249	else
	250	*extra = NULL;
	251	g_strfreev ( parts );
	252
	253	options = NULL;
	254	}
	255
	256	static gboolean datasource_process ( VikTrwLayer vtl, const gchar cmd, const gchar extra, BabelStatusFunc status_cb, acq_dialog_widgets_t adw, DownloadMapOptions *options )
	257	{
	258	datasource_t data = (datasource_t )adw->user_data;
	259	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( data->self );
	260	// Dependent on the ExtTool / what extra has been set to...
	261	// When extra is NULL - then it interprets results as a GPX
	262	gboolean result = a_babel_convert_from_url_filter ( vtl, cmd, extra, priv->babel_filter_args, status_cb, adw, options);
	263	return result;
	264	}
	265
	266	static void cleanup ( gpointer data )
	267	{
	268	g_free ( data );
	269	}
	270
	271	static void webtool_datasource_open ( VikExtTool self, VikWindow vw )
	272	{
	273	gboolean search = webtool_needs_user_string ( VIK_WEBTOOL ( self ) );
	274
	275	// Use VikDataSourceInterface to give thready goodness controls of downloading stuff (i.e. can cancel the request)
	276
	277	// Can now create a 'VikDataSourceInterface' on the fly...
	278	VikDataSourceInterface *vik_datasource_interface = g_malloc(sizeof(VikDataSourceInterface));
	279
	280	// An 'easy' way of assigning values
	281	VikDataSourceInterface data = {
	282	vik_ext_tool_get_label (self),
	283	vik_ext_tool_get_label (self),
	284	VIK_DATASOURCE_ADDTOLAYER,
	285	VIK_DATASOURCE_INPUTTYPE_NONE,
	286	FALSE, // Maintain current view - rather than setting it to the acquired points
	287	TRUE,
	288	TRUE,
	289	(VikDataSourceInitFunc) datasource_init,
	290	(VikDataSourceCheckExistenceFunc) NULL,
	291	(VikDataSourceAddSetupWidgetsFunc) (search ? datasource_add_setup_widgets : NULL),
	292	(VikDataSourceGetCmdStringFunc) datasource_get_cmd_string,
	293	(VikDataSourceProcessFunc) datasource_process,
	294	(VikDataSourceProgressFunc) NULL,
	295	(VikDataSourceAddProgressWidgetsFunc) NULL,
	296	(VikDataSourceCleanupFunc) cleanup,
	297	(VikDataSourceOffFunc) NULL,
	298	NULL,
	299	0,
	300	NULL,
	301	NULL,
	302	0
	303	};
	304	memcpy ( vik_datasource_interface, &data, sizeof(VikDataSourceInterface) );
	305
	306	a_acquire ( vw, vik_window_layers_panel(vw), vik_window_viewport (vw), data.mode, vik_datasource_interface, self, cleanup );
	307	}
	308
	309	static void vik_webtool_datasource_class_init ( VikWebtoolDatasourceClass *klass )
	310	{
	311	GObjectClass *gobject_class;
	312	VikWebtoolClass *base_class;
	313	GParamSpec *pspec;
	314
	315	gobject_class = G_OBJECT_CLASS (klass);
	316
	317	gobject_class->finalize = webtool_datasource_finalize;
	318	gobject_class->set_property = webtool_datasource_set_property;
	319	gobject_class->get_property = webtool_datasource_get_property;
	320
	321	pspec = g_param_spec_string ("url",
	322	"Template URL",
	323	"Set the template URL",
	324	VIKING_URL /* default value */,
	325	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	326	g_object_class_install_property (gobject_class,
	327	PROP_URL,
	328	pspec);
	329
	330	pspec = g_param_spec_string ("url_format_code",
	331	"Template URL Format Code",
	332	"Set the template URL format code",
	333	"LRBT", // default value
	334	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	335	g_object_class_install_property (gobject_class,
	336	PROP_URL_FORMAT_CODE,
	337	pspec);
	338
	339	pspec = g_param_spec_string ("file_type",
	340	"The file type expected",
	341	"Set the file type",
	342	NULL, // default value ~ equates to internal GPX reading
	343	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	344	g_object_class_install_property (gobject_class,
	345	PROP_FILE_TYPE,
	346	pspec);
	347
	348	pspec = g_param_spec_string ("babel_filter_args",
	349	"The command line filter options to pass to gpsbabel",
	350	"Set the command line filter options for gpsbabel",
	351	NULL, // default value
	352	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	353	g_object_class_install_property (gobject_class,
	354	PROP_BABEL_FILTER_ARGS,
	355	pspec);
	356
	357	pspec = g_param_spec_string ("input_label",
	358	"The label for the user input box if input is required.",
	359	"Set the label to be shown next to the user input box if an input term is required",
	360	_("Search Term"),
	361	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	362	g_object_class_install_property (gobject_class,
	363	PROP_INPUT_LABEL,
	364	pspec);
	365
	366	parent_class = g_type_class_peek_parent (klass);
	367
	368	base_class = VIK_WEBTOOL_CLASS ( klass );
	369	base_class->get_url = webtool_datasource_get_url;
	370
	371	// Override default open function here:
	372	VikExtToolClass *ext_tool_class = VIK_EXT_TOOL_CLASS ( klass );
	373	ext_tool_class->open = webtool_datasource_open;
	374
	375	g_type_class_add_private (klass, sizeof (VikWebtoolDatasourcePrivate));
	376	}
	377
	378	VikWebtoolDatasource *vik_webtool_datasource_new ()
	379	{
	380	return VIK_WEBTOOL_DATASOURCE ( g_object_new ( VIK_WEBTOOL_DATASOURCE_TYPE, NULL ) );
	381	}
	382
	383	VikWebtoolDatasource vik_webtool_datasource_new_with_members ( const gchar label,
	384	const gchar *url,
	385	const gchar *url_format_code,
	386	const gchar *file_type,
	387	const gchar *babel_filter_args,
	388	const gchar *input_label )
	389	{
	390	VikWebtoolDatasource *result = VIK_WEBTOOL_DATASOURCE ( g_object_new ( VIK_WEBTOOL_DATASOURCE_TYPE,
	391	"label", label,
	392	"url", url,
	393	"url_format_code", url_format_code,
	394	"file_type", file_type,
	395	"babel_filter_args", babel_filter_args,
	396	"input_label", input_label,
	397	NULL ) );
	398
	399	return result;
	400	}
	401
	402	static void vik_webtool_datasource_init ( VikWebtoolDatasource *self )
	403	{
	404	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE (self);
	405	priv->url = NULL;
	406	priv->url_format_code = NULL;
	407	priv->file_type = NULL;
	408	priv->babel_filter_args = NULL;
	409	priv->input_label = NULL;
	410	priv->user_string = NULL;
	411	}
	412
	413	static void webtool_datasource_finalize ( GObject *gob )
	414	{
	415	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( gob );
	416	g_free ( priv->url ); priv->url = NULL;
	417	g_free ( priv->url_format_code ); priv->url_format_code = NULL;
	418	g_free ( priv->file_type ); priv->file_type = NULL;
	419	g_free ( priv->babel_filter_args ); priv->babel_filter_args = NULL;
	420	g_free ( priv->input_label ); priv->input_label = NULL;
	421	g_free ( priv->user_string); priv->user_string = NULL;
	422	G_OBJECT_CLASS(parent_class)->finalize(gob);
	423	}
	424
	425	#define MAX_NUMBER_CODES 7
	426
	427	/**
	428	* Calculate individual elements (similarly to the VikWebtool Bounds & Center) for all potential values
	429	* Then only values specified by the URL format are used in parameterizing the URL
	430	*/
	431	static gchar webtool_datasource_get_url ( VikWebtool self, VikWindow *vw )
	432	{
	433	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );
	434	VikViewport *viewport = vik_window_viewport ( vw );
	435
	436	// Get top left and bottom right lat/lon pairs from the viewport
	437	gdouble min_lat, max_lat, min_lon, max_lon;
	438	gchar sminlon[G_ASCII_DTOSTR_BUF_SIZE];
	439	gchar smaxlon[G_ASCII_DTOSTR_BUF_SIZE];
	440	gchar sminlat[G_ASCII_DTOSTR_BUF_SIZE];
	441	gchar smaxlat[G_ASCII_DTOSTR_BUF_SIZE];
	442	vik_viewport_get_min_max_lat_lon ( viewport, &min_lat, &max_lat, &min_lon, &max_lon );
	443
	444	// Cannot simply use g_strdup_printf and gdouble due to locale.
	445	// As we compute an URL, we have to think in C locale.
	446	g_ascii_dtostr (sminlon, G_ASCII_DTOSTR_BUF_SIZE, min_lon);
	447	g_ascii_dtostr (smaxlon, G_ASCII_DTOSTR_BUF_SIZE, max_lon);
	448	g_ascii_dtostr (sminlat, G_ASCII_DTOSTR_BUF_SIZE, min_lat);
	449	g_ascii_dtostr (smaxlat, G_ASCII_DTOSTR_BUF_SIZE, max_lat);
	450
	451	// Center values
	452	const VikCoord *coord = vik_viewport_get_center ( viewport );
	453	struct LatLon ll;
	454	vik_coord_to_latlon ( coord, &ll );
	455
	456	gchar scenterlat[G_ASCII_DTOSTR_BUF_SIZE];
	457	gchar scenterlon[G_ASCII_DTOSTR_BUF_SIZE];
	458	g_ascii_dtostr (scenterlat, G_ASCII_DTOSTR_BUF_SIZE, ll.lat);
	459	g_ascii_dtostr (scenterlon, G_ASCII_DTOSTR_BUF_SIZE, ll.lon);
	460
	461	guint8 zoom = 17; // A zoomed in default
	462	// zoom - ideally x & y factors need to be the same otherwise use the default
	463	if ( vik_viewport_get_xmpp ( viewport ) == vik_viewport_get_ympp ( viewport ) )
	464	zoom = map_utils_mpp_to_zoom_level ( vik_viewport_get_zoom ( viewport ) );
	465
	466	gchar szoom[G_ASCII_DTOSTR_BUF_SIZE];
	467	g_snprintf ( szoom, G_ASCII_DTOSTR_BUF_SIZE, "%d", zoom );
	468
	469	gint len = 0;
	470	if ( priv->url_format_code )
	471	len = strlen ( priv->url_format_code );
	472	if ( len > MAX_NUMBER_CODES )
	473	len = MAX_NUMBER_CODES;
	474
	475	gchar* values[MAX_NUMBER_CODES];
	476	int i;
	477	for ( i = 0; i < MAX_NUMBER_CODES; i++ ) {
	478	values[i] = '\0';
	479	}
	480
	481	for ( i = 0; i < len; i++ ) {
	482	switch ( g_ascii_toupper ( priv->url_format_code[i] ) ) {
	483	case 'L': values[i] = g_strdup ( sminlon ); break;
	484	case 'R': values[i] = g_strdup ( smaxlon ); break;
	485	case 'B': values[i] = g_strdup ( sminlat ); break;
	486	case 'T': values[i] = g_strdup ( smaxlat ); break;
	487	case 'A': values[i] = g_strdup ( scenterlat ); break;
	488	case 'O': values[i] = g_strdup ( scenterlon ); break;
	489	case 'Z': values[i] = g_strdup ( szoom ); break;
	490	case 'S': values[i] = g_strdup ( priv->user_string ); break;
	491	default: break;
	492	}
	493	}
	494
	495	gchar *url = g_strdup_printf ( priv->url, values[0], values[1], values[2], values[3], values[4], values[5], values[6] );
	496
	497	for ( i = 0; i < MAX_NUMBER_CODES; i++ ) {
	498	if ( values[i] != '\0' )
	499	g_free ( values[i] );
	500	}
	501
	502	return url;
	503	}
	504
	505	// NB Only works for ascii strings
	506	char* strcasestr2(const char dst, const char src)
	507	{
	508	if ( !dst \|\| !src )
	509	return NULL;
	510
	511	if(src[0] == '\0')
	512	return (char*)dst;
	513
	514	int len = strlen(src) - 1;
	515	char sc = tolower(src[0]);
	516	for(char dc = dst; (dc = dst); dst++) {
	517	dc = tolower(dc);
	518	if(sc == dc && (len == 0 \|\| !strncasecmp(dst+1, src+1, len)))
	519	return (char*)dst;
	520	}
	521
	522	return NULL;
	523	}
	524
	525	/**
	526	* Returns true if the URL format contains 'S' -- that is, a search term entry
	527	* box needs to be displayed
	528	*/
	529	static gboolean webtool_needs_user_string ( VikWebtool *self )
	530	{
	531	VikWebtoolDatasourcePrivate *priv = WEBTOOL_DATASOURCE_GET_PRIVATE ( self );
	532	// For some reason (my) Windows build gets built with -D_GNU_SOURCE
	533	#if (_GNU_SOURCE && !WINDOWS)
	534	return (strcasestr(priv->url_format_code, "S") != NULL);
	535	#else
	536	return (strcasestr2(priv->url_format_code, "S") != NULL);
	537	#endif
	538	}