src/vikmapsourcedefault.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * viking
   4  * Copyright (C) 2009-2010, 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: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
  29 #include "vikmapsourcedefault.h"
  30 #include "vikenumtypes.h"
  31 #include "download.h"
  32
  33 static void map_source_get_copyright (VikMapSource *self, LatLonBBox bbox, gdouble zoom, void (*fct)(VikViewport*,const gchar*), void *data);
  34 static const gchar *map_source_get_license (VikMapSource *self);
  35 static const gchar *map_source_get_license_url (VikMapSource *self);
  36 static const GdkPixbuf *map_source_get_logo (VikMapSource *self);
  37
  38 static const gchar *map_source_get_name (VikMapSource *self);
  39 static guint16 map_source_get_uniq_id (VikMapSource *self);
  40 static const gchar *map_source_get_label (VikMapSource *self);
  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);
  44 static const gchar *map_source_get_file_extension (VikMapSource *self);
  45
  46 static DownloadResult_t _download ( VikMapSource *self, MapCoord *src, const gchar *dest_fn, void *handle );
  47 static void * _download_handle_init ( VikMapSource *self );
  48 static void _download_handle_cleanup ( VikMapSource *self, void *handle );
  49
  50 typedef struct _VikMapSourceDefaultPrivate VikMapSourceDefaultPrivate;
  51 struct _VikMapSourceDefaultPrivate
  52 {
  53         /* legal stuff */
  54         gchar *copyright;
  55         gchar *license;
  56         gchar *license_url;
  57         GdkPixbuf *logo;
  58
  59         gchar *name;
  60         guint16 uniq_id;
  61         gchar *label;
  62         guint16 tilesize_x;
  63         guint16 tilesize_y;
  64         VikViewportDrawMode drawmode;
  65         gchar *file_extension;
  66 };
  67
  68 #define VIK_MAP_SOURCE_DEFAULT_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), VIK_TYPE_MAP_SOURCE_DEFAULT, VikMapSourceDefaultPrivate))
  69
  70 /* properties */
  71 enum
  72 {
  73   PROP_0,
  74
  75   PROP_NAME,
  76   PROP_ID,
  77   PROP_LABEL,
  78   PROP_TILESIZE_X,
  79   PROP_TILESIZE_Y,
  80   PROP_DRAWMODE,
  81   PROP_COPYRIGHT,
  82   PROP_LICENSE,
  83   PROP_LICENSE_URL,
  84   PROP_FILE_EXTENSION,
  85 };
  86
  87 G_DEFINE_ABSTRACT_TYPE (VikMapSourceDefault, vik_map_source_default, VIK_TYPE_MAP_SOURCE);
  88
  89 static void
  90 vik_map_source_default_init (VikMapSourceDefault *object)
  91 {
  92   VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
  93   VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);
  94
  95   priv->label = NULL;
  96   priv->copyright = NULL;
  97   priv->license = NULL;
  98   priv->license_url = NULL;
  99   priv->logo = NULL;
 100   priv->name = NULL;
 101   priv->file_extension = NULL;
 102 }
 103
 104 static void
 105 vik_map_source_default_finalize (GObject *object)
 106 {
 107   VikMapSourceDefault *self = VIK_MAP_SOURCE_DEFAULT (object);
 108   VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE (self);
 109
 110   g_free (priv->label);
 111   priv->label = NULL;
 112   g_free (priv->copyright);
 113   priv->copyright = NULL;
 114   g_free (priv->license);
 115   priv->license = NULL;
 116   g_free (priv->license_url);
 117   priv->license_url = NULL;
 118   g_free (priv->logo);
 119   priv->license_url = NULL;
 120   g_free (priv->name);
 121   priv->name = NULL;
 122   g_free (priv->file_extension);
 123   priv->file_extension = NULL;
 124
 125   G_OBJECT_CLASS (vik_map_source_default_parent_class)->finalize (object);
 126 }
 127
 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     {
 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
 147     case PROP_ID:
 148       priv->uniq_id = g_value_get_uint (value);
 149       break;
 150
 151     case PROP_LABEL:
 152       g_free (priv->label);
 153       priv->label = g_strdup(g_value_get_string (value));
 154       break;
 155
 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
 168     case PROP_COPYRIGHT:
 169       g_free (priv->copyright);
 170       priv->copyright = g_strdup(g_value_get_string (value));
 171       break;
 172
 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
 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
 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     {
 206     case PROP_NAME:
 207       g_value_set_string (value, priv->name);
 208       break;
 209
 210     case PROP_ID:
 211       g_value_set_uint (value, priv->uniq_id);
 212       break;
 213
 214     case PROP_LABEL:
 215       g_value_set_string (value, priv->label);
 216       break;
 217
 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
 230     case PROP_COPYRIGHT:
 231       g_value_set_string (value, priv->copyright);
 232       break;
 233
 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
 242     case PROP_FILE_EXTENSION:
 243       g_value_set_string (value, priv->file_extension);
 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_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);
 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
 263         /* Overiding methods */
 264         parent_class->get_copyright =   map_source_get_copyright;
 265         parent_class->get_license =     map_source_get_license;
 266         parent_class->get_license_url = map_source_get_license_url;
 267         parent_class->get_logo =        map_source_get_logo;
 268         parent_class->get_name =        map_source_get_name;
 269         parent_class->get_uniq_id =    map_source_get_uniq_id;
 270         parent_class->get_label =      map_source_get_label;
 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;
 274         parent_class->get_file_extension = map_source_get_file_extension;
 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;
 283
 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
 291         pspec = g_param_spec_uint ("id",
 292                                    "Id of the tool",
 293                                "Set the id",
 294                                0  /* minimum value */,
 295                                G_MAXUINT /* maximum value */,
 296                                0  /* default value */,
 297                                G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
 298         g_object_class_install_property (object_class, PROP_ID, pspec);
 299
 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
 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 */,
 313                                G_PARAM_READWRITE);
 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 */,
 322                                G_PARAM_READWRITE);
 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
 333         pspec = g_param_spec_string ("copyright",
 334                                      "Copyright",
 335                                      "The copyright of the map source",
 336                                      NULL,
 337                                      G_PARAM_READWRITE);
 338         g_object_class_install_property (object_class, PROP_COPYRIGHT, pspec);
 339
 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
 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
 361         g_type_class_add_private (klass, sizeof (VikMapSourceDefaultPrivate));
 362
 363         object_class->finalize = vik_map_source_default_finalize;
 364 }
 365
 366 static void
 367 map_source_get_copyright (VikMapSource *self, LatLonBBox bbox, gdouble zoom, void (*fct)(VikViewport*,const gchar*), void *data)
 368 {
 369         /* Just ignore bbox and zoom level */
 370         g_return_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self));
 371
 372         VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 373
 374         (*fct) (data, priv->copyright);
 375 }
 376
 377 static const gchar *
 378 map_source_get_license (VikMapSource *self)
 379 {
 380         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
 381
 382         VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 383
 384         return priv->license;
 385 }
 386
 387 static const gchar *
 388 map_source_get_license_url (VikMapSource *self)
 389 {
 390         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
 391
 392         VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 393
 394         return priv->license_url;
 395 }
 396
 397 static const GdkPixbuf *
 398 map_source_get_logo (VikMapSource *self)
 399 {
 400         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
 401
 402         VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 403
 404         return priv->logo;
 405 }
 406
 407 static const gchar *
 408 map_source_get_name (VikMapSource *self)
 409 {
 410         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
 411         VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 412         return priv->name;
 413 }
 414
 415 static guint16
 416 map_source_get_uniq_id (VikMapSource *self)
 417 {
 418         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);
 419
 420         VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 421
 422         return priv->uniq_id;
 423 }
 424
 425 static const gchar *
 426 map_source_get_label (VikMapSource *self)
 427 {
 428         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
 429
 430         VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 431
 432         return priv->label;
 433 }
 434
 435 static guint16
 436 map_source_get_tilesize_x (VikMapSource *self)
 437 {
 438         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);
 439
 440     VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 441
 442         return priv->tilesize_x;
 443 }
 444
 445 static guint16
 446 map_source_get_tilesize_y (VikMapSource *self)
 447 {
 448         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (guint16)0);
 449
 450     VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 451
 452         return priv->tilesize_y;
 453 }
 454
 455 static VikViewportDrawMode
 456 map_source_get_drawmode (VikMapSource *self)
 457 {
 458         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), (VikViewportDrawMode)0);
 459
 460     VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 461
 462         return priv->drawmode;
 463 }
 464
 465 static DownloadResult_t
 466 _download ( VikMapSource *self, MapCoord *src, const gchar *dest_fn, void *handle )
 467 {
 468    gchar *uri = vik_map_source_default_get_uri(VIK_MAP_SOURCE_DEFAULT(self), src);
 469    gchar *host = vik_map_source_default_get_hostname(VIK_MAP_SOURCE_DEFAULT(self));
 470    DownloadMapOptions *options = vik_map_source_default_get_download_options(VIK_MAP_SOURCE_DEFAULT(self));
 471    DownloadResult_t res = a_http_download_get_url ( host, uri, dest_fn, options, handle );
 472    g_free ( uri );
 473    g_free ( host );
 474    return res;
 475 }
 476
 477 static const gchar *
 478 map_source_get_file_extension (VikMapSource *self)
 479 {
 480     g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT(self), NULL);
 481     VikMapSourceDefaultPrivate *priv = VIK_MAP_SOURCE_DEFAULT_PRIVATE(self);
 482     return priv->file_extension;
 483 }
 484
 485 static void *
 486 _download_handle_init ( VikMapSource *self )
 487 {
 488    return a_download_handle_init ();
 489 }
 490
 491
 492 static void
 493 _download_handle_cleanup ( VikMapSource *self, void *handle )
 494 {
 495    a_download_handle_cleanup ( handle );
 496 }
 497
 498 gchar *
 499 vik_map_source_default_get_uri( VikMapSourceDefault *self, MapCoord *src )
 500 {
 501         VikMapSourceDefaultClass *klass;
 502         g_return_val_if_fail (self != NULL, 0);
 503         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
 504         klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);
 505
 506         g_return_val_if_fail (klass->get_uri != NULL, 0);
 507
 508         return (*klass->get_uri)(self, src);
 509 }
 510
 511 gchar *
 512 vik_map_source_default_get_hostname( VikMapSourceDefault *self )
 513 {
 514         VikMapSourceDefaultClass *klass;
 515         g_return_val_if_fail (self != NULL, 0);
 516         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
 517         klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);
 518
 519         g_return_val_if_fail (klass->get_hostname != NULL, 0);
 520
 521         return (*klass->get_hostname)(self);
 522 }
 523
 524 DownloadMapOptions *
 525 vik_map_source_default_get_download_options( VikMapSourceDefault *self )
 526 {
 527         VikMapSourceDefaultClass *klass;
 528         g_return_val_if_fail (self != NULL, 0);
 529         g_return_val_if_fail (VIK_IS_MAP_SOURCE_DEFAULT (self), 0);
 530         klass = VIK_MAP_SOURCE_DEFAULT_GET_CLASS(self);
 531
 532         g_return_val_if_fail (klass->get_download_options != NULL, 0);
 533
 534         return (*klass->get_download_options)(self);
 535 }