src/vikgotoxmltool.c

/*
 * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
 *
 * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
 * Copyright (C) 2009, Guilhem Bonnefille <guilhem.bonnefille@gmail.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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_MATH_H
#include "math.h"
#endif
#include <glib.h>
#include <glib/gstdio.h>
#include <glib/gprintf.h>
#include <glib/gi18n.h>

#include "viking.h"

#include "vikgotoxmltool.h"


static void _goto_xml_tool_class_init ( VikGotoXmlToolClass *klass );
static void _goto_xml_tool_init ( VikGotoXmlTool *self );

static void _goto_xml_tool_finalize ( GObject *gob );

static gchar *_goto_xml_tool_get_url_format ( VikGotoTool *self );
static gboolean _goto_xml_tool_parse_file_for_latlon(VikGotoTool *self, gchar *filename, struct LatLon *ll);

typedef struct _VikGotoXmlToolPrivate VikGotoXmlToolPrivate;

struct _VikGotoXmlToolPrivate
{
  gchar *url_format;
  gchar *lat_path;
  gchar *lat_attr;
  gchar *lon_path;
  gchar *lon_attr;

  struct LatLon ll;
};

#define GOTO_XML_TOOL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
                                        VIK_GOTO_XML_TOOL_TYPE,          \
                                        VikGotoXmlToolPrivate))

GType vik_goto_xml_tool_get_type()
{
  static GType w_type = 0;

  if (!w_type)
  {
    static const GTypeInfo w_info =
    {
      sizeof (VikGotoXmlToolClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) _goto_xml_tool_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (VikGotoXmlTool),
      0,
      (GInstanceInitFunc) _goto_xml_tool_init,
    };
    w_type = g_type_register_static ( VIK_GOTO_TOOL_TYPE, "VikGotoXmlTool", &w_info, 0 );
  }

  return w_type;
}

enum
{
  PROP_0,

  PROP_URL_FORMAT,
  PROP_LAT_PATH,
  PROP_LAT_ATTR,
  PROP_LON_PATH,
  PROP_LON_ATTR,
};

static void
_goto_xml_tool_set_property (GObject      *object,
                             guint         property_id,
                             const GValue *value,
                             GParamSpec   *pspec)
{
  VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (object);
  VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
  gchar **splitted = NULL;

  switch (property_id)
    {
    case PROP_URL_FORMAT:
      g_free (priv->url_format);
      priv->url_format = g_value_dup_string (value);
      break;

    case PROP_LAT_PATH:
      splitted = g_strsplit (g_value_get_string (value), "@", 2);
      g_free (priv->lat_path);
      priv->lat_path = splitted[0];
      if (splitted[1])
      {
        g_object_set (object, "lat-attr", splitted[1], NULL);
        g_free (splitted[1]);
      }
      /* only free the tab, not the strings */
      g_free (splitted);
      splitted = NULL;
      break;

    case PROP_LAT_ATTR:
      /* Avoid to overwrite XPATH value */
      /* NB: This disable future overwriting,
         but as property is CONSTRUCT_ONLY there is no matter */
      if (!priv->lat_attr || g_value_get_string (value))
      {
        g_free (priv->lat_attr);
        priv->lat_attr = g_value_dup_string (value);
      }
      break;

    case PROP_LON_PATH:
      splitted = g_strsplit (g_value_get_string (value), "@", 2);
      g_free (priv->lon_path);
      priv->lon_path = splitted[0];
      if (splitted[1])
      {
        g_object_set (object, "lon-attr", splitted[1], NULL);
        g_free (splitted[1]);
      }
      /* only free the tab, not the strings */
      g_free (splitted);
      splitted = NULL;
      break;

    case PROP_LON_ATTR:
      /* Avoid to overwrite XPATH value */
      /* NB: This disable future overwriting,
         but as property is CONSTRUCT_ONLY there is no matter */
      if (!priv->lon_attr || g_value_get_string (value))
      {
        g_free (priv->lon_attr);
        priv->lon_attr = g_value_dup_string (value);
      }
      break;

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

static void
_goto_xml_tool_get_property (GObject    *object,
                             guint       property_id,
                             GValue     *value,
                             GParamSpec *pspec)
{
  VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (object);
  VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);

  switch (property_id)
    {
    case PROP_URL_FORMAT:
      g_value_set_string (value, priv->url_format);
      break;

    case PROP_LAT_PATH:
      g_value_set_string (value, priv->lat_path);
      break;

    case PROP_LAT_ATTR:
      g_value_set_string (value, priv->lat_attr);
      break;

    case PROP_LON_PATH:
      g_value_set_string (value, priv->lon_path);
      break;

    case PROP_LON_ATTR:
      g_value_set_string (value, priv->lon_attr);
      break;

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

static void _goto_xml_tool_class_init ( VikGotoXmlToolClass *klass )
{
  GObjectClass *object_class;
  VikGotoToolClass *parent_class;
  GParamSpec *pspec;

  object_class = G_OBJECT_CLASS (klass);

  object_class->finalize = _goto_xml_tool_finalize;
  object_class->set_property = _goto_xml_tool_set_property;
  object_class->get_property = _goto_xml_tool_get_property;


  pspec = g_param_spec_string ("url-format",
                               "URL format",
                               "The format of the URL",
                               "<no-set>" /* default value */,
                               G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
  g_object_class_install_property (object_class,
                                   PROP_URL_FORMAT,
                                   pspec);

  pspec = g_param_spec_string ("lat-path",
                               "Latitude path",
                               "XPath of the latitude",
                               "<no-set>" /* default value */,
                               G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
  g_object_class_install_property (object_class,
                                   PROP_LAT_PATH,
                                   pspec);

  pspec = g_param_spec_string ("lat-attr",
                               "Latitude attribute",
                               "XML attribute of the latitude",
                               NULL /* default value */,
                               G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
  g_object_class_install_property (object_class,
                                   PROP_LAT_ATTR,
                                   pspec);

  pspec = g_param_spec_string ("lon-path",
                               "Longitude path",
                               "XPath of the longitude",
                               "<no-set>" /* default value */,
                               G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
  g_object_class_install_property (object_class,
                                   PROP_LON_PATH,
                                   pspec);

  pspec = g_param_spec_string ("lon-attr",
                               "Longitude attribute",
                               "XML attribute of the longitude",
                               NULL /* default value */,
                               G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
  g_object_class_install_property (object_class,
                                   PROP_LON_ATTR,
                                   pspec);

  parent_class = VIK_GOTO_TOOL_CLASS (klass);

  parent_class->get_url_format = _goto_xml_tool_get_url_format;
  parent_class->parse_file_for_latlon = _goto_xml_tool_parse_file_for_latlon;

  g_type_class_add_private (klass, sizeof (VikGotoXmlToolPrivate));
}

VikGotoXmlTool *vik_goto_xml_tool_new ()
{
  return VIK_GOTO_XML_TOOL ( g_object_new ( VIK_GOTO_XML_TOOL_TYPE, "label", "Google", NULL ) );
}

static void _goto_xml_tool_init ( VikGotoXmlTool *self )
{
  VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
  priv->url_format = NULL;
  priv->lat_path = NULL;
  priv->lat_attr = NULL;
  priv->lon_path = NULL;
  priv->lon_attr = NULL;
  //
  priv->ll.lat = NAN;
  priv->ll.lon = NAN;
}

static void _goto_xml_tool_finalize ( GObject *gob )
{
  G_OBJECT_GET_CLASS(gob)->finalize(gob);
}

static gboolean
stack_is_path (const GSList *stack,
               const gchar  *path)
{
  gboolean equal = TRUE;
  int stack_len = g_list_length((GList *)stack);
  int i = 0;
  i = stack_len - 1;
  while (equal == TRUE && i >= 0)
  {
    if (*path != '/')
      equal = FALSE;
    else
      path++;
    const gchar *current = g_list_nth_data((GList *)stack, i);
    size_t len = strlen(current);
    if (strncmp(path, current, len) != 0 )
      equal = FALSE;
    else
    {
      path += len;
    }
    i--;
  }
  if (*path != '\0')
    equal = FALSE;
  return equal;
}

/* Called for open tags <foo bar="baz"> */
static void
_start_element (GMarkupParseContext *context,
                const gchar         *element_name,
                const gchar        **attribute_names,
                const gchar        **attribute_values,
                gpointer             user_data,
                GError             **error)
{
  VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (user_data);
  VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
  const GSList *stack = g_markup_parse_context_get_element_stack (context);
  /* Longitude */
  if (priv->lon_attr != NULL && isnan(priv->ll.lon) && stack_is_path (stack, priv->lon_path))
	{
		int i=0;
		while (attribute_names[i] != NULL)
		{
			if (strcmp (attribute_names[i], priv->lon_attr) == 0)
			{
				priv->ll.lon = g_ascii_strtod(attribute_values[i], NULL);
			}
			i++;
		}
	}
  /* Latitude */
  if (priv->lat_attr != NULL && isnan(priv->ll.lat) && stack_is_path (stack, priv->lat_path))
	{
		int i=0;
		while (attribute_names[i] != NULL)
		{
			if (strcmp (attribute_names[i], priv->lat_attr) == 0)
			{
				priv->ll.lat = g_ascii_strtod(attribute_values[i], NULL);
			}
			i++;
		}
	}
}

/* Called for character data */
/* text is not nul-terminated */
static void
_text (GMarkupParseContext *context,
       const gchar         *text,
       gsize                text_len,
       gpointer             user_data,
       GError             **error)
{
  VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (user_data);
  VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
  const GSList *stack = g_markup_parse_context_get_element_stack (context);
  gchar *textl = g_strndup(text, text_len);
  /* Store only first result */
	if (priv->lat_attr == NULL && isnan(priv->ll.lat) && stack_is_path (stack, priv->lat_path))
	{
    priv->ll.lat = g_ascii_strtod(textl, NULL);
	}
	if (priv->lon_attr == NULL && isnan(priv->ll.lon) && stack_is_path (stack, priv->lon_path))
	{
    priv->ll.lon = g_ascii_strtod(textl, NULL);
	}
  g_free(textl);
}

static gboolean
_goto_xml_tool_parse_file_for_latlon(VikGotoTool *self, gchar *filename, struct LatLon *ll)
{
	GMarkupParser xml_parser;
	GMarkupParseContext *xml_context = NULL;
	GError *error = NULL;
	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
  g_return_val_if_fail(priv != NULL, FALSE);

  g_debug ("%s: %s@%s, %s@%s",
           __FUNCTION__,
           priv->lat_path, priv->lat_attr,
           priv->lon_path, priv->lon_attr);

	FILE *file = g_fopen (filename, "r");
	if (file == NULL)
		/* TODO emit warning */
		return FALSE;

	/* setup context parse (ie callbacks) */
	if (priv->lat_attr != NULL || priv->lon_attr != NULL)
    // At least one coordinate uses an attribute
    xml_parser.start_element = &_start_element;
  else
    xml_parser.start_element = NULL;
	xml_parser.end_element = NULL;
	if (priv->lat_attr == NULL || priv->lon_attr == NULL)
    // At least one coordinate uses a raw element
    xml_parser.text = &_text;
  else
    xml_parser.text = NULL;
	xml_parser.passthrough = NULL;
	xml_parser.error = NULL;

	xml_context = g_markup_parse_context_new(&xml_parser, 0, self, NULL);

	/* setup result */
	priv->ll.lat = NAN;
	priv->ll.lon = NAN;

	gchar buff[BUFSIZ];
	size_t nb;
	while (xml_context &&
	       (nb = fread (buff, sizeof(gchar), BUFSIZ, file)) > 0)
	{
		if (!g_markup_parse_context_parse(xml_context, buff, nb, &error))
		{
			fprintf(stderr, "%s: parsing error: %s.\n",
				__FUNCTION__, error->message);
			g_markup_parse_context_free(xml_context);
			xml_context = NULL;
		}
		g_clear_error (&error);
	}
	/* cleanup */
	if (xml_context &&
	    !g_markup_parse_context_end_parse(xml_context, &error))
		fprintf(stderr, "%s: errors occurred while reading file: %s.\n",
			__FUNCTION__, error->message);
	g_clear_error (&error);

	if (xml_context)
		g_markup_parse_context_free(xml_context);
	xml_context = NULL;
	fclose (file);

  if (ll != NULL)
  {
    *ll = priv->ll;
  }

  if (isnan(priv->ll.lat) || isnan(priv->ll.lat))
		/* At least one coordinate not found */
		return FALSE;
	else
		return TRUE;
}

static gchar *
_goto_xml_tool_get_url_format ( VikGotoTool *self )
{
  VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
  g_return_val_if_fail(priv != NULL, NULL);
  return priv->url_format;
}
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	* Copyright (C) 2009, Guilhem Bonnefille <guilhem.bonnefille@gmail.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	#ifdef HAVE_CONFIG_H
	23	#include "config.h"
	24	#endif
	25	#include <stdlib.h>
	26	#include <stdio.h>
	27	#include <string.h>
	28	#ifdef HAVE_MATH_H
	29	#include "math.h"
	30	#endif
	31	#include <glib.h>
	32	#include <glib/gstdio.h>
	33	#include <glib/gprintf.h>
	34	#include <glib/gi18n.h>
	35
	36	#include "viking.h"
	37
	38	#include "vikgotoxmltool.h"
	39
	40
	41	static void _goto_xml_tool_class_init ( VikGotoXmlToolClass *klass );
	42	static void _goto_xml_tool_init ( VikGotoXmlTool *self );
	43
	44	static void _goto_xml_tool_finalize ( GObject *gob );
	45
	46	static gchar _goto_xml_tool_get_url_format ( VikGotoTool self );
	47	static gboolean _goto_xml_tool_parse_file_for_latlon(VikGotoTool self, gchar filename, struct LatLon *ll);
	48
	49	typedef struct _VikGotoXmlToolPrivate VikGotoXmlToolPrivate;
	50
	51	struct _VikGotoXmlToolPrivate
	52	{
	53	gchar *url_format;
	54	gchar *lat_path;
	55	gchar *lat_attr;
	56	gchar *lon_path;
	57	gchar *lon_attr;
	58
	59	struct LatLon ll;
	60	};
	61
	62	#define GOTO_XML_TOOL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
	63	VIK_GOTO_XML_TOOL_TYPE, \
	64	VikGotoXmlToolPrivate))
	65
	66	GType vik_goto_xml_tool_get_type()
	67	{
	68	static GType w_type = 0;
	69
	70	if (!w_type)
	71	{
	72	static const GTypeInfo w_info =
	73	{
	74	sizeof (VikGotoXmlToolClass),
	75	NULL, /* base_init */
	76	NULL, /* base_finalize */
	77	(GClassInitFunc) _goto_xml_tool_class_init,
	78	NULL, /* class_finalize */
	79	NULL, /* class_data */
	80	sizeof (VikGotoXmlTool),
	81	0,
	82	(GInstanceInitFunc) _goto_xml_tool_init,
	83	};
	84	w_type = g_type_register_static ( VIK_GOTO_TOOL_TYPE, "VikGotoXmlTool", &w_info, 0 );
	85	}
	86
	87	return w_type;
	88	}
	89
	90	enum
	91	{
	92	PROP_0,
	93
	94	PROP_URL_FORMAT,
	95	PROP_LAT_PATH,
	96	PROP_LAT_ATTR,
	97	PROP_LON_PATH,
	98	PROP_LON_ATTR,
	99	};
	100
	101	static void
	102	_goto_xml_tool_set_property (GObject *object,
	103	guint property_id,
	104	const GValue *value,
	105	GParamSpec *pspec)
	106	{
	107	VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (object);
	108	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
	109	gchar **splitted = NULL;
	110
	111	switch (property_id)
	112	{
	113	case PROP_URL_FORMAT:
	114	g_free (priv->url_format);
	115	priv->url_format = g_value_dup_string (value);
	116	break;
	117
	118	case PROP_LAT_PATH:
	119	splitted = g_strsplit (g_value_get_string (value), "@", 2);
	120	g_free (priv->lat_path);
	121	priv->lat_path = splitted[0];
	122	if (splitted[1])
	123	{
	124	g_object_set (object, "lat-attr", splitted[1], NULL);
	125	g_free (splitted[1]);
	126	}
	127	/* only free the tab, not the strings */
	128	g_free (splitted);
	129	splitted = NULL;
	130	break;
	131
	132	case PROP_LAT_ATTR:
	133	/* Avoid to overwrite XPATH value */
	134	/* NB: This disable future overwriting,
	135	but as property is CONSTRUCT_ONLY there is no matter */
	136	if (!priv->lat_attr \|\| g_value_get_string (value))
	137	{
	138	g_free (priv->lat_attr);
	139	priv->lat_attr = g_value_dup_string (value);
	140	}
	141	break;
	142
	143	case PROP_LON_PATH:
	144	splitted = g_strsplit (g_value_get_string (value), "@", 2);
	145	g_free (priv->lon_path);
	146	priv->lon_path = splitted[0];
	147	if (splitted[1])
	148	{
	149	g_object_set (object, "lon-attr", splitted[1], NULL);
	150	g_free (splitted[1]);
	151	}
	152	/* only free the tab, not the strings */
	153	g_free (splitted);
	154	splitted = NULL;
	155	break;
	156
	157	case PROP_LON_ATTR:
	158	/* Avoid to overwrite XPATH value */
	159	/* NB: This disable future overwriting,
	160	but as property is CONSTRUCT_ONLY there is no matter */
	161	if (!priv->lon_attr \|\| g_value_get_string (value))
	162	{
	163	g_free (priv->lon_attr);
	164	priv->lon_attr = g_value_dup_string (value);
	165	}
	166	break;
	167
	168	default:
	169	/* We don't have any other property... */
	170	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
	171	break;
	172	}
	173	}
	174
	175	static void
	176	_goto_xml_tool_get_property (GObject *object,
	177	guint property_id,
	178	GValue *value,
	179	GParamSpec *pspec)
	180	{
	181	VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (object);
	182	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
	183
	184	switch (property_id)
	185	{
	186	case PROP_URL_FORMAT:
	187	g_value_set_string (value, priv->url_format);
	188	break;
	189
	190	case PROP_LAT_PATH:
	191	g_value_set_string (value, priv->lat_path);
	192	break;
	193
	194	case PROP_LAT_ATTR:
	195	g_value_set_string (value, priv->lat_attr);
	196	break;
	197
	198	case PROP_LON_PATH:
	199	g_value_set_string (value, priv->lon_path);
	200	break;
	201
	202	case PROP_LON_ATTR:
	203	g_value_set_string (value, priv->lon_attr);
	204	break;
	205
	206	default:
	207	/* We don't have any other property... */
	208	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
	209	break;
	210	}
	211	}
	212
	213	static void _goto_xml_tool_class_init ( VikGotoXmlToolClass *klass )
	214	{
	215	GObjectClass *object_class;
	216	VikGotoToolClass *parent_class;
	217	GParamSpec *pspec;
	218
	219	object_class = G_OBJECT_CLASS (klass);
	220
	221	object_class->finalize = _goto_xml_tool_finalize;
	222	object_class->set_property = _goto_xml_tool_set_property;
	223	object_class->get_property = _goto_xml_tool_get_property;
	224
	225
	226	pspec = g_param_spec_string ("url-format",
	227	"URL format",
	228	"The format of the URL",
	229	"<no-set>" /* default value */,
	230	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	231	g_object_class_install_property (object_class,
	232	PROP_URL_FORMAT,
	233	pspec);
	234
	235	pspec = g_param_spec_string ("lat-path",
	236	"Latitude path",
	237	"XPath of the latitude",
	238	"<no-set>" /* default value */,
	239	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	240	g_object_class_install_property (object_class,
	241	PROP_LAT_PATH,
	242	pspec);
	243
	244	pspec = g_param_spec_string ("lat-attr",
	245	"Latitude attribute",
	246	"XML attribute of the latitude",
	247	NULL /* default value */,
	248	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	249	g_object_class_install_property (object_class,
	250	PROP_LAT_ATTR,
	251	pspec);
	252
	253	pspec = g_param_spec_string ("lon-path",
	254	"Longitude path",
	255	"XPath of the longitude",
	256	"<no-set>" /* default value */,
	257	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	258	g_object_class_install_property (object_class,
	259	PROP_LON_PATH,
	260	pspec);
	261
	262	pspec = g_param_spec_string ("lon-attr",
	263	"Longitude attribute",
	264	"XML attribute of the longitude",
	265	NULL /* default value */,
	266	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	267	g_object_class_install_property (object_class,
	268	PROP_LON_ATTR,
	269	pspec);
	270
	271	parent_class = VIK_GOTO_TOOL_CLASS (klass);
	272
	273	parent_class->get_url_format = _goto_xml_tool_get_url_format;
	274	parent_class->parse_file_for_latlon = _goto_xml_tool_parse_file_for_latlon;
	275
	276	g_type_class_add_private (klass, sizeof (VikGotoXmlToolPrivate));
	277	}
	278
	279	VikGotoXmlTool *vik_goto_xml_tool_new ()
	280	{
	281	return VIK_GOTO_XML_TOOL ( g_object_new ( VIK_GOTO_XML_TOOL_TYPE, "label", "Google", NULL ) );
	282	}
	283
	284	static void _goto_xml_tool_init ( VikGotoXmlTool *self )
	285	{
	286	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
	287	priv->url_format = NULL;
	288	priv->lat_path = NULL;
	289	priv->lat_attr = NULL;
	290	priv->lon_path = NULL;
	291	priv->lon_attr = NULL;
	292	//
	293	priv->ll.lat = NAN;
	294	priv->ll.lon = NAN;
	295	}
	296
	297	static void _goto_xml_tool_finalize ( GObject *gob )
	298	{
	299	G_OBJECT_GET_CLASS(gob)->finalize(gob);
	300	}
	301
	302	static gboolean
	303	stack_is_path (const GSList *stack,
	304	const gchar *path)
	305	{
	306	gboolean equal = TRUE;
	307	int stack_len = g_list_length((GList *)stack);
	308	int i = 0;
	309	i = stack_len - 1;
	310	while (equal == TRUE && i >= 0)
	311	{
	312	if (*path != '/')
	313	equal = FALSE;
	314	else
	315	path++;
	316	const gchar current = g_list_nth_data((GList )stack, i);
	317	size_t len = strlen(current);
	318	if (strncmp(path, current, len) != 0 )
	319	equal = FALSE;
	320	else
	321	{
	322	path += len;
	323	}
	324	i--;
	325	}
	326	if (*path != '\0')
	327	equal = FALSE;
	328	return equal;
	329	}
	330
	331	/* Called for open tags <foo bar="baz"> */
	332	static void
	333	_start_element (GMarkupParseContext *context,
	334	const gchar *element_name,
	335	const gchar **attribute_names,
	336	const gchar **attribute_values,
	337	gpointer user_data,
	338	GError **error)
	339	{
	340	VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (user_data);
	341	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
	342	const GSList *stack = g_markup_parse_context_get_element_stack (context);
	343	/* Longitude */
	344	if (priv->lon_attr != NULL && isnan(priv->ll.lon) && stack_is_path (stack, priv->lon_path))
	345	{
	346	int i=0;
	347	while (attribute_names[i] != NULL)
	348	{
	349	if (strcmp (attribute_names[i], priv->lon_attr) == 0)
	350	{
	351	priv->ll.lon = g_ascii_strtod(attribute_values[i], NULL);
	352	}
	353	i++;
	354	}
	355	}
	356	/* Latitude */
	357	if (priv->lat_attr != NULL && isnan(priv->ll.lat) && stack_is_path (stack, priv->lat_path))
	358	{
	359	int i=0;
	360	while (attribute_names[i] != NULL)
	361	{
	362	if (strcmp (attribute_names[i], priv->lat_attr) == 0)
	363	{
	364	priv->ll.lat = g_ascii_strtod(attribute_values[i], NULL);
	365	}
	366	i++;
	367	}
	368	}
	369	}
	370
	371	/* Called for character data */
	372	/* text is not nul-terminated */
	373	static void
	374	_text (GMarkupParseContext *context,
	375	const gchar *text,
	376	gsize text_len,
	377	gpointer user_data,
	378	GError **error)
	379	{
	380	VikGotoXmlTool *self = VIK_GOTO_XML_TOOL (user_data);
	381	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
	382	const GSList *stack = g_markup_parse_context_get_element_stack (context);
	383	gchar *textl = g_strndup(text, text_len);
	384	/* Store only first result */
	385	if (priv->lat_attr == NULL && isnan(priv->ll.lat) && stack_is_path (stack, priv->lat_path))
	386	{
	387	priv->ll.lat = g_ascii_strtod(textl, NULL);
	388	}
	389	if (priv->lon_attr == NULL && isnan(priv->ll.lon) && stack_is_path (stack, priv->lon_path))
	390	{
	391	priv->ll.lon = g_ascii_strtod(textl, NULL);
	392	}
	393	g_free(textl);
	394	}
	395
	396	static gboolean
	397	_goto_xml_tool_parse_file_for_latlon(VikGotoTool self, gchar filename, struct LatLon *ll)
	398	{
	399	GMarkupParser xml_parser;
	400	GMarkupParseContext *xml_context = NULL;
	401	GError *error = NULL;
	402	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
	403	g_return_val_if_fail(priv != NULL, FALSE);
	404
	405	g_debug ("%s: %s@%s, %s@%s",
	406	__FUNCTION__,
	407	priv->lat_path, priv->lat_attr,
	408	priv->lon_path, priv->lon_attr);
	409
	410	FILE *file = g_fopen (filename, "r");
	411	if (file == NULL)
	412	/* TODO emit warning */
	413	return FALSE;
	414
	415	/* setup context parse (ie callbacks) */
	416	if (priv->lat_attr != NULL \|\| priv->lon_attr != NULL)
	417	// At least one coordinate uses an attribute
	418	xml_parser.start_element = &_start_element;
	419	else
	420	xml_parser.start_element = NULL;
	421	xml_parser.end_element = NULL;
	422	if (priv->lat_attr == NULL \|\| priv->lon_attr == NULL)
	423	// At least one coordinate uses a raw element
	424	xml_parser.text = &_text;
	425	else
	426	xml_parser.text = NULL;
	427	xml_parser.passthrough = NULL;
	428	xml_parser.error = NULL;
	429
	430	xml_context = g_markup_parse_context_new(&xml_parser, 0, self, NULL);
	431
	432	/* setup result */
	433	priv->ll.lat = NAN;
	434	priv->ll.lon = NAN;
	435
	436	gchar buff[BUFSIZ];
	437	size_t nb;
	438	while (xml_context &&
	439	(nb = fread (buff, sizeof(gchar), BUFSIZ, file)) > 0)
	440	{
	441	if (!g_markup_parse_context_parse(xml_context, buff, nb, &error))
	442	{
	443	fprintf(stderr, "%s: parsing error: %s.\n",
	444	__FUNCTION__, error->message);
	445	g_markup_parse_context_free(xml_context);
	446	xml_context = NULL;
	447	}
	448	g_clear_error (&error);
	449	}
	450	/* cleanup */
	451	if (xml_context &&
	452	!g_markup_parse_context_end_parse(xml_context, &error))
	453	fprintf(stderr, "%s: errors occurred while reading file: %s.\n",
	454	__FUNCTION__, error->message);
	455	g_clear_error (&error);
	456
	457	if (xml_context)
	458	g_markup_parse_context_free(xml_context);
	459	xml_context = NULL;
	460	fclose (file);
	461
	462	if (ll != NULL)
	463	{
	464	*ll = priv->ll;
	465	}
	466
	467	if (isnan(priv->ll.lat) \|\| isnan(priv->ll.lat))
	468	/* At least one coordinate not found */
	469	return FALSE;
	470	else
	471	return TRUE;
	472	}
	473
	474	static gchar *
	475	_goto_xml_tool_get_url_format ( VikGotoTool *self )
	476	{
	477	VikGotoXmlToolPrivate *priv = GOTO_XML_TOOL_GET_PRIVATE (self);
	478	g_return_val_if_fail(priv != NULL, NULL);
	479	return priv->url_format;
	480	}