src/viklayer.c

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