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