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

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * viking
 * Copyright (C) 2009-2010, Guilhem Bonnefille <guilhem.bonnefille@gmail.com>
 * 
 * viking is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * viking 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, see <http://www.gnu.org/licenses/>.
 */

 /**
  * SECTION:vikmapsourcedefault
  * @short_description: the base class implementing most of generic features
  * 
  * The #VikMapSourceDefault class is the base class implementing most of
  * generic feature, using properties or reducing complexity of some
  * functions.
  */

#include "vikmapsourcedefault.h"
#include "vikenumtypes.h"
#include "download.h"

static void map_source_get_copyright (VikMapSource *self, LatLonBBox bbox, gdouble zoom, void (*fct)(VikViewport*,const gchar*), void *data);
static const gchar *map_source_get_license (VikMapSource *self);
static const gchar *map_source_get_license_url (VikMapSource *self);
static const GdkPixbuf *map_source_get_logo (VikMapSource *self);

static const gchar *map_source_get_name (VikMapSource *self);
static guint16 map_source_get_uniq_id (VikMapSource *self);
static const gchar *map_source_get_label (VikMapSource *self);
static guint16 map_source_get_tilesize_x (VikMapSource *self);
static guint16 map_source_get_tilesize_y (VikMapSource *self);
static VikViewportDrawMode map_source_get_drawmode (VikMapSource *self);
static const gchar *map_source_get_file_extension (VikMapSource *self);

static DownloadResult_t _download ( VikMapSource *self, MapCoord *src, const gchar *dest_fn, void *handle );
static void * _download_handle_init ( VikMapSource *self );
static void _download_handle_cleanup ( VikMapSource *self, void *handle );

typedef struct _VikMapSourceDefaultPrivate VikMapSourceDefaultPrivate;
struct _VikMapSourceDefaultPrivate
{
	/* legal stuff */
	gchar *copyright;
	gchar *license;
	gchar *license_url;
	GdkPixbuf *logo;

	gchar *name;
	guint16 uniq_id;
	gchar *label;
	guint16 tilesize_x;
	guint16 tilesize_y;
	VikViewportDrawMode drawmode;
	gchar *file_extension;
};

#define VIK_MAP_SOURCE_DEFAULT_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIK_TYPE_MAP_SOURCE_DEFAULT, VikMapSourceDefaultPrivate))

/* properties */
enum
{
  PROP_0,

  PROP_NAME,
  PROP_ID,
  PROP_LABEL,
  PROP_TILESIZE_X,
  PROP_TILESIZE_Y,
  PROP_DRAWMODE,
  PROP_COPYRIGHT,
  PROP_LICENSE,
  PROP_LICENSE_URL,
  PROP_FILE_EXTENSION,
};

G_DEFINE_ABSTRACT_TYPE (VikMapSourceDefault, vik_map_source_default, VIK_TYPE_MAP_SOURCE);

static void
vik_map_source_default_init (VikMapSourceDefault *object)
{
  VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
  VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);

  priv->label = NULL;
  priv->copyright = NULL;
  priv->license = NULL;
  priv->license_url = NULL;
  priv->logo = NULL;
  priv->name = NULL;
  priv->file_extension = NULL;
}

static void
vik_map_source_default_finalize (GObject *object)
{
  VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
  VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);

  g_free (priv->label);
  priv->label = NULL;
  g_free (priv->copyright);
  priv->copyright = NULL;
  g_free (priv->license);
  priv->license = NULL;
  g_free (priv->license_url);
  priv->license_url = NULL;
  g_free (priv->logo);
  priv->license_url = NULL;
  g_free (priv->name);
  priv->name = NULL;
  g_free (priv->file_extension);
  priv->file_extension = NULL;

  G_OBJECT_CLASS (vik_map_source_default_parent_class)->finalize (object);
}

static void
vik_map_source_default_set_property (GObject      *object,
                                     guint         property_id,
                                     const GValue *value,
                                     GParamSpec   *pspec)
{
  VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
  VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);

  switch (property_id)
    {
    case PROP_NAME:
      // Sanitize the name here for file usage
      // A simple check just to prevent containing slashes ATM
      g_free (priv->name);
      priv->name = g_strdup(g_value_get_string (value));
      g_strdelimit (priv->name, "\\/", 'x' );
      break;

    case PROP_ID:
      priv->uniq_id = g_value_get_uint (value);
      break;

    case PROP_LABEL:
      g_free (priv->label);
      priv->label = g_strdup(g_value_get_string (value));
      break;

    case PROP_TILESIZE_X:
      priv->tilesize_x = g_value_get_uint (value);
      break;

    case PROP_TILESIZE_Y:
      priv->tilesize_y = g_value_get_uint (value);
      break;

    case PROP_DRAWMODE:
      priv->drawmode = g_value_get_enum(value);
      break;

    case PROP_COPYRIGHT:
      g_free (priv->copyright);
      priv->copyright = g_strdup(g_value_get_string (value));
      break;

    case PROP_LICENSE:
      g_free (priv->license);
      priv->license = g_strdup(g_value_get_string (value));
      break;

    case PROP_LICENSE_URL:
      g_free (priv->license_url);
      priv->license_url = g_strdup(g_value_get_string (value));
      break;

    case PROP_FILE_EXTENSION:
      g_free (priv->file_extension);
      priv->file_extension = g_strdup(g_value_get_string(value));
      break;

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

static void
vik_map_source_default_get_property (GObject    *object,
                                     guint       property_id,
                                     GValue     *value,
                                     GParamSpec *pspec)
{
  VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
  VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);

  switch (property_id)
    {
    case PROP_NAME:
      g_value_set_string (value, priv->name);
      break;

    case PROP_ID:
      g_value_set_uint (value, priv->uniq_id);
      break;

    case PROP_LABEL:
      g_value_set_string (value, priv->label);
      break;

    case PROP_TILESIZE_X:
      g_value_set_uint (value, priv->tilesize_x);
      break;

    case PROP_TILESIZE_Y:
      g_value_set_uint (value, priv->tilesize_y);
      break;

    case PROP_DRAWMODE:
      g_value_set_enum (value, priv->drawmode);
      break;

    case PROP_COPYRIGHT:
      g_value_set_string (value, priv->copyright);
      break;

    case PROP_LICENSE:
      g_value_set_string (value, priv->license);
      break;

    case PROP_LICENSE_URL:
      g_value_set_string (value, priv->license_url);
      break;

    case PROP_FILE_EXTENSION:
      g_value_set_string (value, priv->file_extension);
      break;

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

static void
vik_map_source_default_class_init (VikMapSourceDefaultClass *klass)
{
	GObjectClass* object_class = G_OBJECT_CLASS (klass);
	VikMapSourceClass* parent_class = VIK_MAP_SOURCE_CLASS (klass);
    GParamSpec *pspec = NULL;
	
	object_class->set_property = vik_map_source_default_set_property;
    object_class->get_property = vik_map_source_default_get_property;
	
	/* Overiding methods */
	parent_class->get_copyright =   map_source_get_copyright;
	parent_class->get_license =     map_source_get_license;
	parent_class->get_license_url = map_source_get_license_url;
	parent_class->get_logo =        map_source_get_logo;
	parent_class->get_name =        map_source_get_name;
	parent_class->get_uniq_id =    map_source_get_uniq_id;
	parent_class->get_label =      map_source_get_label;
	parent_class->get_tilesize_x = map_source_get_tilesize_x;
	parent_class->get_tilesize_y = map_source_get_tilesize_y;
	parent_class->get_drawmode =   map_source_get_drawmode;
	parent_class->get_file_extension = map_source_get_file_extension;
	parent_class->download =                 _download;
	parent_class->download_handle_init =     _download_handle_init;
	parent_class->download_handle_cleanup =  _download_handle_cleanup;

	/* Default implementation of methods */
	klass->get_uri = NULL;
	klass->get_hostname = NULL;
	klass->get_download_options = NULL;

	pspec = g_param_spec_string ("name",
	                             "Name",
	                             "The name of the map that may be used as the file cache directory",
	                             "Unknown" /* default value */,
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_NAME, pspec);

	pspec = g_param_spec_uint ("id",
	                           "Id of the tool",
                               "Set the id",
                               0  /* minimum value */,
                               G_MAXUINT /* maximum value */,
                               0  /* default value */,
                               G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_ID, pspec);

	pspec = g_param_spec_string ("label",
	                             "Label",
	                             "The label of the map source",
	                             "<no-set>" /* default value */,
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_LABEL, pspec);

	pspec = g_param_spec_uint ("tilesize-x",
	                           "TileSizeX",
                               "Set the size of the tile (x)",
                               0  /* minimum value */,
                               G_MAXUINT16 /* maximum value */,
                               0  /* default value */,
                               G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_TILESIZE_X, pspec);

	pspec = g_param_spec_uint ("tilesize-y",
	                           "TileSizeY",
                               "Set the size of the tile (y)",
                               0  /* minimum value */,
                               G_MAXUINT16 /* maximum value */,
                               0  /* default value */,
                               G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_TILESIZE_Y, pspec);

	pspec = g_param_spec_enum("drawmode",
                              "Drawmode",
                              "The mode used to draw map",
                              VIK_TYPE_VIEWPORT_DRAW_MODE,
                              VIK_VIEWPORT_DRAWMODE_UTM,
                              G_PARAM_READWRITE);
    g_object_class_install_property(object_class, PROP_DRAWMODE, pspec);                                    

	pspec = g_param_spec_string ("copyright",
	                             "Copyright",
	                             "The copyright of the map source",
	                             NULL,
	                             G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_COPYRIGHT, pspec);

	pspec = g_param_spec_string ("license",
	                             "License",
	                             "The license of the map source",
	                             NULL,
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_LICENSE, pspec);

	pspec = g_param_spec_string ("license-url",
	                             "License URL",
	                             "The URL of the license of the map source",
	                             NULL,
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_LICENSE_URL, pspec);

	pspec = g_param_spec_string ("file-extension",
	                             "File Extension",
	                             "The file extension of tile files on disk",
	                             ".png" /* default value */,
	                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
	g_object_class_install_property (object_class, PROP_FILE_EXTENSION, pspec);

	g_type_class_add_private (klass, sizeof (VikMapSourceDefaultPrivate));

	object_class->finalize = vik_map_source_default_finalize;
}

static void
map_source_get_copyright (VikMapSource *self, LatLonBBox bbox, gdouble zoom, void (*fct)(VikViewport*,const gchar*), void *data)
{
	/* Just ignore bbox and zoom level */
	g_return_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self));

	g_debug ("%s: %g %g %g %g %g", __FUNCTION__,
		bbox.south, bbox.north, bbox.east, bbox.west,
		zoom);
	
	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	(*fct) (data, priv->copyright);
}

static const gchar *
map_source_get_license (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	
	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->license;
}

static const gchar *
map_source_get_license_url (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	
	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->license_url;
}

static const GdkPixbuf *
map_source_get_logo (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);

	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->logo;
}

static const gchar *
map_source_get_name (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	return priv->name;
}

static guint16
map_source_get_uniq_id (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);
	
	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->uniq_id;
}

static const gchar *
map_source_get_label (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	
	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->label;
}

static guint16
map_source_get_tilesize_x (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);

    VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->tilesize_x;
}

static guint16
map_source_get_tilesize_y (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);

    VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->tilesize_y;
}

static VikViewportDrawMode
map_source_get_drawmode (VikMapSource *self)
{
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (VikViewportDrawMode)0);

    VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);

	return priv->drawmode;
}

static DownloadResult_t
_download ( VikMapSource *self, MapCoord *src, const gchar *dest_fn, void *handle )
{
   gchar *uri = vik_map_source_default_get_uri(VIK_MAP_SOURCE_DEFAULT(self), src);
   gchar *host = vik_map_source_default_get_hostname(VIK_MAP_SOURCE_DEFAULT(self));
   DownloadMapOptions *options = vik_map_source_default_get_download_options(VIK_MAP_SOURCE_DEFAULT(self));
   DownloadResult_t res = a_http_download_get_url ( host, uri, dest_fn, options, handle );
   g_free ( uri );
   g_free ( host );
   return res;
}

static const gchar *
map_source_get_file_extension (VikMapSource *self)
{
    g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
    VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
    return priv->file_extension;
}

static void *
_download_handle_init ( VikMapSource *self )
{
   return a_download_handle_init ();
}


static void
_download_handle_cleanup ( VikMapSource *self, void *handle )
{
   a_download_handle_cleanup ( handle );
}

gchar *
vik_map_source_default_get_uri( VikMapSourceDefault *self, MapCoord *src )
{
	VikMapSourceDefaultClass *klass;
	g_return_val_if_fail (self != NULL, 0);
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
	klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);

	g_return_val_if_fail (klass->get_uri != NULL, 0);

	return (*klass->get_uri)(self, src);
}

gchar *
vik_map_source_default_get_hostname( VikMapSourceDefault *self )
{
	VikMapSourceDefaultClass *klass;
	g_return_val_if_fail (self != NULL, 0);
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
	klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);

	g_return_val_if_fail (klass->get_hostname != NULL, 0);

	return (*klass->get_hostname)(self);
}

DownloadMapOptions *
vik_map_source_default_get_download_options( VikMapSourceDefault *self )
{
	VikMapSourceDefaultClass *klass;
	g_return_val_if_fail (self != NULL, 0);
	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
	klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);

	g_return_val_if_fail (klass->get_download_options != NULL, 0);

	return (*klass->get_download_options)(self);
}
Commit	Line	Data
3a4b95f6 GB	1	/* -- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -- */
	2	/*
	3	* viking
82aa018d	4	* Copyright (C) 2009-2010, Guilhem Bonnefille <guilhem.bonnefille@gmail.com>
3a4b95f6 GB	5	*
	6	* viking is free software: you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* viking is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	14	* See the GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along
	17	* with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
aa69d106 GB	20	/**
	21	* SECTION:vikmapsourcedefault
	22	* @short_description: the base class implementing most of generic features
	23	*
	24	* The #VikMapSourceDefault class is the base class implementing most of
	25	* generic feature, using properties or reducing complexity of some
	26	* functions.
	27	*/
	28
3a4b95f6	29	#include "vikmapsourcedefault.h"
31f3c5e7	30	#include "vikenumtypes.h"
f66ea3ec	31	#include "download.h"
3a4b95f6	32
551ee033	33	static void map_source_get_copyright (VikMapSource self, LatLonBBox bbox, gdouble zoom, void (fct)(VikViewport,const gchar), void *data);
53ac8302 GB	34	static const gchar map_source_get_license (VikMapSource self);
53ac8302 GB	35	static const gchar map_source_get_license_url (VikMapSource self);
26336cf0	36	static const GdkPixbuf map_source_get_logo (VikMapSource self);
82aa018d	37
2eb18edc	38	static const gchar map_source_get_name (VikMapSource self);
d7e495b2	39	static guint16 map_source_get_uniq_id (VikMapSource *self);
db03733a	40	static const gchar map_source_get_label (VikMapSource self);
3a4b95f6 GB	41	static guint16 map_source_get_tilesize_x (VikMapSource *self);
	42	static guint16 map_source_get_tilesize_y (VikMapSource *self);
	43	static VikViewportDrawMode map_source_get_drawmode (VikMapSource *self);
14b57d17	44	static const gchar map_source_get_file_extension (VikMapSource self);
3a4b95f6	45
4e815e90	46	static DownloadResult_t _download ( VikMapSource self, MapCoord src, const gchar dest_fn, void handle );
f66ea3ec GB	47	static void * _download_handle_init ( VikMapSource *self );
	48	static void _download_handle_cleanup ( VikMapSource self, void handle );
	49
3a4b95f6 GB	50	typedef struct _VikMapSourceDefaultPrivate VikMapSourceDefaultPrivate;
	51	struct _VikMapSourceDefaultPrivate
	52	{
82aa018d GB	53	/* legal stuff */
82aa018d GB	54	gchar *copyright;
53ac8302 GB	55	gchar *license;
53ac8302 GB	56	gchar *license_url;
26336cf0 GB	57	GdkPixbuf *logo;
26336cf0 GB	58
2eb18edc	59	gchar *name;
d7e495b2	60	guint16 uniq_id;
db03733a	61	gchar *label;
3a4b95f6 GB	62	guint16 tilesize_x;
	63	guint16 tilesize_y;
	64	VikViewportDrawMode drawmode;
14b57d17	65	gchar *file_extension;
3a4b95f6 GB	66	};
	67
	68	#define VIK_MAP_SOURCE_DEFAULT_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIK_TYPE_MAP_SOURCE_DEFAULT, VikMapSourceDefaultPrivate))
	69
31f3c5e7 GB	70	/* properties */
	71	enum
	72	{
	73	PROP_0,
	74
2eb18edc	75	PROP_NAME,
31f3c5e7	76	PROP_ID,
db03733a	77	PROP_LABEL,
31f3c5e7 GB	78	PROP_TILESIZE_X,
	79	PROP_TILESIZE_Y,
	80	PROP_DRAWMODE,
82aa018d	81	PROP_COPYRIGHT,
53ac8302 GB	82	PROP_LICENSE,
53ac8302 GB	83	PROP_LICENSE_URL,
14b57d17	84	PROP_FILE_EXTENSION,
31f3c5e7	85	};
3a4b95f6	86
d840e6de	87	G_DEFINE_ABSTRACT_TYPE (VikMapSourceDefault, vik_map_source_default, VIK_TYPE_MAP_SOURCE);
3a4b95f6 GB	88
	89	static void
	90	vik_map_source_default_init (VikMapSourceDefault *object)
	91	{
db03733a GB	92	VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
	93	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);
	94
	95	priv->label = NULL;
82aa018d	96	priv->copyright = NULL;
53ac8302 GB	97	priv->license = NULL;
53ac8302 GB	98	priv->license_url = NULL;
26336cf0	99	priv->logo = NULL;
2eb18edc	100	priv->name = NULL;
14b57d17	101	priv->file_extension = NULL;
3a4b95f6 GB	102	}
	103
	104	static void
	105	vik_map_source_default_finalize (GObject *object)
	106	{
db03733a GB	107	VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
db03733a GB	108	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);
3a4b95f6	109
db03733a GB	110	g_free (priv->label);
db03733a GB	111	priv->label = NULL;
82aa018d GB	112	g_free (priv->copyright);
82aa018d GB	113	priv->copyright = NULL;
53ac8302 GB	114	g_free (priv->license);
	115	priv->license = NULL;
	116	g_free (priv->license_url);
	117	priv->license_url = NULL;
26336cf0 GB	118	g_free (priv->logo);
26336cf0 GB	119	priv->license_url = NULL;
2eb18edc RN	120	g_free (priv->name);
2eb18edc RN	121	priv->name = NULL;
14b57d17 RN	122	g_free (priv->file_extension);
14b57d17 RN	123	priv->file_extension = NULL;
2eb18edc	124
db03733a	125	G_OBJECT_CLASS (vik_map_source_default_parent_class)->finalize (object);
3a4b95f6 GB	126	}
3a4b95f6 GB	127
31f3c5e7 GB	128	static void
	129	vik_map_source_default_set_property (GObject *object,
	130	guint property_id,
	131	const GValue *value,
	132	GParamSpec *pspec)
	133	{
	134	VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
	135	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);
	136
	137	switch (property_id)
	138	{
2eb18edc RN	139	case PROP_NAME:
	140	// Sanitize the name here for file usage
	141	// A simple check just to prevent containing slashes ATM
	142	g_free (priv->name);
	143	priv->name = g_strdup(g_value_get_string (value));
	144	g_strdelimit (priv->name, "\\/", 'x' );
	145	break;
	146
31f3c5e7 GB	147	case PROP_ID:
	148	priv->uniq_id = g_value_get_uint (value);
	149	break;
	150
9f58c4b4	151	case PROP_LABEL:
db03733a GB	152	g_free (priv->label);
	153	priv->label = g_strdup(g_value_get_string (value));
	154	break;
	155
31f3c5e7 GB	156	case PROP_TILESIZE_X:
	157	priv->tilesize_x = g_value_get_uint (value);
	158	break;
	159
	160	case PROP_TILESIZE_Y:
	161	priv->tilesize_y = g_value_get_uint (value);
	162	break;
	163
	164	case PROP_DRAWMODE:
	165	priv->drawmode = g_value_get_enum(value);
	166	break;
	167
82aa018d GB	168	case PROP_COPYRIGHT:
	169	g_free (priv->copyright);
	170	priv->copyright = g_strdup(g_value_get_string (value));
	171	break;
	172
53ac8302 GB	173	case PROP_LICENSE:
	174	g_free (priv->license);
	175	priv->license = g_strdup(g_value_get_string (value));
	176	break;
	177
	178	case PROP_LICENSE_URL:
	179	g_free (priv->license_url);
	180	priv->license_url = g_strdup(g_value_get_string (value));
	181	break;
	182
14b57d17 RN	183	case PROP_FILE_EXTENSION:
	184	g_free (priv->file_extension);
	185	priv->file_extension = g_strdup(g_value_get_string(value));
	186	break;
	187
31f3c5e7 GB	188	default:
	189	/* We don't have any other property... */
	190	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
	191	break;
	192	}
	193	}
	194
	195	static void
	196	vik_map_source_default_get_property (GObject *object,
	197	guint property_id,
	198	GValue *value,
	199	GParamSpec *pspec)
	200	{
	201	VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
	202	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);
	203
	204	switch (property_id)
	205	{
2eb18edc RN	206	case PROP_NAME:
	207	g_value_set_string (value, priv->name);
	208	break;
	209
31f3c5e7 GB	210	case PROP_ID:
	211	g_value_set_uint (value, priv->uniq_id);
	212	break;
	213
db03733a GB	214	case PROP_LABEL:
	215	g_value_set_string (value, priv->label);
	216	break;
	217
31f3c5e7 GB	218	case PROP_TILESIZE_X:
	219	g_value_set_uint (value, priv->tilesize_x);
	220	break;
	221
	222	case PROP_TILESIZE_Y:
	223	g_value_set_uint (value, priv->tilesize_y);
	224	break;
	225
	226	case PROP_DRAWMODE:
	227	g_value_set_enum (value, priv->drawmode);
	228	break;
	229
82aa018d GB	230	case PROP_COPYRIGHT:
	231	g_value_set_string (value, priv->copyright);
	232	break;
	233
53ac8302 GB	234	case PROP_LICENSE:
	235	g_value_set_string (value, priv->license);
	236	break;
	237
	238	case PROP_LICENSE_URL:
	239	g_value_set_string (value, priv->license_url);
	240	break;
	241
14b57d17 RN	242	case PROP_FILE_EXTENSION:
	243	g_value_set_string (value, priv->file_extension);
	244	break;
	245
31f3c5e7 GB	246	default:
	247	/* We don't have any other property... */
	248	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
	249	break;
	250	}
	251	}
	252
3a4b95f6 GB	253	static void
	254	vik_map_source_default_class_init (VikMapSourceDefaultClass *klass)
	255	{
	256	GObjectClass* object_class = G_OBJECT_CLASS (klass);
	257	VikMapSourceClass* parent_class = VIK_MAP_SOURCE_CLASS (klass);
31f3c5e7 GB	258	GParamSpec *pspec = NULL;
	259
	260	object_class->set_property = vik_map_source_default_set_property;
	261	object_class->get_property = vik_map_source_default_get_property;
	262
3a4b95f6	263	/* Overiding methods */
82aa018d	264	parent_class->get_copyright = map_source_get_copyright;
53ac8302 GB	265	parent_class->get_license = map_source_get_license;
53ac8302 GB	266	parent_class->get_license_url = map_source_get_license_url;
26336cf0	267	parent_class->get_logo = map_source_get_logo;
2eb18edc	268	parent_class->get_name = map_source_get_name;
3a4b95f6	269	parent_class->get_uniq_id = map_source_get_uniq_id;
db03733a	270	parent_class->get_label = map_source_get_label;
3a4b95f6 GB	271	parent_class->get_tilesize_x = map_source_get_tilesize_x;
	272	parent_class->get_tilesize_y = map_source_get_tilesize_y;
	273	parent_class->get_drawmode = map_source_get_drawmode;
14b57d17	274	parent_class->get_file_extension = map_source_get_file_extension;
f66ea3ec GB	275	parent_class->download = _download;
	276	parent_class->download_handle_init = _download_handle_init;
	277	parent_class->download_handle_cleanup = _download_handle_cleanup;
	278
	279	/* Default implementation of methods */
	280	klass->get_uri = NULL;
	281	klass->get_hostname = NULL;
	282	klass->get_download_options = NULL;
3a4b95f6	283
2eb18edc RN	284	pspec = g_param_spec_string ("name",
	285	"Name",
	286	"The name of the map that may be used as the file cache directory",
	287	"Unknown" /* default value */,
	288	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	289	g_object_class_install_property (object_class, PROP_NAME, pspec);
	290
31f3c5e7 GB	291	pspec = g_param_spec_uint ("id",
	292	"Id of the tool",
	293	"Set the id",
	294	0 /* minimum value */,
9593ef7d	295	G_MAXUINT /* maximum value */,
31f3c5e7 GB	296	0 /* default value */,
	297	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	298	g_object_class_install_property (object_class, PROP_ID, pspec);
	299
db03733a GB	300	pspec = g_param_spec_string ("label",
	301	"Label",
	302	"The label of the map source",
	303	"<no-set>" /* default value */,
	304	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	305	g_object_class_install_property (object_class, PROP_LABEL, pspec);
	306
31f3c5e7 GB	307	pspec = g_param_spec_uint ("tilesize-x",
	308	"TileSizeX",
	309	"Set the size of the tile (x)",
	310	0 /* minimum value */,
	311	G_MAXUINT16 /* maximum value */,
	312	0 /* default value */,
f0d4496f	313	G_PARAM_READWRITE);
31f3c5e7 GB	314	g_object_class_install_property (object_class, PROP_TILESIZE_X, pspec);
	315
	316	pspec = g_param_spec_uint ("tilesize-y",
	317	"TileSizeY",
	318	"Set the size of the tile (y)",
	319	0 /* minimum value */,
	320	G_MAXUINT16 /* maximum value */,
	321	0 /* default value */,
f0d4496f	322	G_PARAM_READWRITE);
31f3c5e7 GB	323	g_object_class_install_property (object_class, PROP_TILESIZE_Y, pspec);
	324
	325	pspec = g_param_spec_enum("drawmode",
	326	"Drawmode",
	327	"The mode used to draw map",
	328	VIK_TYPE_VIEWPORT_DRAW_MODE,
	329	VIK_VIEWPORT_DRAWMODE_UTM,
	330	G_PARAM_READWRITE);
	331	g_object_class_install_property(object_class, PROP_DRAWMODE, pspec);
	332
82aa018d GB	333	pspec = g_param_spec_string ("copyright",
	334	"Copyright",
	335	"The copyright of the map source",
	336	NULL,
9f58c4b4	337	G_PARAM_READWRITE);
82aa018d GB	338	g_object_class_install_property (object_class, PROP_COPYRIGHT, pspec);
82aa018d GB	339
53ac8302 GB	340	pspec = g_param_spec_string ("license",
	341	"License",
	342	"The license of the map source",
	343	NULL,
	344	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	345	g_object_class_install_property (object_class, PROP_LICENSE, pspec);
	346
	347	pspec = g_param_spec_string ("license-url",
	348	"License URL",
	349	"The URL of the license of the map source",
	350	NULL,
	351	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	352	g_object_class_install_property (object_class, PROP_LICENSE_URL, pspec);
	353
14b57d17 RN	354	pspec = g_param_spec_string ("file-extension",
	355	"File Extension",
	356	"The file extension of tile files on disk",
	357	".png" /* default value */,
	358	G_PARAM_CONSTRUCT_ONLY \| G_PARAM_READWRITE);
	359	g_object_class_install_property (object_class, PROP_FILE_EXTENSION, pspec);
	360
3a4b95f6 GB	361	g_type_class_add_private (klass, sizeof (VikMapSourceDefaultPrivate));
	362
	363	object_class->finalize = vik_map_source_default_finalize;
	364	}
	365
68b1d6c0	366	static void
551ee033	367	map_source_get_copyright (VikMapSource self, LatLonBBox bbox, gdouble zoom, void (fct)(VikViewport,const gchar), void *data)
82aa018d	368	{
68b1d6c0 GB	369	/* Just ignore bbox and zoom level */
	370	g_return_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self));
	371
	372	g_debug ("%s: %g %g %g %g %g", __FUNCTION__,
	373	bbox.south, bbox.north, bbox.east, bbox.west,
	374	zoom);
82aa018d GB	375
	376	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	377
68b1d6c0	378	(*fct) (data, priv->copyright);
82aa018d GB	379	}
82aa018d GB	380
53ac8302 GB	381	static const gchar *
	382	map_source_get_license (VikMapSource *self)
	383	{
	384	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	385
	386	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	387
	388	return priv->license;
	389	}
	390
	391	static const gchar *
	392	map_source_get_license_url (VikMapSource *self)
	393	{
	394	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	395
	396	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	397
	398	return priv->license_url;
	399	}
	400
26336cf0 GB	401	static const GdkPixbuf *
	402	map_source_get_logo (VikMapSource *self)
	403	{
	404	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	405
	406	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	407
	408	return priv->logo;
	409	}
	410
2eb18edc RN	411	static const gchar *
	412	map_source_get_name (VikMapSource *self)
	413	{
	414	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	415	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	416	return priv->name;
	417	}
	418
d7e495b2	419	static guint16
3a4b95f6 GB	420	map_source_get_uniq_id (VikMapSource *self)
3a4b95f6 GB	421	{
d7e495b2	422	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);
3a84e537 GB	423
3a84e537 GB	424	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
3a4b95f6 GB	425
	426	return priv->uniq_id;
	427	}
	428
db03733a GB	429	static const gchar *
	430	map_source_get_label (VikMapSource *self)
	431	{
	432	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	433
	434	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	435
	436	return priv->label;
	437	}
	438
3a4b95f6 GB	439	static guint16
	440	map_source_get_tilesize_x (VikMapSource *self)
	441	{
3a84e537 GB	442	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);
3a84e537 GB	443
3a4b95f6	444	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
3a4b95f6 GB	445
	446	return priv->tilesize_x;
	447	}
	448
	449	static guint16
	450	map_source_get_tilesize_y (VikMapSource *self)
	451	{
3a84e537 GB	452	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);
3a84e537 GB	453
3a4b95f6	454	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
3a4b95f6 GB	455
	456	return priv->tilesize_y;
	457	}
	458
	459	static VikViewportDrawMode
	460	map_source_get_drawmode (VikMapSource *self)
	461	{
3a84e537 GB	462	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (VikViewportDrawMode)0);
3a84e537 GB	463
3a4b95f6	464	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
3a4b95f6 GB	465
	466	return priv->drawmode;
	467	}
f66ea3ec	468
4e815e90	469	static DownloadResult_t
f66ea3ec GB	470	_download ( VikMapSource self, MapCoord src, const gchar dest_fn, void handle )
f66ea3ec GB	471	{
f66ea3ec GB	472	gchar *uri = vik_map_source_default_get_uri(VIK_MAP_SOURCE_DEFAULT(self), src);
	473	gchar *host = vik_map_source_default_get_hostname(VIK_MAP_SOURCE_DEFAULT(self));
	474	DownloadMapOptions *options = vik_map_source_default_get_download_options(VIK_MAP_SOURCE_DEFAULT(self));
4e815e90	475	DownloadResult_t res = a_http_download_get_url ( host, uri, dest_fn, options, handle );
f66ea3ec GB	476	g_free ( uri );
	477	g_free ( host );
	478	return res;
	479	}
	480
14b57d17 RN	481	static const gchar *
	482	map_source_get_file_extension (VikMapSource *self)
	483	{
	484	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
	485	VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
	486	return priv->file_extension;
	487	}
	488
f66ea3ec GB	489	static void *
	490	_download_handle_init ( VikMapSource *self )
	491	{
	492	return a_download_handle_init ();
	493	}
	494
	495
	496	static void
	497	_download_handle_cleanup ( VikMapSource self, void handle )
	498	{
41810542	499	a_download_handle_cleanup ( handle );
f66ea3ec GB	500	}
	501
	502	gchar *
	503	vik_map_source_default_get_uri( VikMapSourceDefault self, MapCoord src )
	504	{
	505	VikMapSourceDefaultClass *klass;
	506	g_return_val_if_fail (self != NULL, 0);
	507	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
	508	klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);
	509
	510	g_return_val_if_fail (klass->get_uri != NULL, 0);
	511
	512	return (*klass->get_uri)(self, src);
	513	}
	514
	515	gchar *
	516	vik_map_source_default_get_hostname( VikMapSourceDefault *self )
	517	{
	518	VikMapSourceDefaultClass *klass;
	519	g_return_val_if_fail (self != NULL, 0);
	520	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
	521	klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);
	522
	523	g_return_val_if_fail (klass->get_hostname != NULL, 0);
	524
	525	return (*klass->get_hostname)(self);
	526	}
	527
	528	DownloadMapOptions *
	529	vik_map_source_default_get_download_options( VikMapSourceDefault *self )
	530	{
	531	VikMapSourceDefaultClass *klass;
	532	g_return_val_if_fail (self != NULL, 0);
	533	g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
	534	klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);
	535
	536	g_return_val_if_fail (klass->get_download_options != NULL, 0);
	537
	538	return (*klass->get_download_options)(self);
	539	}