src/vikslippymapsource.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * viking
   4  * Copyright (C) 2009, Guilhem Bonnefille <guilhem.bonnefille@gmail.com>
   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
  20  /**
  21   * SECTION:vikslippymapsource
  22   * @short_description: the class for SlippyMap oriented map sources
  23   *
  24   * The #VikSlippyMapSource class handles slippy map oriented map sources.
  25   * The related service is tile oriented, à la Google.
  26   *
  27   * The tiles are in 'google spherical mercator', which is
  28   * basically a mercator projection that assumes a spherical earth.
  29   * http://docs.openlayers.org/library/spherical_mercator.html
  30   *
  31   * Such service is also a type of TMS (Tile Map Service) as defined in
  32   * OSGeo's wiki.
  33   * http://wiki.osgeo.org/wiki/Tile_Map_Service_Specification
  34   * But take care that the Y axis is inverted, ie the origin is at top-left
  35   * corner.
  36   * Following this specification, the protocol handled by this class
  37   * follows the global-mercator profile.
  38   *
  39   * You can also find many interesting information on the OSM's wiki.
  40   * http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
  41   * http://wiki.openstreetmap.org/wiki/Setting_up_TMS
  42   */
  43
  44 #ifdef HAVE_CONFIG_H
  45 #include "config.h"
  46 #endif
  47
  48 #ifdef HAVE_MATH_H
  49 #include <math.h>
  50 #endif
  51
  52 #include "globals.h"
  53 #include "vikslippymapsource.h"
  54 #include "maputils.h"
  55
  56 static gboolean _coord_to_mapcoord ( VikMapSource *self, const VikCoord *src, gdouble xzoom, gdouble yzoom, MapCoord *dest );
  57 static void _mapcoord_to_center_coord ( VikMapSource *self, MapCoord *src, VikCoord *dest );
  58
  59 static gboolean _is_direct_file_access (VikMapSource *self );
  60 static gboolean _is_mbtiles (VikMapSource *self );
  61 static gboolean _is_osm_meta_tiles (VikMapSource *self );
  62 static gboolean _supports_download_only_new (VikMapSource *self );
  63 static guint8 _get_zoom_min(VikMapSource *self );
  64 static guint8 _get_zoom_max(VikMapSource *self );
  65 static gdouble _get_lat_min(VikMapSource *self );
  66 static gdouble _get_lat_max(VikMapSource *self );
  67 static gdouble _get_lon_min(VikMapSource *self );
  68 static gdouble _get_lon_max(VikMapSource *self );
  69
  70 static gchar *_get_uri( VikMapSourceDefault *self, MapCoord *src );
  71 static gchar *_get_hostname( VikMapSourceDefault *self );
  72 static DownloadMapOptions *_get_download_options( VikMapSourceDefault *self );
  73
  74 typedef struct _VikSlippyMapSourcePrivate VikSlippyMapSourcePrivate;
  75 struct _VikSlippyMapSourcePrivate
  76 {
  77   gchar *hostname;
  78   gchar *url;
  79   DownloadMapOptions options;
  80   // NB Probably best to keep the above fields in same order to be common across Slippy, TMS & WMS map definitions
  81   guint zoom_min; // TMS Zoom level: 0 = Whole World // http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
  82   guint zoom_max; // TMS Zoom level: Often 18 for zoomed in.
  83   gdouble lat_min; // Degrees
  84   gdouble lat_max; // Degrees
  85   gdouble lon_min; // Degrees
  86   gdouble lon_max; // Degrees
  87   gboolean is_direct_file_access;
  88   gboolean is_mbtiles;
  89   gboolean is_osm_meta_tiles; // http://wiki.openstreetmap.org/wiki/Meta_tiles as used by tirex or renderd
  90   // Mainly for ARCGIS Tile Server URL Layout // http://help.arcgis.com/EN/arcgisserver/10.0/apis/rest/tile.html
  91   gboolean switch_xy;
  92 };
  93
  94 #define VIK_SLIPPY_MAP_SOURCE_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIK_TYPE_SLIPPY_MAP_SOURCE, VikSlippyMapSourcePrivate))
  95
  96 /* properties */
  97 enum
  98 {
  99   PROP_0,
 100
 101   PROP_HOSTNAME,
 102   PROP_URL,
 103   PROP_ZOOM_MIN,
 104   PROP_ZOOM_MAX,
 105   PROP_LAT_MIN,
 106   PROP_LAT_MAX,
 107   PROP_LON_MIN,
 108   PROP_LON_MAX,
 109   PROP_REFERER,
 110   PROP_FOLLOW_LOCATION,
 111   PROP_CHECK_FILE_SERVER_TIME,
 112   PROP_USE_ETAG,
 113   PROP_IS_DIRECT_FILE_ACCESS,
 114   PROP_IS_MBTILES,
 115   PROP_IS_OSM_META_TILES,
 116   PROP_SWITCH_XY,
 117 };
 118
 119 G_DEFINE_TYPE (VikSlippyMapSource, vik_slippy_map_source, VIK_TYPE_MAP_SOURCE_DEFAULT);
 120
 121 static void
 122 vik_slippy_map_source_init (VikSlippyMapSource *self)
 123 {
 124   /* initialize the object here */
 125   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE (self);
 126
 127   priv->hostname = NULL;
 128   priv->url = NULL;
 129   priv->zoom_min = 0;
 130   priv->zoom_max = 18;
 131   priv->lat_min = -90.0;
 132   priv->lat_max = 90.0;
 133   priv->lon_min = -180.0;
 134   priv->lon_max = 180.0;
 135   priv->options.referer = NULL;
 136   priv->options.follow_location = 0;
 137   priv->options.check_file = a_check_map_file;
 138   priv->options.check_file_server_time = FALSE;
 139   priv->options.use_etag = FALSE;
 140   priv->is_direct_file_access = FALSE;
 141   priv->is_mbtiles = FALSE;
 142   priv->is_osm_meta_tiles = FALSE;
 143   priv->switch_xy = FALSE;
 144
 145   g_object_set (G_OBJECT (self),
 146                 "tilesize-x", 256,
 147                 "tilesize-y", 256,
 148                 "drawmode", VIK_VIEWPORT_DRAWMODE_MERCATOR,
 149                 NULL);
 150 }
 151
 152 static void
 153 vik_slippy_map_source_finalize (GObject *object)
 154 {
 155   VikSlippyMapSource *self = VIK_SLIPPY_MAP_SOURCE (object);
 156   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE (self);
 157
 158   g_free (priv->hostname);
 159   priv->hostname = NULL;
 160   g_free (priv->url);
 161   priv->url = NULL;
 162   g_free (priv->options.referer);
 163   priv->options.referer = NULL;
 164
 165   G_OBJECT_CLASS (vik_slippy_map_source_parent_class)->finalize (object);
 166 }
 167
 168 static void
 169 vik_slippy_map_source_set_property (GObject      *object,
 170                                     guint         property_id,
 171                                     const GValue *value,
 172                                     GParamSpec   *pspec)
 173 {
 174   VikSlippyMapSource *self = VIK_SLIPPY_MAP_SOURCE (object);
 175   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE (self);
 176
 177   switch (property_id)
 178     {
 179     case PROP_HOSTNAME:
 180       g_free (priv->hostname);
 181       priv->hostname = g_value_dup_string (value);
 182       break;
 183
 184     case PROP_URL:
 185       g_free (priv->url);
 186       priv->url = g_value_dup_string (value);
 187       break;
 188
 189     case PROP_ZOOM_MIN:
 190       priv->zoom_min = g_value_get_uint (value);
 191       break;
 192
 193     case PROP_ZOOM_MAX:
 194       priv->zoom_max = g_value_get_uint (value);
 195       break;
 196
 197     case PROP_LAT_MIN:
 198       priv->lat_min = g_value_get_double (value);
 199       break;
 200
 201     case PROP_LAT_MAX:
 202       priv->lat_max = g_value_get_double (value);
 203       break;
 204
 205     case PROP_LON_MIN:
 206       priv->lon_min = g_value_get_double (value);
 207       break;
 208
 209     case PROP_LON_MAX:
 210       priv->lon_max = g_value_get_double (value);
 211       break;
 212
 213     case PROP_REFERER:
 214       g_free (priv->options.referer);
 215       priv->options.referer = g_value_dup_string (value);
 216       break;
 217
 218     case PROP_FOLLOW_LOCATION:
 219       priv->options.follow_location = g_value_get_long (value);
 220       break;
 221
 222     case PROP_CHECK_FILE_SERVER_TIME:
 223       priv->options.check_file_server_time = g_value_get_boolean (value);
 224       break;
 225
 226     case PROP_USE_ETAG:
 227       priv->options.use_etag = g_value_get_boolean (value);
 228       break;
 229
 230     case PROP_IS_DIRECT_FILE_ACCESS:
 231       priv->is_direct_file_access = g_value_get_boolean (value);
 232       break;
 233
 234     case PROP_IS_MBTILES:
 235       priv->is_mbtiles = g_value_get_boolean (value);
 236       break;
 237
 238     case PROP_IS_OSM_META_TILES:
 239       priv->is_osm_meta_tiles = g_value_get_boolean (value);
 240       break;
 241
 242     case PROP_SWITCH_XY:
 243       priv->switch_xy = g_value_get_boolean (value);
 244       break;
 245
 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
 253 static void
 254 vik_slippy_map_source_get_property (GObject    *object,
 255                                     guint       property_id,
 256                                     GValue     *value,
 257                                     GParamSpec *pspec)
 258 {
 259   VikSlippyMapSource *self = VIK_SLIPPY_MAP_SOURCE (object);
 260   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE (self);
 261
 262   switch (property_id)
 263     {
 264     case PROP_HOSTNAME:
 265       g_value_set_string (value, priv->hostname);
 266       break;
 267
 268     case PROP_URL:
 269       g_value_set_string (value, priv->url);
 270       break;
 271
 272     case PROP_ZOOM_MIN:
 273       g_value_set_uint (value, priv->zoom_min);
 274       break;
 275
 276     case PROP_ZOOM_MAX:
 277       g_value_set_uint (value, priv->zoom_max);
 278       break;
 279
 280     case PROP_LON_MIN:
 281       g_value_set_double (value, priv->lon_min);
 282       break;
 283
 284     case PROP_LON_MAX:
 285       g_value_set_double (value, priv->lon_max);
 286       break;
 287
 288     case PROP_LAT_MIN:
 289       g_value_set_double (value, priv->lat_min);
 290       break;
 291
 292     case PROP_LAT_MAX:
 293       g_value_set_double (value, priv->lat_max);
 294       break;
 295
 296     case PROP_REFERER:
 297       g_value_set_string (value, priv->options.referer);
 298       break;
 299
 300     case PROP_FOLLOW_LOCATION:
 301       g_value_set_long (value, priv->options.follow_location);
 302       break;
 303
 304     case PROP_CHECK_FILE_SERVER_TIME:
 305       g_value_set_boolean (value, priv->options.check_file_server_time);
 306       break;
 307
 308     case PROP_USE_ETAG:
 309       g_value_set_boolean (value, priv->options.use_etag);
 310       break;
 311
 312     case PROP_IS_DIRECT_FILE_ACCESS:
 313       g_value_set_boolean (value, priv->is_direct_file_access);
 314       break;
 315
 316     case PROP_IS_MBTILES:
 317       g_value_set_boolean (value, priv->is_mbtiles);
 318       break;
 319
 320     case PROP_IS_OSM_META_TILES:
 321       g_value_set_boolean (value, priv->is_osm_meta_tiles);
 322       break;
 323
 324     case PROP_SWITCH_XY:
 325       g_value_set_boolean (value, priv->switch_xy);
 326       break;
 327
 328     default:
 329       /* We don't have any other property... */
 330       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 331       break;
 332     }
 333 }
 334
 335 static void
 336 vik_slippy_map_source_class_init (VikSlippyMapSourceClass *klass)
 337 {
 338         GObjectClass* object_class = G_OBJECT_CLASS (klass);
 339         VikMapSourceClass* grandparent_class = VIK_MAP_SOURCE_CLASS (klass);
 340         VikMapSourceDefaultClass* parent_class = VIK_MAP_SOURCE_DEFAULT_CLASS (klass);
 341         GParamSpec *pspec = NULL;
 342
 343         object_class->set_property = vik_slippy_map_source_set_property;
 344     object_class->get_property = vik_slippy_map_source_get_property;
 345
 346         /* Overiding methods */
 347         grandparent_class->coord_to_mapcoord =        _coord_to_mapcoord;
 348         grandparent_class->mapcoord_to_center_coord = _mapcoord_to_center_coord;
 349         grandparent_class->is_direct_file_access = _is_direct_file_access;
 350         grandparent_class->is_mbtiles = _is_mbtiles;
 351         grandparent_class->is_osm_meta_tiles = _is_osm_meta_tiles;
 352         grandparent_class->supports_download_only_new = _supports_download_only_new;
 353         grandparent_class->get_zoom_min = _get_zoom_min;
 354         grandparent_class->get_zoom_max = _get_zoom_max;
 355         grandparent_class->get_lat_min = _get_lat_min;
 356         grandparent_class->get_lat_max = _get_lat_max;
 357         grandparent_class->get_lon_min = _get_lon_min;
 358         grandparent_class->get_lon_max = _get_lon_max;
 359
 360         parent_class->get_uri = _get_uri;
 361         parent_class->get_hostname = _get_hostname;
 362         parent_class->get_download_options = _get_download_options;
 363
 364         pspec = g_param_spec_string ("hostname",
 365                                      "Hostname",
 366                                      "The hostname of the map server",
 367                                      "<no-set>" /* default value */,
 368                                      G_PARAM_READWRITE);
 369         g_object_class_install_property (object_class, PROP_HOSTNAME, pspec);
 370
 371         pspec = g_param_spec_string ("url",
 372                                      "URL",
 373                                      "The template of the tiles' URL",
 374                                      "<no-set>" /* default value */,
 375                                      G_PARAM_READWRITE);
 376         g_object_class_install_property (object_class, PROP_URL, pspec);
 377
 378         pspec = g_param_spec_uint ("zoom-min",
 379                                    "Minimum zoom",
 380                                    "Minimum Zoom level supported by the map provider",
 381                                    0,  // minimum value,
 382                                    22, // maximum value
 383                                    0, // default value
 384                                    G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 385         g_object_class_install_property (object_class, PROP_ZOOM_MIN, pspec);
 386
 387         pspec = g_param_spec_uint ("zoom-max",
 388                                    "Maximum zoom",
 389                                    "Maximum Zoom level supported by the map provider",
 390                                    0,  // minimum value,
 391                                    22, // maximum value
 392                                    18, // default value
 393                                    G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 394         g_object_class_install_property (object_class, PROP_ZOOM_MAX, pspec);
 395
 396         pspec = g_param_spec_double ("lat-min",
 397                                      "Minimum latitude",
 398                                      "Minimum latitude in degrees supported by the map provider",
 399                                      -90.0,  // minimum value
 400                                      90.0, // maximum value
 401                                      -90.0, // default value
 402                                      G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 403         g_object_class_install_property (object_class, PROP_LAT_MIN, pspec);
 404
 405         pspec = g_param_spec_double ("lat-max",
 406                                      "Maximum latitude",
 407                                      "Maximum latitude in degrees supported by the map provider",
 408                                      -90.0,  // minimum value
 409                                      90.0, // maximum value
 410                                      90.0, // default value
 411                                      G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 412         g_object_class_install_property (object_class, PROP_LAT_MAX, pspec);
 413
 414         pspec = g_param_spec_double ("lon-min",
 415                                      "Minimum longitude",
 416                                      "Minimum longitude in degrees supported by the map provider",
 417                                      -180.0,  // minimum value
 418                                      180.0, // maximum value
 419                                      -180.0, // default value
 420                                      G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 421         g_object_class_install_property (object_class, PROP_LON_MIN, pspec);
 422
 423         pspec = g_param_spec_double ("lon-max",
 424                                      "Maximum longitude",
 425                                      "Maximum longitude in degrees supported by the map provider",
 426                                      -180.0,  // minimum value
 427                                      180.0, // maximum value
 428                                      180.0, // default value
 429                                      G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 430         g_object_class_install_property (object_class, PROP_LON_MAX, pspec);
 431
 432         pspec = g_param_spec_string ("referer",
 433                                      "Referer",
 434                                      "The REFERER string to use in HTTP request",
 435                                      NULL /* default value */,
 436                                      G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 437         g_object_class_install_property (object_class, PROP_REFERER, pspec);
 438
 439         pspec = g_param_spec_long ("follow-location",
 440                                    "Follow location",
 441                                "Specifies the number of retries to follow a redirect while downloading a page",
 442                                0  /* minimum value */,
 443                                G_MAXLONG /* maximum value */,
 444                                0  /* default value */,
 445                                G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 446         g_object_class_install_property (object_class, PROP_FOLLOW_LOCATION, pspec);
 447
 448         pspec = g_param_spec_boolean ("check-file-server-time",
 449                                       "Check file server time",
 450                                   "Age of current cache before redownloading tile",
 451                                   FALSE  /* default value */,
 452                                   G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 453         g_object_class_install_property (object_class, PROP_CHECK_FILE_SERVER_TIME, pspec);
 454
 455         pspec = g_param_spec_boolean ("use-etag",
 456                                       "Use etag values with server",
 457                                   "Store etag in a file, and send it to server to check if we have the latest file",
 458                                   FALSE  /* default value */,
 459                                   G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 460         g_object_class_install_property (object_class, PROP_USE_ETAG, pspec);
 461
 462         pspec = g_param_spec_boolean ("use-direct-file-access",
 463                                       "Use direct file access",
 464                                       "Use direct file access to OSM like tile images - no need for a webservice",
 465                                   FALSE  /* default value */,
 466                                   G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 467         g_object_class_install_property (object_class, PROP_IS_DIRECT_FILE_ACCESS, pspec);
 468
 469         pspec = g_param_spec_boolean ("is-mbtiles",
 470                                       "Is an SQL MBTiles File",
 471                                       "Use an SQL MBTiles File for the tileset - no need for a webservice",
 472                                       FALSE  /* default value */,
 473                                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 474         g_object_class_install_property (object_class, PROP_IS_MBTILES, pspec);
 475
 476         pspec = g_param_spec_boolean ("is-osm-meta-tiles",
 477                                       "Is in OSM Meta Tile format",
 478                                       "Read from OSM Meta Tiles - Should be 'use-direct-file-access' as well",
 479                                       FALSE  /* default value */,
 480                                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 481         g_object_class_install_property (object_class, PROP_IS_OSM_META_TILES, pspec);
 482
 483         pspec = g_param_spec_boolean ("switch-xy",
 484                                       "Switch the order of x,y components in the URL",
 485                                       "Switch the order of x,y components in the URL (such as used by ARCGIS Tile Server",
 486                                       FALSE  /* default value */,
 487                                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 488         g_object_class_install_property (object_class, PROP_SWITCH_XY, pspec);
 489
 490         g_type_class_add_private (klass, sizeof (VikSlippyMapSourcePrivate));
 491
 492         object_class->finalize = vik_slippy_map_source_finalize;
 493 }
 494
 495 static gboolean
 496 _is_direct_file_access (VikMapSource *self)
 497 {
 498   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 499
 500   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 501
 502   return priv->is_direct_file_access;
 503 }
 504
 505 static gboolean
 506 _is_mbtiles (VikMapSource *self)
 507 {
 508   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 509
 510   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 511
 512   return priv->is_mbtiles;
 513 }
 514
 515 /**
 516  *
 517  */
 518 static gboolean
 519 _is_osm_meta_tiles (VikMapSource *self)
 520 {
 521   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 522   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 523   return priv->is_osm_meta_tiles;
 524 }
 525
 526 static gboolean
 527 _supports_download_only_new (VikMapSource *self)
 528 {
 529   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 530
 531   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 532
 533   return priv->options.check_file_server_time || priv->options.use_etag;
 534 }
 535
 536 /**
 537  *
 538  */
 539 static guint8
 540 _get_zoom_min (VikMapSource *self)
 541 {
 542   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 543   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 544   return priv->zoom_min;
 545 }
 546
 547 /**
 548  *
 549  */
 550 static guint8
 551 _get_zoom_max (VikMapSource *self)
 552 {
 553   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 554   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 555   return priv->zoom_max;
 556 }
 557
 558 /**
 559  *
 560  */
 561 static gdouble
 562 _get_lat_min (VikMapSource *self)
 563 {
 564   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 565   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 566   return priv->lat_min;
 567 }
 568
 569 /**
 570  *
 571  */
 572 static gdouble
 573 _get_lat_max (VikMapSource *self)
 574 {
 575   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 576   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 577   return priv->lat_max;
 578 }
 579
 580 /**
 581  *
 582  */
 583 static gdouble
 584 _get_lon_min (VikMapSource *self)
 585 {
 586   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 587   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 588   return priv->lon_min;
 589 }
 590
 591 /**
 592  *
 593  */
 594 static gdouble
 595 _get_lon_max (VikMapSource *self)
 596 {
 597   g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), FALSE);
 598   VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 599   return priv->lon_max;
 600 }
 601
 602 static gboolean
 603 _coord_to_mapcoord ( VikMapSource *self, const VikCoord *src, gdouble xzoom, gdouble yzoom, MapCoord *dest )
 604 {
 605   g_assert ( src->mode == VIK_COORD_LATLON );
 606
 607   if ( xzoom != yzoom )
 608     return FALSE;
 609
 610   dest->scale = map_utils_mpp_to_scale ( xzoom );
 611   if ( dest->scale == 255 )
 612     return FALSE;
 613
 614   dest->x = (src->east_west + 180) / 360 * VIK_GZ(17) / xzoom;
 615   dest->y = (180 - MERCLAT(src->north_south)) / 360 * VIK_GZ(17) / xzoom;
 616   dest->z = 0;
 617
 618   return TRUE;
 619 }
 620
 621 static void
 622 _mapcoord_to_center_coord ( VikMapSource *self, MapCoord *src, VikCoord *dest )
 623 {
 624   gdouble socalled_mpp;
 625   if (src->scale >= 0)
 626     socalled_mpp = VIK_GZ(src->scale);
 627   else
 628     socalled_mpp = 1.0/VIK_GZ(-src->scale);
 629   dest->mode = VIK_COORD_LATLON;
 630   dest->east_west = ((src->x+0.5) / VIK_GZ(17) * socalled_mpp * 360) - 180;
 631   dest->north_south = DEMERCLAT(180 - ((src->y+0.5) / VIK_GZ(17) * socalled_mpp * 360));
 632 }
 633
 634 static gchar *
 635 _get_uri( VikMapSourceDefault *self, MapCoord *src )
 636 {
 637         g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), NULL);
 638
 639         VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 640
 641         gchar *uri = NULL;
 642         if ( priv->switch_xy )
 643                 // 'ARC GIS' Tile Server layout ordering
 644                 uri = g_strdup_printf (priv->url, 17 - src->scale, src->y, src->x);
 645         else
 646                 // (Default) Standard OSM Tile Server layout ordering
 647                 uri = g_strdup_printf (priv->url, 17 - src->scale, src->x, src->y);
 648
 649         return uri;
 650 }
 651
 652 static gchar *
 653 _get_hostname( VikMapSourceDefault *self )
 654 {
 655         g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), NULL);
 656
 657     VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 658         return g_strdup( priv->hostname );
 659 }
 660
 661 static DownloadMapOptions *
 662 _get_download_options( VikMapSourceDefault *self )
 663 {
 664         g_return_val_if_fail (VIK_IS_SLIPPY_MAP_SOURCE(self), NULL);
 665
 666         VikSlippyMapSourcePrivate *priv = VIK_SLIPPY_MAP_SOURCE_PRIVATE(self);
 667         return &(priv->options);
 668 }
 669
 670 VikSlippyMapSource *
 671 vik_slippy_map_source_new_with_id (guint16 id, const gchar *label, const gchar *hostname, const gchar *url)
 672 {
 673         return g_object_new(VIK_TYPE_SLIPPY_MAP_SOURCE,
 674                             "id", id, "label", label, "hostname", hostname, "url", url, NULL);
 675 }