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       d = get_param(vl, i);
 263       switch ( params[i].type )
 264       {
 265       case VIK_LAYER_PARAM_STRING:
 266         vlm_append(d.s, strlen(d.s));
 267         break;
 268
 269       /* print out the string list in the array */
 270       case VIK_LAYER_PARAM_STRING_LIST: {
 271         GList *list = d.sl;
 272
 273         /* write length of list (# of strings) */
 274         gint listlen = g_list_length ( list );
 275         g_byte_array_append ( b, (guint8 *)&listlen, sizeof(listlen) );
 276
 277         /* write each string */
 278         while ( list ) {
 279           gchar *s = (gchar *) list->data;
 280           vlm_append(s, strlen(s));
 281           list = list->next;
 282         }
 283
 284         break;
 285       }
 286       default:
 287         vlm_append(&d, sizeof(d));
 288         break;
 289       }
 290     }
 291   }
 292
 293   *data = b->data;
 294   *datalen = b->len;
 295   g_byte_array_free ( b, FALSE );
 296
 297 #undef vlm_append
 298 }
 299
 300 void vik_layer_unmarshall_params ( VikLayer *vl, guint8 *data, gint datalen, VikViewport *vvp )
 301 {
 302   VikLayerParam *params = vik_layer_get_interface(vl->type)->params;
 303   VikLayerFuncSetParam set_param = vik_layer_get_interface(vl->type)->set_param;
 304   gchar *s;
 305   guint8 *b = (guint8 *)data;
 306
 307 #define vlm_size (*(gint *)b)
 308 #define vlm_read(obj)                           \
 309   memcpy((obj), b+sizeof(gint), vlm_size);      \
 310   b += sizeof(gint) + vlm_size;
 311
 312   s = g_malloc(vlm_size + 1);
 313   s[vlm_size]=0;
 314   vlm_read(s);
 315
 316   vik_layer_rename(vl, s);
 317
 318   g_free(s);
 319
 320   if ( params && set_param )
 321   {
 322     VikLayerParamData d;
 323     guint16 i, params_count = vik_layer_get_interface(vl->type)->params_count;
 324     for ( i = 0; i < params_count; i++ )
 325     {
 326       switch ( params[i].type )
 327       {
 328       case VIK_LAYER_PARAM_STRING:
 329         s = g_malloc(vlm_size + 1);
 330         s[vlm_size]=0;
 331         vlm_read(s);
 332         d.s = s;
 333         set_param(vl, i, d, vvp);
 334         g_free(s);
 335         break;
 336       case VIK_LAYER_PARAM_STRING_LIST:  {
 337         gint listlen = vlm_size, j;
 338         GList *list = NULL;
 339         b += sizeof(gint); /* skip listlen */;
 340
 341         for ( j = 0; j < listlen; j++ ) {
 342           /* get a string */
 343           s = g_malloc(vlm_size + 1);
 344           s[vlm_size]=0;
 345           vlm_read(s);
 346           list = g_list_append ( list, s );
 347         }
 348         d.sl = list;
 349         set_param ( vl, i, d, vvp );
 350         /* don't free -- string list is responsibility of the layer */
 351
 352         break;
 353         }
 354       default:
 355         vlm_read(&d);
 356         set_param(vl, i, d, vvp);
 357         break;
 358       }
 359     }
 360   }
 361 }
 362
 363 VikLayer *vik_layer_unmarshall ( guint8 *data, gint len, VikViewport *vvp )
 364 {
 365   header_t *header;
 366
 367   header = (header_t *)data;
 368
 369   if ( vik_layer_interfaces[header->layer_type]->unmarshall ) {
 370     return vik_layer_interfaces[header->layer_type]->unmarshall ( header->data, header->len, vvp );
 371   } else {
 372     return NULL;
 373   }
 374 }
 375
 376 static void layer_finalize ( VikLayer *vl )
 377 {
 378   g_assert ( vl != NULL );
 379   if ( vik_layer_interfaces[vl->type]->free )
 380     vik_layer_interfaces[vl->type]->free ( vl );
 381   if ( vl->name )
 382     g_free ( vl->name );
 383   G_OBJECT_CLASS(parent_class)->finalize(G_OBJECT(vl));
 384 }
 385
 386 /* sublayer switching */
 387 gboolean vik_layer_sublayer_toggle_visible ( VikLayer *l, gint subtype, gpointer sublayer )
 388 {
 389   if ( vik_layer_interfaces[l->type]->sublayer_toggle_visible )
 390     return vik_layer_interfaces[l->type]->sublayer_toggle_visible ( l, subtype, sublayer );
 391   return TRUE; /* if unknown, will always be visible */
 392 }
 393
 394 void vik_layer_realize ( VikLayer *l, VikTreeview *vt, GtkTreeIter *layer_iter )
 395 {
 396   l->vt = vt;
 397   l->iter = *layer_iter;
 398   l->realized = TRUE;
 399   if ( vik_layer_interfaces[l->type]->realize )
 400     vik_layer_interfaces[l->type]->realize ( l, vt, layer_iter );
 401 }
 402
 403 void vik_layer_set_menu_items_selection(VikLayer *l, guint16 selection)
 404 {
 405   if ( vik_layer_interfaces[l->type]->set_menu_selection )
 406     vik_layer_interfaces[l->type]->set_menu_selection ( l, selection );
 407 }
 408
 409 guint16 vik_layer_get_menu_items_selection(VikLayer *l)
 410 {
 411   if ( vik_layer_interfaces[l->type]->get_menu_selection )
 412     return(vik_layer_interfaces[l->type]->get_menu_selection (l));
 413   else
 414     return(vik_layer_interfaces[l->type]->menu_items_selection);
 415 }
 416
 417 void vik_layer_add_menu_items ( VikLayer *l, GtkMenu *menu, gpointer vlp )
 418 {
 419   if ( vik_layer_interfaces[l->type]->add_menu_items )
 420     vik_layer_interfaces[l->type]->add_menu_items ( l, menu, vlp );
 421 }
 422
 423 gboolean vik_layer_sublayer_add_menu_items ( VikLayer *l, GtkMenu *menu, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
 424 {
 425   if ( vik_layer_interfaces[l->type]->sublayer_add_menu_items )
 426     return vik_layer_interfaces[l->type]->sublayer_add_menu_items ( l, menu, vlp, subtype, sublayer, iter );
 427   return FALSE;
 428 }
 429
 430
 431 const gchar *vik_layer_sublayer_rename_request ( VikLayer *l, const gchar *newname, gpointer vlp, gint subtype, gpointer sublayer, GtkTreeIter *iter )
 432 {
 433   if ( vik_layer_interfaces[l->type]->sublayer_rename_request )
 434     return vik_layer_interfaces[l->type]->sublayer_rename_request ( l, newname, vlp, subtype, sublayer, iter );
 435   return NULL;
 436 }
 437
 438 GdkPixbuf *vik_layer_load_icon ( gint type )
 439 {
 440   g_assert ( type < VIK_LAYER_NUM_TYPES );
 441   if ( vik_layer_interfaces[type]->icon )
 442     return gdk_pixbuf_from_pixdata ( vik_layer_interfaces[type]->icon, FALSE, NULL );
 443   return NULL;
 444 }
 445
 446 gboolean vik_layer_set_param ( VikLayer *layer, guint16 id, VikLayerParamData data, gpointer vp )
 447 {
 448   if ( vik_layer_interfaces[layer->type]->set_param )
 449     return vik_layer_interfaces[layer->type]->set_param ( layer, id, data, vp );
 450   return FALSE;
 451 }
 452
 453 void vik_layer_post_read ( VikLayer *layer, VikViewport *vp, gboolean from_file )
 454 {
 455   if ( vik_layer_interfaces[layer->type]->post_read )
 456     vik_layer_interfaces[layer->type]->post_read ( layer, vp, from_file );
 457 }
 458
 459 static gboolean layer_properties_factory ( VikLayer *vl, VikViewport *vp )
 460 {
 461   switch ( a_uibuilder_properties_factory ( VIK_GTK_WINDOW_FROM_WIDGET(vp),
 462                 vik_layer_interfaces[vl->type]->params,
 463                 vik_layer_interfaces[vl->type]->params_count,
 464                 vik_layer_interfaces[vl->type]->params_groups,
 465                 vik_layer_interfaces[vl->type]->params_groups_count,
 466                 vik_layer_interfaces[vl->type]->set_param, vl, vp,
 467                 vik_layer_interfaces[vl->type]->get_param, vl) ) {
 468     case 0:
 469       return FALSE;
 470     case 3:
 471       /* redraw (?) */
 472     case 2:
 473       vik_layer_post_read ( vl, vp, FALSE ); /* update any gc's */
 474     default:
 475       return TRUE;
 476   }
 477 }
 478
 479 static GdkCursor ***layers_cursors;
 480
 481 GdkCursor *vik_layer_get_tool_cursor ( gint layer_id, gint tool_id )
 482 {
 483   if ( layer_id >= VIK_LAYER_NUM_TYPES )
 484     return NULL;
 485   if ( tool_id >= vik_layer_interfaces[layer_id]->tools_count )
 486     return NULL;
 487   return layers_cursors[layer_id][tool_id];
 488 }
 489
 490 void vik_layer_cursors_init()
 491 {
 492   gint i, j;
 493   layers_cursors = g_malloc ( sizeof(GdkCursor **) * VIK_LAYER_NUM_TYPES );
 494   for ( i = 0 ; i < VIK_LAYER_NUM_TYPES; i++ ) {
 495     if ( vik_layer_interfaces[i]->tools_count ) {
 496       layers_cursors[i] = g_malloc ( sizeof(GdkCursor *) *  vik_layer_interfaces[i]->tools_count );
 497       for ( j = 0; j < vik_layer_interfaces[i]->tools_count; j++ ) {
 498         if ( vik_layer_interfaces[i]->tools[j].cursor ) {
 499           const GdkPixdata *cursor_pixdata = vik_layer_interfaces[i]->tools[j].cursor;
 500           GError *cursor_load_err = NULL;
 501           GdkPixbuf *cursor_pixbuf = gdk_pixbuf_from_pixdata (cursor_pixdata, FALSE, &cursor_load_err);
 502           /* TODO: settable offeset */
 503           GdkCursor *cursor = gdk_cursor_new_from_pixbuf ( gdk_display_get_default(), cursor_pixbuf, 3, 3 );
 504           layers_cursors[i][j] = cursor;
 505
 506           g_object_unref ( G_OBJECT(cursor_pixbuf) );
 507         }
 508         else
 509           layers_cursors[i][j] = NULL;
 510       }
 511     } else
 512       layers_cursors[i] = NULL;
 513   }
 514 }
 515
 516 void vik_layer_cursors_uninit()
 517 {
 518   gint i, j;
 519   for ( i = 0 ; i < VIK_LAYER_NUM_TYPES; i++ ) {
 520     if ( vik_layer_interfaces[i]->tools_count ) {
 521       for ( j = 0; j < vik_layer_interfaces[i]->tools_count; j++ ) {
 522         if ( layers_cursors[i][j] )
 523           gdk_cursor_unref ( layers_cursors[i][j] );
 524       }
 525       g_free ( layers_cursors[i] );
 526     }
 527   }
 528   g_free ( layers_cursors );
 529 }