src/viklayer.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2005, Alex Foobarian <foobarian@gmail.com>
   5  * Copyright (C) 2003-2007, Evan Battaglia <gtoevan@gmx.net>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <glib/gi18n.h>
  28
  29 #include "viking.h"
  30 #include <string.h>
  31
  32 /* functions common to all layers. */
  33 /* TODO longone: rename interface free -> finalize */
  34
  35 extern VikLayerInterface vik_aggregate_layer_interface;
  36 extern VikLayerInterface vik_trw_layer_interface;
  37 extern VikLayerInterface vik_maps_layer_interface;
  38 extern VikLayerInterface vik_coord_layer_interface;
  39 extern VikLayerInterface vik_georef_layer_interface;
  40 extern VikLayerInterface vik_gps_layer_interface;
  41 extern VikLayerInterface vik_dem_layer_interface;
  42
  43 enum {
  44   VL_UPDATE_SIGNAL,
  45   VL_LAST_SIGNAL
  46 };
  47 static guint layer_signals[VL_LAST_SIGNAL] = { 0 };
  48
  49 static GObjectClass *parent_class;
  50
  51 static void layer_class_init ( VikLayerClass *klass );
  52 static void layer_init ( VikLayer *vl );
  53 static void layer_finalize ( VikLayer *vl );
  54 static gboolean layer_properties_factory ( VikLayer *vl, VikViewport *vp );
  55
  56
  57 /* TODO longone: rename vik_layer_init -> set_type */
  58
  59 GType vik_layer_get_type ()
  60 {
  61   static GType vl_type = 0;
  62
  63   if (!vl_type)
  64   {
  65     static const GTypeInfo vl_info =
  66     {
  67       sizeof (VikLayerClass),
  68       NULL, /* base_init */
  69       NULL, /* base_finalize */
  70       (GClassInitFunc) layer_class_init, /* class init */
  71       NULL, /* class_finalize */
  72       NULL, /* class_data */
  73       sizeof (VikLayer),
  74       0,
  75       (GInstanceInitFunc) layer_init /* instance init */
  76     };
  77     vl_type = g_type_register_static ( G_TYPE_OBJECT, "VikLayer", &vl_info, 0 );
  78   }
  79
  80   return vl_type;
  81 }
  82
  83 static void layer_class_init (VikLayerClass *klass)
  84 {
  85   GObjectClass *object_class;
  86
  87   object_class = G_OBJECT_CLASS (klass);
  88
  89   object_class->finalize = (GObjectFinalizeFunc) layer_finalize;
  90
  91   parent_class = g_type_class_peek_parent (klass);
  92
  93   layer_signals[VL_UPDATE_SIGNAL] = g_signal_new ( "update", G_TYPE_FROM_CLASS (klass),
  94       G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikLayerClass, update), NULL, NULL,
  95       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
  96 }
  97
  98 void vik_layer_emit_update ( VikLayer *vl )
  99 {
 100   if ( vl->visible ) {
 101     vik_window_set_redraw_trigger(vl);
 102     g_signal_emit ( G_OBJECT(vl), layer_signals[VL_UPDATE_SIGNAL], 0 );
 103   }
 104 }
 105
 106 /* should only be done by VikLayersPanel -- need to redraw and record trigger
 107  * when we make a layer invisible.
 108  */
 109 void vik_layer_emit_update_although_invisible ( VikLayer *vl )
 110 {
 111   vik_window_set_redraw_trigger(vl);
 112   g_signal_emit ( G_OBJECT(vl), layer_signals[VL_UPDATE_SIGNAL], 0 );
 113 }
 114
 115 /* doesn't set the trigger. should be done by aggregate layer when child emits update. */
 116 void vik_layer_emit_update_secondary ( VikLayer *vl )
 117 {
 118   if ( vl->visible )
 119     g_signal_emit ( G_OBJECT(vl), layer_signals[VL_UPDATE_SIGNAL], 0 );
 120 }
 121
 122 static VikLayerInterface *vik_layer_interfaces[VIK_LAYER_NUM_TYPES] = {
 123   &vik_aggregate_layer_interface,
 124   &vik_trw_layer_interface,
 125   &vik_coord_layer_interface,
 126   &vik_georef_layer_interface,
 127   &vik_gps_layer_interface,
 128   &vik_maps_layer_interface,
 129   &vik_dem_layer_interface,
 130 };
 131
 132 VikLayerInterface *vik_layer_get_interface ( gint type )
 133 {
 134   g_assert ( type < VIK_LAYER_NUM_TYPES );
 135   return vik_layer_interfaces[type];
 136 }
 137
 138 static void layer_init ( VikLayer *vl )
 139 {
 140   vl->visible = TRUE;
 141   vl->name = NULL;
 142   vl->realized = FALSE;
 143 }
 144
 145 void vik_layer_init ( VikLayer *vl, gint type )
 146 {
 147   vl->type = type;
 148 }
 149
 150 /* frees old name */
 151 void vik_layer_rename ( VikLayer *l, const gchar *new_name )
 152 {
 153   g_assert ( l != NULL );
 154   g_assert ( new_name != NULL );
 155   g_free ( l->name );
 156   l->name = g_strdup ( new_name );
 157 }
 158
 159 void vik_layer_rename_no_copy ( VikLayer *l, gchar *new_name )
 160 {
 161   g_assert ( l != NULL );
 162   g_assert ( new_name != NULL );
 163   g_free ( l->name );
 164   l->name = new_name;
 165 }
 166
 167 const gchar *vik_layer_get_name ( VikLayer *l )
 168 {
 169   g_assert ( l != NULL);
 170   return l->name;
 171 }
 172
 173 VikLayer *vik_layer_create ( gint type, gpointer vp, GtkWindow *w, gboolean interactive )
 174 {
 175   VikLayer *new_layer = NULL;
 176   g_assert ( type < VIK_LAYER_NUM_TYPES );
 177
 178   new_layer = vik_layer_interfaces[type]->create ( vp );
 179
 180   g_assert ( new_layer != NULL );
 181
 182   if ( interactive )
 183   {
 184     if ( vik_layer_properties ( new_layer, vp ) )
 185       /* We translate the name here */
 186       /* in order to avoid translating name set by user */
 187       vik_layer_rename ( VIK_LAYER(new_layer), _(vik_layer_interfaces[type]->name) );
 188     else
 189     {
 190       g_object_unref ( G_OBJECT(new_layer) ); /* cancel that */
 191       new_layer = NULL;
 192     }
 193   }
 194   return new_layer;
 195 }
 196
 197 /* returns TRUE if OK was pressed */
 198 gboolean vik_layer_properties ( VikLayer *layer, gpointer vp )
 199 {
 200   if ( vik_layer_interfaces[layer->type]->properties )
 201     return vik_layer_interfaces[layer->type]->properties ( layer, vp );
 202   return layer_properties_factory ( layer, vp );
 203 }
 204
 205 void vik_layer_draw ( VikLayer *l, gpointer data )
 206 {
 207   if ( l->visible )
 208     if ( vik_layer_interfaces[l->type]->draw )
 209       vik_layer_interfaces[l->type]->draw ( l, data );
 210 }
 211
 212 void vik_layer_change_coord_mode ( VikLayer *l, VikCoordMode mode )
 213 {
 214   if ( vik_layer_interfaces[l->type]->change_coord_mode )
 215     vik_layer_interfaces[l->type]->change_coord_mode ( l, mode );
 216 }
 217
 218 typedef struct {
 219   gint layer_type;
 220   gint len;
 221   guint8 data[0];
 222 } header_t;
 223
 224 void vik_layer_marshall ( VikLayer *vl, guint8 **data, gint *len )
 225 {
 226   header_t *header;
 227   if ( vl && vik_layer_interfaces[vl->type]->marshall ) {
 228     vik_layer_interfaces[vl->type]->marshall ( vl, data, len );
 229     if (*data) {
 230       header = g_malloc(*len + sizeof(*header));
 231       header->layer_type = vl->type;
 232       header->len = *len;
 233       memcpy(header->data, *data, *len);
 234       g_free(*data);
 235       *data = (guint8 *)header;
 236       *len = *len + sizeof(*header);
 237     }
 238   } else {
 239     *data = NULL;
 240   }
 241 }
 242
 243 void vik_layer_marshall_params ( VikLayer *vl, guint8 **data, gint *datalen )
 244 {
 245   VikLayerParam *params = vik_layer_get_interface(vl->type)->params;
 246   VikLayerFuncGetParam get_param = vik_layer_get_interface(vl->type)->get_param;
 247   GByteArray* b = g_byte_array_new ();
 248   gint len;
 249
 250 #define vlm_append(obj, sz)     \
 251   len = (sz);                   \
 252   g_byte_array_append ( b, (guint8 *)&len, sizeof(len) );       \
 253   g_byte_array_append ( b, (guint8 *)(obj), len );
 254
 255   vlm_append(vl->name, strlen(vl->name));
 256
 257   if ( params && get_param )
 258   {
 259     VikLayerParamData d;
 260     guint16 i, params_count = vik_layer_get_interface(vl->type)->params_count;
 261     for ( i = 0; i < params_count; i++ )
 262     {
 263       g_debug("%s: %s", __FUNCTION__, params[i].name);
 264       d = get_param(vl, i, FALSE);
 265       switch ( params[i].type )
 266       {
 267       case VIK_LAYER_PARAM_STRING:
 268         vlm_append(d.s, strlen(d.s));
 269         break;
 270
 271       /* print out the string list in the array */
 272       case VIK_LAYER_PARAM_STRING_LIST: {
 273         GList *list = d.sl;
 274
 275         /* write length of list (# of strings) */
 276         gint listlen = g_list_length ( list );
 277         g_byte_array_append ( b, (guint8 *)&listlen, sizeof(listlen) );
 278
 279         /* write each string */
 280         while ( list ) {
 281           gchar *s = (gchar *) list->data;
 282           vlm_append(s, strlen(s));
 283           list = list->next;
 284         }
 285
 286         break;
 287       }
 288       default:
 289         vlm_append(&d, sizeof(d));
 290         break;
 291       }
 292     }
 293   }
 294
 295   *data = b->data;
 296   *datalen = b->len;
 297   g_byte_array_free ( b, FALSE );
 298
 299 #undef vlm_append
 300 }
 301
 302 void vik_layer_unmarshall_params ( VikLayer *vl, guint8 *data, gint datalen, VikViewport *vvp )
 303 {
 304   VikLayerParam *params = vik_layer_get_interface(vl->type)->params;
 305   VikLayerFuncSetParam set_param = vik_layer_get_interface(vl->type)->set_param;
 306   gchar *s;
 307   guint8 *b = (guint8 *)data;
 308
 309 #define vlm_size (*(gint *)b)
 310 #define vlm_read(obj)                           \
 311   memcpy((obj), b+sizeof(gint), vlm_size);      \
 312   b += sizeof(gint) + vlm_size;
 313
 314   s = g_malloc(vlm_size + 1);
 315   s[vlm_size]=0;
 316   vlm_read(s);
 317
 318   vik_layer_rename(vl, s);
 319
 320   g_free(s);
 321
 322   if ( params && set_param )
 323   {
 324     VikLayerParamData d;
 325     guint16 i, params_count = vik_layer_get_interface(vl->type)->params_count;
 326     for ( i = 0; i < params_count; i++ )
 327     {
 328       g_debug("%s: %s", __FUNCTION__, params[i].name);
 329       switch ( params[i].type )
 330       {
 331       case VIK_LAYER_PARAM_STRING:
 332         s = g_malloc(vlm_size + 1);
 333         s[vlm_size]=0;
 334         vlm_read(s);
 335         d.s = s;
 336         set_param(vl, i, d, vvp, FALSE);
 337         g_free(s);
 338         break;
 339       case VIK_LAYER_PARAM_STRING_LIST:  {
 340         gint listlen = vlm_size, j;
 341         GList *list = NULL;
 342         b += sizeof(gint); /* skip listlen */;
 343
 344         for ( j = 0; j < listlen; j++ ) {
 345           /* get a string */
 346           s = g_malloc(vlm_size + 1);
 347           s[vlm_size]=0;
 348           vlm_read(s);
 349           list = g_list_append ( list, s );
 350         }
 351         d.sl = list;
 352         set_param(vl, i, d, vvp, FALSE);
 353         /* don't free -- string list is responsibility of the layer */
 354
 355         break;
 356         }
 357       default:
 358         vlm_read(&d);
 359         set_param(vl, i, d, vvp, FALSE);
 360         break;
 361       }
 362     }
 363   }
 364 }
 365
 366 VikLayer *vik_layer_unmarshall ( guint8 *data, gint len, VikViewport *vvp )
 367 {
 368   header_t *header;
 369
 370   header = (header_t *)data;
 371
 372   if ( vik_layer_interfaces[header->layer_type]->unmarshall ) {
 373     return vik_layer_interfaces[header->layer_type]->unmarshall ( header->data, header->len, vvp );
 374   } else {
 375     return NULL;
 376   }
 377 }
 378
 379 static void layer_finalize ( VikLayer *vl )
 380 {
 381   g_assert ( vl != NULL );
 382   if ( vik_layer_interfaces[vl->type]->free )
 383     vik_layer_interfaces[vl->type]->free ( vl );
 384   if ( vl->name )
 385     g_free ( vl->name );
 386   G_OBJECT_CLASS(parent_class)->finalize(G_OBJECT(vl));
 387 }
 388
 389 /* sublayer switching */
 390 gboolean vik_layer_sublayer_toggle_visible ( VikLayer *l, gint subtype, gpointer sublayer )
 391 {
 392   if ( vik_layer_interfaces[l->type]->sublayer_toggle_visible )
 393     return vik_layer_interfaces[l->type]->sublayer_toggle_visible ( l, subtype, sublayer );
 394   return TRUE; /* if unknown, will always be visible */
 395 }
 396
 397 void vik_layer_realize ( VikLayer *l, VikTreeview *vt, GtkTreeIter *layer_iter )
 398 {
 399   l->vt = vt;
 400   l->iter = *layer_iter;
 401   l->realized = TRUE;
 402   if ( vik_layer_interfaces[l->type]->realize )
 403     vik_layer_interfaces[l->type]->realize ( l, vt, layer_iter );
 404 }
 405
 406 void vik_layer_set_menu_items_selection(VikLayer *l, guint16 selection)
 407 {
 408   if ( vik_layer_interfaces[l->type]->set_menu_selection )
 409     vik_layer_interfaces[l->type]->set_menu_selection ( l, selection );
 410 }
 411
 412 guint16 vik_layer_get_menu_items_selection(VikLayer *l)
 413 {
 414   if ( vik_layer_interfaces[l->type]->get_menu_selection )
 415     return(vik_layer_interfaces[l->type]->get_menu_selection (l));
 416   else
 417     return(vik_layer_interfaces[l->type]->menu_items_selection);
 418 }
 419
 420 void vik_layer_add_menu_items ( VikLayer *l, GtkMenu *menu, gpointer vlp )
 421 {
 422   if ( vik_layer_interfaces[l->type]->add_menu_items )
 423     vik_layer_interfaces[l->type]->add_menu_items ( l, menu, vlp );
 424 }
 425
 426 gboolean vik_layer_sublayer_add_menu_items ( VikLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
 427 {
 428   if ( vik_layer_interfaces[l->type]->sublayer_add_menu_items )
 429     return vik_layer_interfaces[l->type]->sublayer_add_menu_items ( l, menu, vlp, subtype, sublayer, iter );
 430   return FALSE;
 431 }
 432
 433
 434 const gchar *vik_layer_sublayer_rename_request ( VikLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
 435 {
 436   if ( vik_layer_interfaces[l->type]->sublayer_rename_request )
 437     return vik_layer_interfaces[l->type]->sublayer_rename_request ( l, newname, vlp, subtype, sublayer, iter );
 438   return NULL;
 439 }
 440
 441 GdkPixbuf *vik_layer_load_icon ( gint type )
 442 {
 443   g_assert ( type < VIK_LAYER_NUM_TYPES );
 444   if ( vik_layer_interfaces[type]->icon )
 445     return gdk_pixbuf_from_pixdata ( vik_layer_interfaces[type]->icon, FALSE, NULL );
 446   return NULL;
 447 }
 448
 449 gboolean vik_layer_set_param ( VikLayer *layer, guint16 id, VikLayerParamData data, gpointer vp, gboolean is_file_operation )
 450 {
 451   if ( vik_layer_interfaces[layer->type]->set_param )
 452     return vik_layer_interfaces[layer->type]->set_param ( layer, id, data, vp, is_file_operation );
 453   return FALSE;
 454 }
 455
 456 void vik_layer_post_read ( VikLayer *layer, VikViewport *vp, gboolean from_file )
 457 {
 458   if ( vik_layer_interfaces[layer->type]->post_read )
 459     vik_layer_interfaces[layer->type]->post_read ( layer, vp, from_file );
 460 }
 461
 462 static gboolean layer_properties_factory ( VikLayer *vl, VikViewport *vp )
 463 {
 464   switch ( a_uibuilder_properties_factory ( _("Layer Properties"),
 465                                             VIK_GTK_WINDOW_FROM_WIDGET(vp),
 466                                             vik_layer_interfaces[vl->type]->params,
 467                                             vik_layer_interfaces[vl->type]->params_count,
 468                                             vik_layer_interfaces[vl->type]->params_groups,
 469                                             vik_layer_interfaces[vl->type]->params_groups_count,
 470                                             (gpointer) vik_layer_interfaces[vl->type]->set_param,
 471                                             vl,
 472                                             vp,
 473                                             (gpointer) vik_layer_interfaces[vl->type]->get_param,
 474                                             vl) ) {
 475     case 0:
 476     case 3:
 477       return FALSE;
 478       /* redraw (?) */
 479     case 2:
 480       vik_layer_post_read ( vl, vp, FALSE ); /* update any gc's */
 481     default:
 482       return TRUE;
 483   }
 484 }
 485