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 vik_layer_finalize ( VikLayer *vl );
  52 static gboolean vik_layer_properties_factory ( VikLayer *vl, VikViewport *vp );
  53
  54 G_DEFINE_TYPE (VikLayer, vik_layer, G_TYPE_OBJECT)
  55
  56 static void vik_layer_class_init (VikLayerClass *klass)
  57 {
  58   GObjectClass *object_class;
  59
  60   object_class = G_OBJECT_CLASS (klass);
  61
  62   object_class->finalize = (GObjectFinalizeFunc) vik_layer_finalize;
  63
  64   parent_class = g_type_class_peek_parent (klass);
  65
  66   layer_signals[VL_UPDATE_SIGNAL] = g_signal_new ( "update", G_TYPE_FROM_CLASS (klass),
  67       G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikLayerClass, update), NULL, NULL,
  68       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
  69 }
  70
  71 /**
  72  * Invoke the actual drawing via signal method
  73  */
  74 static gboolean idle_draw ( VikLayer *vl )
  75 {
  76   g_signal_emit ( G_OBJECT(vl), layer_signals[VL_UPDATE_SIGNAL], 0 );
  77   return FALSE; // Nothing else to do
  78 }
  79
  80 /**
  81  * Draw specified layer
  82  */
  83 void vik_layer_emit_update ( VikLayer *vl, gboolean from_background )
  84 {
  85   if ( vl->visible ) {
  86     vik_window_set_redraw_trigger(vl);
  87
  88     // Only ever draw when there is time to do so
  89     if ( from_background )
  90       // Drawing requested from background thread, so handle via the gdk thread method
  91       gdk_threads_add_idle ( (GSourceFunc) idle_draw, vl );
  92     else
  93       g_idle_add ( (GSourceFunc) idle_draw, vl );
  94   }
  95 }
  96
  97 /**
  98  * should only be done by VikLayersPanel (hence never used from the background)
  99  * need to redraw and record trigger when we make a layer invisible.
 100  */
 101 void vik_layer_emit_update_although_invisible ( VikLayer *vl )
 102 {
 103   vik_window_set_redraw_trigger(vl);
 104   g_idle_add ( (GSourceFunc) idle_draw, vl );
 105 }
 106
 107 /* doesn't set the trigger. should be done by aggregate layer when child emits update. */
 108 void vik_layer_emit_update_secondary ( VikLayer *vl )
 109 {
 110   if ( vl->visible )
 111     // TODO: this can used from the background - eg in acquire
 112     //       so will need to flow background update status through too
 113     g_idle_add ( (GSourceFunc) idle_draw, vl );
 114 }
 115
 116 static VikLayerInterface *vik_layer_interfaces[VIK_LAYER_NUM_TYPES] = {
 117   &vik_aggregate_layer_interface,
 118   &vik_trw_layer_interface,
 119   &vik_coord_layer_interface,
 120   &vik_georef_layer_interface,
 121   &vik_gps_layer_interface,
 122   &vik_maps_layer_interface,
 123   &vik_dem_layer_interface,
 124 };
 125
 126 VikLayerInterface *vik_layer_get_interface ( gint type )
 127 {
 128   g_assert ( type < VIK_LAYER_NUM_TYPES );
 129   return vik_layer_interfaces[type];
 130 }
 131
 132 static void vik_layer_init ( VikLayer *vl )
 133 {
 134   vl->visible = TRUE;
 135   vl->name = NULL;
 136   vl->realized = FALSE;
 137 }
 138
 139 void vik_layer_set_type ( VikLayer *vl, gint type )
 140 {
 141   vl->type = type;
 142 }
 143
 144 /* frees old name */
 145 void vik_layer_rename ( VikLayer *l, const gchar *new_name )
 146 {
 147   g_assert ( l != NULL );
 148   g_assert ( new_name != NULL );
 149   g_free ( l->name );
 150   l->name = g_strdup ( new_name );
 151 }
 152
 153 void vik_layer_rename_no_copy ( VikLayer *l, gchar *new_name )
 154 {
 155   g_assert ( l != NULL );
 156   g_assert ( new_name != NULL );
 157   g_free ( l->name );
 158   l->name = new_name;
 159 }
 160
 161 const gchar *vik_layer_get_name ( VikLayer *l )
 162 {
 163   g_assert ( l != NULL);
 164   return l->name;
 165 }
 166
 167 VikLayer *vik_layer_create ( gint type, gpointer vp, GtkWindow *w, gboolean interactive )
 168 {
 169   VikLayer *new_layer = NULL;
 170   g_assert ( type < VIK_LAYER_NUM_TYPES );
 171
 172   new_layer = vik_layer_interfaces[type]->create ( vp );
 173
 174   g_assert ( new_layer != NULL );
 175
 176   if ( interactive )
 177   {
 178     if ( vik_layer_properties ( new_layer, vp ) )
 179       /* We translate the name here */
 180       /* in order to avoid translating name set by user */
 181       vik_layer_rename ( VIK_LAYER(new_layer), _(vik_layer_interfaces[type]->name) );
 182     else
 183     {
 184       g_object_unref ( G_OBJECT(new_layer) ); /* cancel that */
 185       new_layer = NULL;
 186     }
 187   }
 188   return new_layer;
 189 }
 190
 191 /* returns TRUE if OK was pressed */
 192 gboolean vik_layer_properties ( VikLayer *layer, gpointer vp )
 193 {
 194   if ( vik_layer_interfaces[layer->type]->properties )
 195     return vik_layer_interfaces[layer->type]->properties ( layer, vp );
 196   return vik_layer_properties_factory ( layer, vp );
 197 }
 198
 199 void vik_layer_draw ( VikLayer *l, gpointer data )
 200 {
 201   if ( l->visible )
 202     if ( vik_layer_interfaces[l->type]->draw )
 203       vik_layer_interfaces[l->type]->draw ( l, data );
 204 }
 205
 206 void vik_layer_change_coord_mode ( VikLayer *l, VikCoordMode mode )
 207 {
 208   if ( vik_layer_interfaces[l->type]->change_coord_mode )
 209     vik_layer_interfaces[l->type]->change_coord_mode ( l, mode );
 210 }
 211
 212 typedef struct {
 213   gint layer_type;
 214   gint len;
 215   guint8 data[0];
 216 } header_t;
 217
 218 void vik_layer_marshall ( VikLayer *vl, guint8 **data, gint *len )
 219 {
 220   header_t *header;
 221   if ( vl && vik_layer_interfaces[vl->type]->marshall ) {
 222     vik_layer_interfaces[vl->type]->marshall ( vl, data, len );
 223     if (*data) {
 224       header = g_malloc(*len + sizeof(*header));
 225       header->layer_type = vl->type;
 226       header->len = *len;
 227       memcpy(header->data, *data, *len);
 228       g_free(*data);
 229       *data = (guint8 *)header;
 230       *len = *len + sizeof(*header);
 231     }
 232   } else {
 233     *data = NULL;
 234   }
 235 }
 236
 237 void vik_layer_marshall_params ( VikLayer *vl, guint8 **data, gint *datalen )
 238 {
 239   VikLayerParam *params = vik_layer_get_interface(vl->type)->params;
 240   VikLayerFuncGetParam get_param = vik_layer_get_interface(vl->type)->get_param;
 241   GByteArray* b = g_byte_array_new ();
 242   gint len;
 243
 244 #define vlm_append(obj, sz)     \
 245   len = (sz);                   \
 246   g_byte_array_append ( b, (guint8 *)&len, sizeof(len) );       \
 247   g_byte_array_append ( b, (guint8 *)(obj), len );
 248
 249   vlm_append(vl->name, strlen(vl->name));
 250
 251   if ( params && get_param )
 252   {
 253     VikLayerParamData d;
 254     guint16 i, params_count = vik_layer_get_interface(vl->type)->params_count;
 255     for ( i = 0; i < params_count; i++ )
 256     {
 257       g_debug("%s: %s", __FUNCTION__, params[i].name);
 258       d = get_param(vl, i, FALSE);
 259       switch ( params[i].type )
 260       {
 261       case VIK_LAYER_PARAM_STRING:
 262         vlm_append(d.s, strlen(d.s));
 263         break;
 264
 265       /* print out the string list in the array */
 266       case VIK_LAYER_PARAM_STRING_LIST: {
 267         GList *list = d.sl;
 268
 269         /* write length of list (# of strings) */
 270         gint listlen = g_list_length ( list );
 271         g_byte_array_append ( b, (guint8 *)&listlen, sizeof(listlen) );
 272
 273         /* write each string */
 274         while ( list ) {
 275           gchar *s = (gchar *) list->data;
 276           vlm_append(s, strlen(s));
 277           list = list->next;
 278         }
 279
 280         break;
 281       }
 282       default:
 283         vlm_append(&d, sizeof(d));
 284         break;
 285       }
 286     }
 287   }
 288
 289   *data = b->data;
 290   *datalen = b->len;
 291   g_byte_array_free ( b, FALSE );
 292
 293 #undef vlm_append
 294 }
 295
 296 void vik_layer_unmarshall_params ( VikLayer *vl, guint8 *data, gint datalen, VikViewport *vvp )
 297 {
 298   VikLayerParam *params = vik_layer_get_interface(vl->type)->params;
 299   VikLayerFuncSetParam set_param = vik_layer_get_interface(vl->type)->set_param;
 300   gchar *s;
 301   guint8 *b = (guint8 *)data;
 302
 303 #define vlm_size (*(gint *)b)
 304 #define vlm_read(obj)                           \
 305   memcpy((obj), b+sizeof(gint), vlm_size);      \
 306   b += sizeof(gint) + vlm_size;
 307
 308   s = g_malloc(vlm_size + 1);
 309   s[vlm_size]=0;
 310   vlm_read(s);
 311
 312   vik_layer_rename(vl, s);
 313
 314   g_free(s);
 315
 316   if ( params && set_param )
 317   {
 318     VikLayerParamData d;
 319     guint16 i, params_count = vik_layer_get_interface(vl->type)->params_count;
 320     for ( i = 0; i < params_count; i++ )
 321     {
 322       g_debug("%s: %s", __FUNCTION__, params[i].name);
 323       switch ( params[i].type )
 324       {
 325       case VIK_LAYER_PARAM_STRING:
 326         s = g_malloc(vlm_size + 1);
 327         s[vlm_size]=0;
 328         vlm_read(s);
 329         d.s = s;
 330         set_param(vl, i, d, vvp, FALSE);
 331         g_free(s);
 332         break;
 333       case VIK_LAYER_PARAM_STRING_LIST:  {
 334         gint listlen = vlm_size, j;
 335         GList *list = NULL;
 336         b += sizeof(gint); /* skip listlen */;
 337
 338         for ( j = 0; j < listlen; j++ ) {
 339           /* get a string */
 340           s = g_malloc(vlm_size + 1);
 341           s[vlm_size]=0;
 342           vlm_read(s);
 343           list = g_list_append ( list, s );
 344         }
 345         d.sl = list;
 346         set_param(vl, i, d, vvp, FALSE);
 347         /* don't free -- string list is responsibility of the layer */
 348
 349         break;
 350         }
 351       default:
 352         vlm_read(&d);
 353         set_param(vl, i, d, vvp, FALSE);
 354         break;
 355       }
 356     }
 357   }
 358 }
 359
 360 VikLayer *vik_layer_unmarshall ( guint8 *data, gint len, VikViewport *vvp )
 361 {
 362   header_t *header;
 363
 364   header = (header_t *)data;
 365
 366   if ( vik_layer_interfaces[header->layer_type]->unmarshall ) {
 367     return vik_layer_interfaces[header->layer_type]->unmarshall ( header->data, header->len, vvp );
 368   } else {
 369     return NULL;
 370   }
 371 }
 372
 373 static void vik_layer_finalize ( VikLayer *vl )
 374 {
 375   g_assert ( vl != NULL );
 376   if ( vik_layer_interfaces[vl->type]->free )
 377     vik_layer_interfaces[vl->type]->free ( vl );
 378   if ( vl->name )
 379     g_free ( vl->name );
 380   G_OBJECT_CLASS(parent_class)->finalize(G_OBJECT(vl));
 381 }
 382
 383 /* sublayer switching */
 384 gboolean vik_layer_sublayer_toggle_visible ( VikLayer *l, gint subtype, gpointer sublayer )
 385 {
 386   if ( vik_layer_interfaces[l->type]->sublayer_toggle_visible )
 387     return vik_layer_interfaces[l->type]->sublayer_toggle_visible ( l, subtype, sublayer );
 388   return TRUE; /* if unknown, will always be visible */
 389 }
 390
 391 gboolean vik_layer_selected ( VikLayer *l, gint subtype, gpointer sublayer, gint type, gpointer vlp )
 392 {
 393   if ( vik_layer_interfaces[l->type]->layer_selected )
 394     return vik_layer_interfaces[l->type]->layer_selected ( l, subtype, sublayer, type, vlp );
 395   /* Since no 'layer_selected' function explicitly turn off here */
 396   return vik_window_clear_highlight ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(l) );
 397 }
 398
 399 void vik_layer_realize ( VikLayer *l, VikTreeview *vt, GtkTreeIter *layer_iter )
 400 {
 401   l->vt = vt;
 402   l->iter = *layer_iter;
 403   l->realized = TRUE;
 404   if ( vik_layer_interfaces[l->type]->realize )
 405     vik_layer_interfaces[l->type]->realize ( l, vt, layer_iter );
 406 }
 407
 408 void vik_layer_set_menu_items_selection(VikLayer *l, guint16 selection)
 409 {
 410   if ( vik_layer_interfaces[l->type]->set_menu_selection )
 411     vik_layer_interfaces[l->type]->set_menu_selection ( l, selection );
 412 }
 413
 414 guint16 vik_layer_get_menu_items_selection(VikLayer *l)
 415 {
 416   if ( vik_layer_interfaces[l->type]->get_menu_selection )
 417     return(vik_layer_interfaces[l->type]->get_menu_selection (l));
 418   else
 419     return(vik_layer_interfaces[l->type]->menu_items_selection);
 420 }
 421
 422 void vik_layer_add_menu_items ( VikLayer *l, GtkMenu *menu, gpointer vlp )
 423 {
 424   if ( vik_layer_interfaces[l->type]->add_menu_items )
 425     vik_layer_interfaces[l->type]->add_menu_items ( l, menu, vlp );
 426 }
 427
 428 gboolean vik_layer_sublayer_add_menu_items ( VikLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter, VikViewport *vvp )
 429 {
 430   if ( vik_layer_interfaces[l->type]->sublayer_add_menu_items )
 431     return vik_layer_interfaces[l->type]->sublayer_add_menu_items ( l, menu, vlp, subtype, sublayer, iter, vvp );
 432   return FALSE;
 433 }
 434
 435
 436 const gchar *vik_layer_sublayer_rename_request ( VikLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
 437 {
 438   if ( vik_layer_interfaces[l->type]->sublayer_rename_request )
 439     return vik_layer_interfaces[l->type]->sublayer_rename_request ( l, newname, vlp, subtype, sublayer, iter );
 440   return NULL;
 441 }
 442
 443 const gchar* vik_layer_sublayer_tooltip ( VikLayer *l, gint subtype, gpointer sublayer )
 444 {
 445   if ( vik_layer_interfaces[l->type]->sublayer_tooltip )
 446     return vik_layer_interfaces[l->type]->sublayer_tooltip ( l, subtype, sublayer );
 447   return NULL;
 448 }
 449
 450 const gchar* vik_layer_layer_tooltip ( VikLayer *l )
 451 {
 452   if ( vik_layer_interfaces[l->type]->layer_tooltip )
 453     return vik_layer_interfaces[l->type]->layer_tooltip ( l );
 454   return NULL;
 455 }
 456
 457 GdkPixbuf *vik_layer_load_icon ( gint type )
 458 {
 459   g_assert ( type < VIK_LAYER_NUM_TYPES );
 460   if ( vik_layer_interfaces[type]->icon )
 461     return gdk_pixbuf_from_pixdata ( vik_layer_interfaces[type]->icon, FALSE, NULL );
 462   return NULL;
 463 }
 464
 465 gboolean vik_layer_set_param ( VikLayer *layer, guint16 id, VikLayerParamData data, gpointer vp, gboolean is_file_operation )
 466 {
 467   if ( vik_layer_interfaces[layer->type]->set_param )
 468     return vik_layer_interfaces[layer->type]->set_param ( layer, id, data, vp, is_file_operation );
 469   return FALSE;
 470 }
 471
 472 void vik_layer_post_read ( VikLayer *layer, VikViewport *vp, gboolean from_file )
 473 {
 474   if ( vik_layer_interfaces[layer->type]->post_read )
 475     vik_layer_interfaces[layer->type]->post_read ( layer, vp, from_file );
 476 }
 477
 478 static gboolean vik_layer_properties_factory ( VikLayer *vl, VikViewport *vp )
 479 {
 480   switch ( a_uibuilder_properties_factory ( _("Layer Properties"),
 481                                             VIK_GTK_WINDOW_FROM_WIDGET(vp),
 482                                             vik_layer_interfaces[vl->type]->params,
 483                                             vik_layer_interfaces[vl->type]->params_count,
 484                                             vik_layer_interfaces[vl->type]->params_groups,
 485                                             vik_layer_interfaces[vl->type]->params_groups_count,
 486                                             (gpointer) vik_layer_interfaces[vl->type]->set_param,
 487                                             vl,
 488                                             vp,
 489                                             (gpointer) vik_layer_interfaces[vl->type]->get_param,
 490                                             vl) ) {
 491     case 0:
 492     case 3:
 493       return FALSE;
 494       /* redraw (?) */
 495     case 2:
 496       vik_layer_post_read ( vl, vp, FALSE ); /* update any gc's */
 497     default:
 498       return TRUE;
 499   }
 500 }
 501