src/acquire.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  * Copyright (C) 2013, Rob Norris <rw_norris@hotmail.com>
   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 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <glib/gprintf.h>
  29 #include <glib/gi18n.h>
  30
  31 #include "viking.h"
  32 #include "babel.h"
  33 #include "gpx.h"
  34 #include "acquire.h"
  35
  36 /************************ FILTER LIST *******************/
  37 // extern VikDataSourceInterface vik_datasource_gps_interface;
  38
  39 /*** Input is TRWLayer ***/
  40 extern VikDataSourceInterface vik_datasource_bfilter_simplify_interface;
  41 extern VikDataSourceInterface vik_datasource_bfilter_compress_interface;
  42 extern VikDataSourceInterface vik_datasource_bfilter_dup_interface;
  43
  44 /*** Input is a track and a TRWLayer ***/
  45 extern VikDataSourceInterface vik_datasource_bfilter_polygon_interface;
  46 extern VikDataSourceInterface vik_datasource_bfilter_exclude_polygon_interface;
  47
  48 /*** Input is a track ***/
  49
  50 const VikDataSourceInterface *filters[] = {
  51   &vik_datasource_bfilter_simplify_interface,
  52   &vik_datasource_bfilter_compress_interface,
  53   &vik_datasource_bfilter_dup_interface,
  54   &vik_datasource_bfilter_polygon_interface,
  55   &vik_datasource_bfilter_exclude_polygon_interface,
  56 };
  57
  58 const guint N_FILTERS = sizeof(filters) / sizeof(filters[0]);
  59
  60 VikTrack *filter_track = NULL;
  61
  62 /********************************************************/
  63
  64 /* passed along to worker thread */
  65 typedef struct {
  66   acq_dialog_widgets_t *w;
  67   gchar *cmd;
  68   gchar *extra;
  69   gboolean creating_new_layer;
  70   VikTrwLayer *vtl;
  71   gpointer options;
  72 } w_and_interface_t;
  73
  74
  75 /*********************************************************
  76  * Definitions and routines for acquiring data from Data Sources in general
  77  *********************************************************/
  78
  79 static void progress_func ( BabelProgressCode c, gpointer data, acq_dialog_widgets_t *w )
  80 {
  81   if ( w->source_interface->is_thread ) {
  82     gdk_threads_enter ();
  83     if ( !w->running ) {
  84       if ( w->source_interface->cleanup_func )
  85         w->source_interface->cleanup_func ( w->user_data );
  86       gdk_threads_leave ();
  87       g_thread_exit ( NULL );
  88     }
  89     gdk_threads_leave ();
  90   }
  91
  92   if ( w->source_interface->progress_func )
  93     w->source_interface->progress_func ( c, data, w );
  94 }
  95
  96 /**
  97  * Some common things to do on completion of a datasource process
  98  *  . Update layer
  99  *  . Update dialog info
 100  *  . Update main dsisplay
 101  */
 102 static void on_complete_process (w_and_interface_t *wi)
 103 {
 104   if (wi->w->running) {
 105     gtk_label_set_text ( GTK_LABEL(wi->w->status), _("Done.") );
 106     if ( wi->creating_new_layer ) {
 107       /* Only create the layer if it actually contains anything useful */
 108       // TODO: create function for this operation to hide detail:
 109       if ( ! vik_trw_layer_is_empty ( wi->vtl ) ) {
 110         vik_layer_post_read ( VIK_LAYER(wi->vtl), wi->w->vvp, TRUE );
 111         vik_aggregate_layer_add_layer ( vik_layers_panel_get_top_layer(wi->w->vlp), VIK_LAYER(wi->vtl), TRUE );
 112       }
 113       else
 114         gtk_label_set_text ( GTK_LABEL(wi->w->status), _("No data.") );
 115     }
 116     if ( wi->w->source_interface->keep_dialog_open ) {
 117       gtk_dialog_set_response_sensitive ( GTK_DIALOG(wi->w->dialog), GTK_RESPONSE_ACCEPT, TRUE );
 118       gtk_dialog_set_response_sensitive ( GTK_DIALOG(wi->w->dialog), GTK_RESPONSE_REJECT, FALSE );
 119     } else {
 120       gtk_dialog_response ( GTK_DIALOG(wi->w->dialog), GTK_RESPONSE_ACCEPT );
 121     }
 122     // Main display update
 123     if ( wi->vtl ) {
 124       vik_layer_post_read ( VIK_LAYER(wi->vtl), wi->w->vvp, TRUE );
 125       // View this data if desired - must be done after post read (so that the bounds are known)
 126       if ( wi->w->source_interface->autoview ) {
 127         vik_trw_layer_auto_set_view ( wi->vtl, vik_layers_panel_get_viewport(wi->w->vlp) );
 128       }
 129       vik_layers_panel_emit_update ( wi->w->vlp );
 130     }
 131   } else {
 132     /* cancelled */
 133     if ( wi->creating_new_layer )
 134       g_object_unref(wi->vtl);
 135   }
 136 }
 137
 138 /* this routine is the worker thread.  there is only one simultaneous download allowed */
 139 static void get_from_anything ( w_and_interface_t *wi )
 140 {
 141   gchar *cmd = wi->cmd;
 142   gchar *extra = wi->extra;
 143   gboolean result = TRUE;
 144
 145   VikDataSourceInterface *source_interface = wi->w->source_interface;
 146
 147   if ( source_interface->process_func )
 148     result = source_interface->process_func ( wi->vtl, cmd, extra, (BabelStatusFunc) progress_func, wi->w, wi->options );
 149
 150   g_free ( cmd );
 151   g_free ( extra );
 152   g_free ( wi->options );
 153
 154   if (wi->w->running && !result) {
 155     gdk_threads_enter();
 156     gtk_label_set_text ( GTK_LABEL(wi->w->status), _("Error: acquisition failed.") );
 157     if ( wi->creating_new_layer )
 158       g_object_unref ( G_OBJECT ( wi->vtl ) );
 159     gdk_threads_leave();
 160   }
 161   else {
 162     gdk_threads_enter();
 163     on_complete_process ( wi );
 164     gdk_threads_leave();
 165   }
 166
 167   if ( source_interface->cleanup_func )
 168     source_interface->cleanup_func ( wi->w->user_data );
 169
 170   if ( wi->w->running ) {
 171     wi->w->running = FALSE;
 172   }
 173   else {
 174     g_free ( wi->w );
 175     g_free ( wi );
 176     wi = NULL;
 177   }
 178
 179   g_thread_exit ( NULL );
 180 }
 181
 182 /* depending on type of filter, often only vtl or track will be given.
 183  * the other can be NULL.
 184  */
 185 static void acquire ( VikWindow *vw,
 186                       VikLayersPanel *vlp,
 187                       VikViewport *vvp,
 188                       vik_datasource_mode_t mode,
 189                       VikDataSourceInterface *source_interface,
 190                       VikTrwLayer *vtl,
 191                       VikTrack *track,
 192                       gpointer userdata,
 193                       VikDataSourceCleanupFunc cleanup_function )
 194 {
 195   /* for manual dialogs */
 196   GtkWidget *dialog = NULL;
 197   GtkWidget *status;
 198   gchar *cmd = NULL;
 199   gchar *extra = NULL;
 200   gchar *cmd_off = NULL;
 201   gchar *extra_off = NULL;
 202   acq_dialog_widgets_t *w;
 203   gpointer user_data;
 204   gpointer options = NULL;
 205
 206   acq_vik_t avt;
 207   avt.vlp = vlp;
 208   avt.vvp = vvp;
 209   avt.vw = vw;
 210   avt.userdata = userdata;
 211
 212   /* for UI builder */
 213   gpointer pass_along_data;
 214   VikLayerParamData *paramdatas = NULL;
 215
 216   w_and_interface_t *wi;
 217
 218   /*** INIT AND CHECK EXISTENCE ***/
 219   if ( source_interface->init_func )
 220     user_data = source_interface->init_func(&avt);
 221   else
 222     user_data = NULL;
 223   pass_along_data = user_data;
 224
 225   if ( source_interface->check_existence_func ) {
 226     gchar *error_str = source_interface->check_existence_func();
 227     if ( error_str ) {
 228       a_dialog_error_msg ( GTK_WINDOW(vw), error_str );
 229       g_free ( error_str );
 230       return;
 231     }
 232   }
 233
 234   /* BUILD UI & GET OPTIONS IF NECESSARY. */
 235
 236   /* POSSIBILITY 0: NO OPTIONS. DO NOTHING HERE. */
 237   /* POSSIBILITY 1: ADD_SETUP_WIDGETS_FUNC */
 238   if ( source_interface->add_setup_widgets_func ) {
 239     dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
 240
 241     gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
 242     GtkWidget *response_w = NULL;
 243 #if GTK_CHECK_VERSION (2, 20, 0)
 244     response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
 245 #endif
 246
 247     source_interface->add_setup_widgets_func(dialog, vvp, user_data);
 248     gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );
 249
 250     if ( response_w )
 251       gtk_widget_grab_focus ( response_w );
 252
 253     if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
 254       source_interface->cleanup_func(user_data);
 255       gtk_widget_destroy(dialog);
 256       return;
 257     }
 258   }
 259   /* POSSIBILITY 2: UI BUILDER */
 260   else if ( source_interface->params ) {
 261     paramdatas = a_uibuilder_run_dialog ( source_interface->window_title, GTK_WINDOW(vw),
 262                         source_interface->params, source_interface->params_count,
 263                         source_interface->params_groups, source_interface->params_groups_count,
 264                         source_interface->params_defaults );
 265     if ( paramdatas )
 266       pass_along_data = paramdatas;
 267     else
 268       return; /* TODO: do we have to free anything here? */
 269   }
 270
 271   /* CREATE INPUT DATA & GET COMMAND STRING */
 272
 273   if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER ) {
 274     gchar *name_src = a_gpx_write_tmp_file ( vtl, NULL );
 275
 276     ((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
 277         ( pass_along_data, &cmd, &extra, name_src );
 278
 279     util_add_to_deletion_list ( name_src );
 280
 281     g_free ( name_src );
 282   } else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK ) {
 283     gchar *name_src = a_gpx_write_tmp_file ( vtl, NULL );
 284     gchar *name_src_track = a_gpx_write_track_tmp_file ( track, NULL );
 285
 286     ((VikDataSourceGetCmdStringFuncWithInputInput) source_interface->get_cmd_string_func)
 287         ( pass_along_data, &cmd, &extra, name_src, name_src_track );
 288
 289     util_add_to_deletion_list ( name_src );
 290     util_add_to_deletion_list ( name_src_track );
 291
 292     g_free ( name_src );
 293     g_free ( name_src_track );
 294   } else if ( source_interface->inputtype == VIK_DATASOURCE_INPUTTYPE_TRACK ) {
 295     gchar *name_src_track = a_gpx_write_track_tmp_file ( track, NULL );
 296
 297     ((VikDataSourceGetCmdStringFuncWithInput) source_interface->get_cmd_string_func)
 298         ( pass_along_data, &cmd, &extra, name_src_track );
 299
 300     g_free ( name_src_track );
 301   } else if ( source_interface->get_cmd_string_func )
 302     source_interface->get_cmd_string_func ( pass_along_data, &cmd, &extra, &options );
 303
 304   /* Get data for Off command */
 305   if ( source_interface->off_func ) {
 306     source_interface->off_func ( pass_along_data, &cmd_off, &extra_off );
 307   }
 308
 309   /* cleanup for option dialogs */
 310   if ( source_interface->add_setup_widgets_func ) {
 311     gtk_widget_destroy(dialog);
 312     dialog = NULL;
 313   } else if ( source_interface->params ) {
 314     a_uibuilder_free_paramdatas ( paramdatas, source_interface->params, source_interface->params_count );
 315   }
 316
 317   w = g_malloc(sizeof(*w));
 318   wi = g_malloc(sizeof(*wi));
 319   wi->w = w;
 320   wi->w->source_interface = source_interface;
 321   wi->cmd = cmd;
 322   wi->extra = extra; /* usually input data type (?) */
 323   wi->options = options;
 324   wi->vtl = vtl;
 325   wi->creating_new_layer = (!vtl); // Default if Auto Layer Management is passed in
 326
 327   dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
 328   gtk_dialog_set_response_sensitive ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT, FALSE );
 329   gtk_window_set_title ( GTK_WINDOW(dialog), _(source_interface->window_title) );
 330
 331   w->dialog = dialog;
 332   w->running = TRUE;
 333   status = gtk_label_new (_("Working..."));
 334   gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), status, FALSE, FALSE, 5 );
 335   gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
 336   // May not want to see the dialog at all
 337   if ( source_interface->is_thread || source_interface->keep_dialog_open )
 338     gtk_widget_show_all(dialog);
 339   w->status = status;
 340
 341   w->vw = vw;
 342   w->vlp = vlp;
 343   w->vvp = vvp;
 344   if ( source_interface->add_progress_widgets_func ) {
 345     source_interface->add_progress_widgets_func ( dialog, user_data );
 346   }
 347   w->user_data = user_data;
 348
 349   if ( mode == VIK_DATASOURCE_ADDTOLAYER ) {
 350     VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp );
 351     if ( IS_VIK_TRW_LAYER(current_selected) ) {
 352       wi->vtl = VIK_TRW_LAYER(current_selected);
 353       wi->creating_new_layer = FALSE;
 354     }
 355   }
 356   else if ( mode == VIK_DATASOURCE_CREATENEWLAYER ) {
 357     wi->creating_new_layer = TRUE;
 358   }
 359   else if ( mode == VIK_DATASOURCE_MANUAL_LAYER_MANAGEMENT ) {
 360     // Don't create in acquire - as datasource will perform the necessary actions
 361     wi->creating_new_layer = FALSE;
 362     VikLayer *current_selected = vik_layers_panel_get_selected ( w->vlp );
 363     if ( IS_VIK_TRW_LAYER(current_selected) )
 364       wi->vtl = VIK_TRW_LAYER(current_selected);
 365   }
 366   if ( wi->creating_new_layer ) {
 367     wi->vtl = VIK_TRW_LAYER ( vik_layer_create ( VIK_LAYER_TRW, w->vvp, FALSE ) );
 368     vik_layer_rename ( VIK_LAYER ( wi->vtl ), _(source_interface->layer_title) );
 369   }
 370
 371   if ( source_interface->is_thread ) {
 372     if ( cmd ) {
 373 #if GLIB_CHECK_VERSION (2, 32, 0)
 374       g_thread_try_new ( "get_from_anything", (GThreadFunc)get_from_anything, wi, NULL );
 375 #else
 376       g_thread_create ( (GThreadFunc)get_from_anything, wi, FALSE, NULL );
 377 #endif
 378       gtk_dialog_run ( GTK_DIALOG(dialog) );
 379       if (w->running) {
 380         // Cancel and mark for thread to finish
 381         w->running = FALSE;
 382         // NB Thread will free memory
 383       } else {
 384         if ( cmd_off ) {
 385           /* Turn off */
 386           a_babel_convert_from (NULL, cmd_off, extra_off, NULL, NULL, NULL);
 387           g_free ( cmd_off );
 388         }
 389         if ( extra_off )
 390           g_free ( extra_off );
 391
 392         // Thread finished by normal completion - free memory
 393         g_free ( w );
 394         g_free ( wi );
 395       }
 396     }
 397     else {
 398       // This shouldn't happen...
 399       gtk_label_set_text ( GTK_LABEL(w->status), _("Unable to create command\nAcquire method failed.") );
 400       gtk_dialog_run (GTK_DIALOG (dialog));
 401     }
 402   }
 403   else {
 404     // bypass thread method malarkly - you'll just have to wait...
 405     if ( source_interface->process_func ) {
 406       gboolean result = source_interface->process_func ( wi->vtl, cmd, extra, (BabelStatusFunc) progress_func, w, options );
 407       if ( !result )
 408         a_dialog_msg ( GTK_WINDOW(vw), GTK_MESSAGE_ERROR, _("Error: acquisition failed."), NULL );
 409     }
 410     g_free ( cmd );
 411     g_free ( extra );
 412     g_free ( options );
 413
 414     on_complete_process ( wi );
 415     // Actually show it if necessary
 416     if ( wi->w->source_interface->keep_dialog_open )
 417       gtk_dialog_run ( GTK_DIALOG(dialog) );
 418
 419     g_free ( w );
 420     g_free ( wi );
 421   }
 422
 423   gtk_widget_destroy ( dialog );
 424
 425   if ( cleanup_function )
 426     cleanup_function ( source_interface );
 427 }
 428
 429 /**
 430  * a_acquire:
 431  * @vw: The #VikWindow to work with
 432  * @vlp: The #VikLayersPanel in which a #VikTrwLayer layer may be created/appended
 433  * @vvp: The #VikViewport defining the current view
 434  * @mode: How layers should be managed
 435  * @source_interface: The #VikDataSourceInterface determining how and what actions to take
 436  * @userdata: External data to be passed into the #VikDataSourceInterface
 437  * @cleanup_function: The function to dispose the #VikDataSourceInterface if necessary
 438  *
 439  * Process the given VikDataSourceInterface for sources with no input data.
 440  */
 441 void a_acquire ( VikWindow *vw,
 442                  VikLayersPanel *vlp,
 443                  VikViewport *vvp,
 444                  vik_datasource_mode_t mode,
 445                  VikDataSourceInterface *source_interface,
 446                  gpointer userdata,
 447                  VikDataSourceCleanupFunc cleanup_function )
 448 {
 449   acquire ( vw, vlp, vvp, mode, source_interface, NULL, NULL, userdata, cleanup_function );
 450 }
 451
 452 static void acquire_trwlayer_callback ( GObject *menuitem, gpointer *pass_along )
 453 {
 454   VikDataSourceInterface *iface = g_object_get_data ( menuitem, "vik_acq_iface" );
 455   VikWindow *vw =       pass_along[0];
 456   VikLayersPanel *vlp = pass_along[1];
 457   VikViewport *vvp =    pass_along[2];
 458   VikTrwLayer *vtl =    pass_along[3];
 459   VikTrack *tr =        pass_along[4];
 460
 461   acquire ( vw, vlp, vvp, iface->mode, iface, vtl, tr, NULL, NULL );
 462 }
 463
 464 static GtkWidget *acquire_build_menu ( VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp,
 465                                 VikTrwLayer *vtl, VikTrack *track, /* both passed to acquire, although for many filters only one ness */
 466                                 const gchar *menu_title, vik_datasource_inputtype_t inputtype )
 467 {
 468   static gpointer pass_along[5];
 469   GtkWidget *menu_item=NULL, *menu=NULL;
 470   GtkWidget *item=NULL;
 471   int i;
 472
 473   pass_along[0] = vw;
 474   pass_along[1] = vlp;
 475   pass_along[2] = vvp;
 476   pass_along[3] = vtl;
 477   pass_along[4] = track;
 478
 479   for ( i = 0; i < N_FILTERS; i++ ) {
 480     if ( filters[i]->inputtype == inputtype ) {
 481       if ( ! menu_item ) { /* do this just once, but return NULL if no filters */
 482         menu = gtk_menu_new();
 483         menu_item = gtk_menu_item_new_with_mnemonic ( menu_title );
 484         gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu );
 485       }
 486
 487       item = gtk_menu_item_new_with_label ( filters[i]->window_title );
 488       g_object_set_data ( G_OBJECT(item), "vik_acq_iface", (gpointer) filters[i] );
 489       g_signal_connect ( G_OBJECT(item), "activate", G_CALLBACK(acquire_trwlayer_callback), pass_along );
 490       gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 491       gtk_widget_show ( item );
 492     }
 493   }
 494
 495   return menu_item;
 496 }
 497
 498 /**
 499  * a_acquire_trwlayer_menu:
 500  *
 501  * Create a sub menu intended for rightclicking on a TRWLayer's menu called "Filter".
 502  *
 503  * Returns: %NULL if no filters.
 504  */
 505 GtkWidget *a_acquire_trwlayer_menu (VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikTrwLayer *vtl)
 506 {
 507   return acquire_build_menu ( vw, vlp, vvp, vtl, NULL, _("_Filter"), VIK_DATASOURCE_INPUTTYPE_TRWLAYER );
 508 }
 509
 510 /**
 511  * a_acquire_trwlayer_track_menu:
 512  *
 513  * Create a sub menu intended for rightclicking on a TRWLayer's menu called "Filter with Track "TRACKNAME"...".
 514  *
 515  * Returns: %NULL if no filters or no filter track has been set.
 516  */
 517 GtkWidget *a_acquire_trwlayer_track_menu (VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikTrwLayer *vtl)
 518 {
 519   if ( filter_track == NULL )
 520     return NULL;
 521   else {
 522     gchar *menu_title = g_strdup_printf ( _("Filter with %s"), filter_track->name );
 523     GtkWidget *rv = acquire_build_menu ( vw, vlp, vvp, vtl, filter_track,
 524                         menu_title, VIK_DATASOURCE_INPUTTYPE_TRWLAYER_TRACK );
 525     g_free ( menu_title );
 526     return rv;
 527   }
 528 }
 529
 530 /**
 531  * a_acquire_track_menu:
 532  *
 533  * Create a sub menu intended for rightclicking on a track's menu called "Filter".
 534  *
 535  * Returns: %NULL if no applicable filters
 536  */
 537 GtkWidget *a_acquire_track_menu (VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp, VikTrack *tr)
 538 {
 539   return acquire_build_menu ( vw, vlp, vvp, NULL, tr, _("Filter"), VIK_DATASOURCE_INPUTTYPE_TRACK );
 540 }
 541
 542 /**
 543  * a_acquire_set_filter_track:
 544  *
 545  * Sets application-wide track to use with filter. references the track.
 546  */
 547 void a_acquire_set_filter_track ( VikTrack *tr )
 548 {
 549   if ( filter_track )
 550     vik_track_free ( filter_track );
 551
 552   filter_track = tr;
 553   vik_track_ref ( tr );
 554 }