src/viktrwlayer_waypointlist.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   4  *
   5  * Copyright (C) 2013-2015, 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 #include <math.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <glib.h>
  27 #include <glib/gstdio.h>
  28 #include <glib/gi18n.h>
  29
  30 #include "viking.h"
  31 #include "viktrwlayer_waypointlist.h"
  32 #include "viktrwlayer_wpwin.h"
  33
  34 // Long formatted date+basic time - listing this way ensures the string comparison sort works - so no local type format %x or %c here!
  35 #define WAYPOINT_LIST_DATE_FORMAT "%Y-%m-%d %H:%M"
  36
  37 /**
  38  * waypoint_close_cb:
  39  *
  40  */
  41 static void waypoint_close_cb ( GtkWidget *dialog, gint resp, GList *data )
  42 {
  43         g_list_foreach ( data, (GFunc) g_free, NULL );
  44         g_list_free ( data );
  45
  46         gtk_widget_destroy (dialog);
  47 }
  48
  49 /**
  50  * format_1f_cell_data_func:
  51  *
  52  * General purpose column double formatting
  53  *
  54 static void format_1f_cell_data_func ( GtkTreeViewColumn *col,
  55                                        GtkCellRenderer   *renderer,
  56                                        GtkTreeModel      *model,
  57                                        GtkTreeIter       *iter,
  58                                        gpointer           user_data )
  59 {
  60         gdouble value;
  61         gchar buf[20];
  62         gint column = GPOINTER_TO_INT (user_data);
  63         gtk_tree_model_get ( model, iter, column, &value, -1 );
  64         g_snprintf ( buf, sizeof(buf), "%.1f", value );
  65         g_object_set ( renderer, "text", buf, NULL );
  66 }
  67  */
  68
  69 #define WPT_LIST_COLS 9
  70 #define WPT_COL_NUM WPT_LIST_COLS-1
  71 #define TRW_COL_NUM WPT_COL_NUM-1
  72
  73 /*
  74  * trw_layer_waypoint_tooltip_cb:
  75  *
  76  * Show a tooltip when the mouse is over a waypoint list entry.
  77  * The tooltip contains the description.
  78  */
  79 static gboolean trw_layer_waypoint_tooltip_cb ( GtkWidget  *widget,
  80                                                 gint        x,
  81                                                 gint        y,
  82                                                 gboolean    keyboard_tip,
  83                                                 GtkTooltip *tooltip,
  84                                                 gpointer    data )
  85 {
  86         GtkTreeIter iter;
  87         GtkTreePath *path = NULL;
  88         GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
  89         GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
  90
  91         if ( !gtk_tree_view_get_tooltip_context ( tree_view, &x, &y,
  92                                                   keyboard_tip,
  93                                                   &model, &path, &iter ) )
  94                 return FALSE;
  95
  96         VikWaypoint *wpt;
  97         gtk_tree_model_get ( model, &iter, WPT_COL_NUM, &wpt, -1 );
  98         if ( !wpt ) return FALSE;
  99
 100         gboolean tooltip_set = TRUE;
 101         if ( wpt->description )
 102                 gtk_tooltip_set_text ( tooltip, wpt->description );
 103         else
 104                 tooltip_set = FALSE;
 105
 106         if ( tooltip_set )
 107                 gtk_tree_view_set_tooltip_row ( tree_view, tooltip, path );
 108
 109         gtk_tree_path_free ( path );
 110
 111         return tooltip_set;
 112 }
 113
 114 /*
 115 static void trw_layer_waypoint_select_cb ( GtkTreeSelection *selection, gpointer data )
 116 {
 117         GtkTreeIter iter;
 118         if ( !gtk_tree_selection_get_selected (selection, NULL, &iter) )
 119                 return;
 120
 121         GtkTreeView *tree_view = GTK_TREE_VIEW ( data );
 122         GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
 123
 124         VikWaypoint *wpt;
 125         gtk_tree_model_get ( model, &iter, WPT_COL_NUM, &wpt, -1 );
 126         if ( !wpt ) return;
 127
 128         VikTrwLayer *vtl;
 129         gtk_tree_model_get ( model, &iter, TRW_COL_NUM, &vtl, -1 );
 130         if ( !IS_VIK_TRW_LAYER(vtl) ) return;
 131
 132         //vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, g_hash_table_lookup ( vtl->waypoint_iters, uuid ), TRUE );
 133 }
 134 */
 135
 136 // A slightly better way of defining the menu callback information
 137 // This should be much easier to extend/rework compared to the current trw_layer menus
 138 typedef enum {
 139   MA_VTL = 0,
 140   MA_WPT,
 141   MA_WPT_UUID,
 142   MA_VVP,
 143   MA_TREEVIEW,
 144   MA_WPTS_LIST,
 145   MA_LAST
 146 } menu_array_index;
 147
 148 typedef gpointer menu_array_values[MA_LAST];
 149
 150 // Instead of hooking automatically on treeview item selection
 151 // This is performed on demand via the specific menu request
 152 static void trw_layer_waypoint_select ( menu_array_values values )
 153 {
 154         VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]);
 155
 156         if ( values[MA_WPT_UUID] ) {
 157                 GtkTreeIter *iter = NULL;
 158                 iter = g_hash_table_lookup ( vik_trw_layer_get_waypoints_iters(vtl), values[MA_WPT_UUID] );
 159
 160                 if ( iter )
 161                         vik_treeview_select_iter ( VIK_LAYER(vtl)->vt, iter, TRUE );
 162         }
 163 }
 164
 165 static void trw_layer_waypoint_properties ( menu_array_values values )
 166 {
 167         VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]);
 168         VikWaypoint *wpt = VIK_WAYPOINT(values[MA_WPT]);
 169
 170         if ( wpt && wpt->name ) {
 171                 // Kill off this dialog to allow interaction with properties window
 172                 //  since the properties also allows waypoint manipulations it won't cause conflicts here.
 173                 GtkWidget *gw = gtk_widget_get_toplevel ( values[MA_TREEVIEW] );
 174                 waypoint_close_cb ( gw, 0, values[MA_WPTS_LIST] );
 175
 176                 gboolean updated = FALSE;
 177                 gchar *new_name = a_dialog_waypoint ( VIK_GTK_WINDOW_FROM_LAYER(vtl), wpt->name, vtl, wpt, vik_trw_layer_get_coord_mode(vtl), FALSE, &updated );
 178                 if ( new_name )
 179                         trw_layer_waypoint_rename ( vtl, wpt, new_name );
 180
 181                 if ( updated )
 182                         trw_layer_waypoint_reset_icon ( vtl, wpt );
 183
 184                 if ( updated && VIK_LAYER(vtl)->visible )
 185                         vik_layer_emit_update ( VIK_LAYER(vtl) );
 186         }
 187 }
 188
 189 static void trw_layer_waypoint_view ( menu_array_values values )
 190 {
 191         VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]);
 192         VikWaypoint *wpt = VIK_WAYPOINT(values[MA_WPT]);
 193         VikViewport *vvp = VIK_VIEWPORT(values[MA_VVP]);
 194
 195         vik_viewport_set_center_coord ( vvp, &(wpt->coord), TRUE );
 196
 197         trw_layer_waypoint_select (values);
 198
 199         vik_layer_emit_update ( VIK_LAYER(vtl) );
 200 }
 201
 202 static void trw_layer_show_picture ( menu_array_values values )
 203 {
 204         VikWaypoint *wpt = VIK_WAYPOINT(values[MA_WPT]);
 205 #ifdef WINDOWS
 206         ShellExecute(NULL, "open", wpt->image, NULL, NULL, SW_SHOWNORMAL);
 207 #else
 208         VikTrwLayer *vtl = VIK_TRW_LAYER(values[MA_VTL]);
 209         GError *err = NULL;
 210         gchar *quoted_file = g_shell_quote ( wpt->image );
 211         gchar *cmd = g_strdup_printf ( "%s %s", a_vik_get_image_viewer(), quoted_file );
 212         g_free ( quoted_file );
 213         if ( ! g_spawn_command_line_async ( cmd, &err ) ) {
 214                 a_dialog_error_msg_extra ( VIK_GTK_WINDOW_FROM_LAYER(vtl), _("Could not launch %s to open file."), a_vik_get_image_viewer() );
 215                 g_error_free ( err );
 216         }
 217         g_free ( cmd );
 218 #endif
 219 }
 220
 221
 222 typedef struct {
 223   gboolean has_layer_names;
 224   gboolean include_positions;
 225   GString *str;
 226 } copy_data_t;
 227
 228 /**
 229  * At the moment allow copying the data displayed** with or without the positions
 230  *  (since the position data is not shown in the list but is useful in copying to external apps)
 231  *
 232  * ** ATM The visibility flag is not copied and neither is a text representation of the waypoint symbol
 233  */
 234 static void copy_selection (GtkTreeModel *model,
 235                             GtkTreePath *path,
 236                             GtkTreeIter *iter,
 237                             gpointer data)
 238 {
 239         copy_data_t *cd = (copy_data_t*) data;
 240
 241         gchar* layername; gtk_tree_model_get ( model, iter, 0, &layername, -1 );
 242         gchar* name; gtk_tree_model_get ( model, iter, 1, &name, -1 );
 243         gchar* date; gtk_tree_model_get ( model, iter, 2, &date, -1 );
 244         gchar* comment; gtk_tree_model_get ( model, iter, 4, &comment, -1 );
 245         if ( comment == NULL )
 246                 comment = g_strdup ( "" );
 247         gint hh; gtk_tree_model_get ( model, iter, 5, &hh, -1 );
 248
 249         VikWaypoint *wpt; gtk_tree_model_get ( model, iter, WPT_COL_NUM, &wpt, -1 );
 250         struct LatLon ll;
 251         if ( wpt ) {
 252                 vik_coord_to_latlon ( &wpt->coord, &ll );
 253         }
 254         gchar sep = '\t'; // Could make this configurable - but simply always make it a tab character for now
 255         // NB Even if the columns have been reordered - this copies it out only in the original default order
 256         // if col 0 is displayed then also copy the layername
 257         // Note that the lat/lon data copy is using the users locale
 258         if ( cd->has_layer_names ) {
 259                 if ( cd->include_positions )
 260                         g_string_append_printf ( cd->str, "%s%c%s%c%s%c%s%c%d%c%.6f%c%.6f\n", layername, sep, name, sep, date, sep, comment, sep, hh, sep, ll.lat, sep, ll.lon );
 261                 else
 262                         g_string_append_printf ( cd->str, "%s%c%s%c%s%c%s%c%d\n", layername, sep, name, sep, date, sep, comment, sep, hh );
 263         }
 264         else {
 265                 if ( cd->include_positions )
 266                         g_string_append_printf ( cd->str, "%s%c%s%c%s%c%d%c%.6f%c%.6f\n", name, sep, date, sep, comment, sep, hh, sep, ll.lat, sep, ll.lon );
 267                 else
 268                         g_string_append_printf ( cd->str, "%s%c%s%c%s%c%d\n", name, sep, date, sep, comment, sep, hh );
 269         }
 270         g_free ( layername );
 271         g_free ( name );
 272         g_free ( date );
 273         g_free ( comment );
 274 }
 275
 276 static void trw_layer_copy_selected ( GtkWidget *tree_view, gboolean include_positions )
 277 {
 278         GtkTreeSelection *selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
 279         // NB GTK3 has gtk_tree_view_get_n_columns() but we're GTK2 ATM
 280         GList *gl = gtk_tree_view_get_columns ( GTK_TREE_VIEW(tree_view) );
 281         guint count = g_list_length ( gl );
 282         g_list_free ( gl );
 283         copy_data_t cd;
 284         cd.has_layer_names = (count > WPT_LIST_COLS-3);
 285         cd.str = g_string_new ( NULL );
 286         cd.include_positions = include_positions;
 287         gtk_tree_selection_selected_foreach ( selection, copy_selection, &cd );
 288
 289         a_clipboard_copy ( VIK_CLIPBOARD_DATA_TEXT, 0, 0, 0, cd.str->str, NULL );
 290
 291         g_string_free ( cd.str, TRUE );
 292 }
 293
 294 static void trw_layer_copy_selected_only_visible_columns ( GtkWidget *tree_view )
 295 {
 296         trw_layer_copy_selected ( tree_view, FALSE );
 297 }
 298
 299 static void trw_layer_copy_selected_with_position ( GtkWidget *tree_view )
 300 {
 301         trw_layer_copy_selected ( tree_view, TRUE );
 302 }
 303
 304 static void add_copy_menu_items ( GtkMenu *menu, GtkWidget *tree_view )
 305 {
 306         GtkWidget *item = gtk_image_menu_item_new_with_mnemonic ( _("_Copy Data") );
 307         gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU) );
 308         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_copy_selected_only_visible_columns), tree_view );
 309         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 310         gtk_widget_show ( item );
 311
 312         item = gtk_image_menu_item_new_with_mnemonic ( _("Copy Data (with _positions)") );
 313         gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU) );
 314         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_copy_selected_with_position), tree_view );
 315         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 316         gtk_widget_show ( item );
 317 }
 318
 319 static gboolean add_menu_items ( GtkMenu *menu, VikTrwLayer *vtl, VikWaypoint *wpt, gpointer wpt_uuid, VikViewport *vvp, GtkWidget *tree_view, gpointer data )
 320 {
 321         static menu_array_values values;
 322         GtkWidget *item;
 323
 324         values[MA_VTL]       = vtl;
 325         values[MA_WPT]       = wpt;
 326         values[MA_WPT_UUID]  = wpt_uuid;
 327         values[MA_VVP]       = vvp;
 328         values[MA_TREEVIEW]  = tree_view;
 329         values[MA_WPTS_LIST] = data;
 330
 331         /*
 332         item = gtk_image_menu_item_new_with_mnemonic ( _("_Select") );
 333         gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_MENU) );
 334         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_select), values );
 335         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 336         gtk_widget_show ( item );
 337         */
 338
 339         // AUTO SELECT NOT TRUE YET...
 340         // ATM view auto selects, so don't bother with separate select menu entry
 341         item = gtk_image_menu_item_new_with_mnemonic ( _("_View") );
 342         gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_ZOOM_FIT, GTK_ICON_SIZE_MENU) );
 343         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_view), values );
 344         gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 345         gtk_widget_show ( item );
 346
 347         item = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL );
 348         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_waypoint_properties), values );
 349         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
 350         gtk_widget_show ( item );
 351
 352         item = gtk_image_menu_item_new_with_mnemonic ( _("_Show Picture...") );
 353         gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock ("vik-icon-Show Picture", GTK_ICON_SIZE_MENU) ); // Own icon - see stock_icons in vikwindow.c
 354         g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(trw_layer_show_picture), values );
 355         gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
 356         gtk_widget_show ( item );
 357         gtk_widget_set_sensitive ( item, GPOINTER_TO_INT(wpt->image) );
 358
 359         add_copy_menu_items ( menu, tree_view );
 360
 361         return TRUE;
 362 }
 363
 364 static gboolean trw_layer_waypoint_menu_popup_multi  ( GtkWidget *tree_view,
 365                                                        GdkEventButton *event,
 366                                                        gpointer data )
 367 {
 368         GtkWidget *menu = gtk_menu_new();
 369
 370         add_copy_menu_items ( GTK_MENU(menu), tree_view );
 371
 372         gtk_menu_popup ( GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
 373
 374         return TRUE;
 375 }
 376
 377 static gboolean trw_layer_waypoint_menu_popup ( GtkWidget *tree_view,
 378                                                 GdkEventButton *event,
 379                                                 gpointer data )
 380 {
 381         static GtkTreeIter iter;
 382
 383         // Use selected item to get a single iterator ref
 384         // This relies on an row being selected as part of the right click
 385         GtkTreeSelection *selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
 386         if ( gtk_tree_selection_count_selected_rows (selection) != 1 )
 387                 return trw_layer_waypoint_menu_popup_multi ( tree_view, event, data );
 388
 389         GtkTreePath *path;
 390         GtkTreeModel *model = gtk_tree_view_get_model ( GTK_TREE_VIEW(tree_view) );
 391
 392         // All this just to get the iter
 393         if ( gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(tree_view),
 394                                              (gint) event->x,
 395                                              (gint) event->y,
 396                                              &path, NULL, NULL, NULL)) {
 397                 gtk_tree_model_get_iter_from_string ( model, &iter, gtk_tree_path_to_string (path) );
 398                 gtk_tree_path_free ( path );
 399         }
 400         else
 401                 return FALSE;
 402
 403         VikWaypoint *wpt;
 404         gtk_tree_model_get ( model, &iter, WPT_COL_NUM, &wpt, -1 );
 405         if ( !wpt ) return FALSE;
 406
 407         VikTrwLayer *vtl;
 408         gtk_tree_model_get ( model, &iter, TRW_COL_NUM, &vtl, -1 );
 409         if ( !IS_VIK_TRW_LAYER(vtl) ) return FALSE;
 410
 411         wpu_udata udataU;
 412         udataU.wp   = wpt;
 413         udataU.uuid = NULL;
 414
 415         gpointer wptf;
 416         wptf = g_hash_table_find ( vik_trw_layer_get_waypoints(vtl), (GHRFunc) trw_layer_waypoint_find_uuid, &udataU );
 417
 418         if ( wptf && udataU.uuid ) {
 419                 VikViewport *vvp = vik_window_viewport((VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(vtl)));
 420
 421                 GtkWidget *menu = gtk_menu_new();
 422
 423                 // Originally started to reuse the trw_layer menu items
 424                 //  however these offer too many ways to edit the waypoint data
 425                 //  so without an easy way to distinguish read only operations,
 426                 //  create a very minimal new set of operations
 427                 add_menu_items ( GTK_MENU(menu),
 428                                  vtl,
 429                                  wpt,
 430                                  udataU.uuid,
 431                                  vvp,
 432                                  tree_view,
 433                                  data );
 434
 435                 gtk_menu_popup ( GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, gtk_get_current_event_time() );
 436                 return TRUE;
 437         }
 438         return FALSE;
 439 }
 440
 441 static gboolean trw_layer_waypoint_button_pressed ( GtkWidget *tree_view,
 442                                                     GdkEventButton *event,
 443                                                     gpointer data )
 444 {
 445         // Only on right clicks...
 446         if ( ! (event->type == GDK_BUTTON_PRESS && event->button == 3) )
 447                 return FALSE;
 448
 449         // ATM Force a selection...
 450         GtkTreeSelection *selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
 451         if ( gtk_tree_selection_count_selected_rows (selection) <= 1 ) {
 452                 GtkTreePath *path;
 453                 /* Get tree path for row that was clicked */
 454                 if ( gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(tree_view),
 455                                                      (gint) event->x,
 456                                                     (gint) event->y,
 457                                                      &path, NULL, NULL, NULL)) {
 458                         gtk_tree_selection_unselect_all ( selection );
 459                         gtk_tree_selection_select_path ( selection, path );
 460                         gtk_tree_path_free ( path );
 461                 }
 462         }
 463         return trw_layer_waypoint_menu_popup ( tree_view, event, data );
 464 }
 465
 466 /*
 467  * Foreach entry we copy the various individual waypoint properties into the tree store
 468  *  formatting & converting the internal values into something for display
 469  */
 470 static void trw_layer_waypoint_list_add ( vik_trw_waypoint_list_t *vtdl,
 471                                           GtkTreeStore *store,
 472                                           vik_units_height_t height_units,
 473                                           const gchar* date_format )
 474 {
 475         GtkTreeIter t_iter;
 476         VikWaypoint *wpt = vtdl->wpt;
 477         VikTrwLayer *vtl = vtdl->vtl;
 478
 479         // Get start date
 480         gchar time_buf[32];
 481         time_buf[0] = '\0';
 482         if ( wpt->has_timestamp ) {
 483
 484 #if GLIB_CHECK_VERSION(2,26,0)
 485                 GDateTime* gdt = g_date_time_new_from_unix_utc ( wpt->timestamp );
 486                 gchar *time = g_date_time_format ( gdt, date_format );
 487                 g_strlcpy ( time_buf, time, sizeof(time_buf) );
 488                 g_free ( time );
 489                 g_date_time_unref ( gdt);
 490 #else
 491                 GDate* gdate_start = g_date_new ();
 492                 g_date_set_time_t ( gdate_start, wpt->timestamp );
 493                 g_date_strftime ( time_buf, sizeof(time_buf), date_format, gdate_start );
 494                 g_date_free ( gdate_start );
 495 #endif
 496         }
 497
 498         // NB: doesn't include aggegrate visibility
 499         gboolean visible = VIK_LAYER(vtl)->visible && wpt->visible;
 500         visible = visible && vik_trw_layer_get_waypoints_visibility(vtl);
 501
 502         gdouble alt = wpt->altitude;
 503         switch (height_units) {
 504         case VIK_UNITS_HEIGHT_FEET: alt = VIK_METERS_TO_FEET(alt); break;
 505         default:
 506                 // VIK_UNITS_HEIGHT_METRES: no need to convert
 507                 break;
 508         }
 509
 510         gtk_tree_store_append ( store, &t_iter, NULL );
 511         gtk_tree_store_set ( store, &t_iter,
 512                              0, VIK_LAYER(vtl)->name,
 513                              1, wpt->name,
 514                              2, time_buf,
 515                              3, visible,
 516                              4, wpt->comment,
 517                              5, (gint)round(alt),
 518                              6, get_wp_sym_small (wpt->symbol),
 519                              TRW_COL_NUM, vtl,
 520                              WPT_COL_NUM, wpt,
 521                              -1 );
 522 }
 523
 524 /*
 525  * Instead of comparing the pixbufs,
 526  *  look at the waypoint data and compare the symbol (as text).
 527  */
 528 gint sort_pixbuf_compare_func ( GtkTreeModel *model,
 529                                 GtkTreeIter  *a,
 530                                 GtkTreeIter  *b,
 531                                 gpointer      userdata )
 532 {
 533         VikWaypoint *wpt1, *wpt2;
 534         gtk_tree_model_get ( model, a, WPT_COL_NUM, &wpt1, -1 );
 535         if ( !wpt1 ) return 0;
 536         gtk_tree_model_get ( model, b, WPT_COL_NUM, &wpt2, -1 );
 537         if ( !wpt2 ) return 0;
 538
 539         return g_strcmp0 ( wpt1->symbol, wpt2->symbol );
 540 }
 541
 542 static GtkTreeViewColumn *my_new_column_text ( const gchar *title, GtkCellRenderer *renderer, GtkWidget *view, gint column_runner )
 543 {
 544         GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes ( title, renderer, "text", column_runner, NULL );
 545         gtk_tree_view_column_set_sort_column_id ( column, column_runner );
 546         gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
 547         gtk_tree_view_column_set_reorderable ( column, TRUE );
 548         gtk_tree_view_column_set_resizable ( column, TRUE );
 549         return column;
 550 }
 551
 552 /**
 553  * vik_trw_layer_waypoint_list_internal:
 554  * @dialog:            The dialog to create the widgets in
 555  * @waypoints_and_layers: The list of waypoints (and it's layer) to be shown
 556  * @show_layer_names:  Show the layer names that each waypoint belongs to
 557  *
 558  * Create a table of waypoints with corresponding waypoint information
 559  * This table does not support being actively updated
 560  */
 561 static void vik_trw_layer_waypoint_list_internal ( GtkWidget *dialog,
 562                                                    GList *waypoints_and_layers,
 563                                                    gboolean show_layer_names )
 564 {
 565         if ( !waypoints_and_layers )
 566                 return;
 567
 568         // It's simple storing the gdouble values in the tree store as the sort works automatically
 569         // Then apply specific cell data formatting (rather default double is to 6 decimal places!)
 570         // However not storing any doubles for waypoints ATM
 571         // TODO: Consider adding the waypoint icon into this store for display in the list
 572         GtkTreeStore *store = gtk_tree_store_new ( WPT_LIST_COLS,
 573                                                    G_TYPE_STRING,    // 0: Layer Name
 574                                                    G_TYPE_STRING,    // 1: Waypoint Name
 575                                                    G_TYPE_STRING,    // 2: Date
 576                                                    G_TYPE_BOOLEAN,   // 3: Visible
 577                                                    G_TYPE_STRING,    // 4: Comment
 578                                                    G_TYPE_INT,       // 5: Height
 579                                                    GDK_TYPE_PIXBUF,  // 6: Symbol Icon
 580                                                    G_TYPE_POINTER,   // 7: TrackWaypoint Layer pointer
 581                                                    G_TYPE_POINTER ); // 8: Waypoint pointer
 582
 583         //gtk_tree_selection_set_select_function ( gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL );
 584
 585         vik_units_height_t height_units = a_vik_get_units_height ();
 586
 587         //GList *gl = get_waypoints_and_layers_cb ( vl, user_data );
 588         //g_list_foreach ( waypoints_and_layers, (GFunc) trw_layer_waypoint_list_add, store );
 589         gchar *date_format = NULL;
 590         if ( !a_settings_get_string ( VIK_SETTINGS_LIST_DATE_FORMAT, &date_format ) )
 591                 date_format = g_strdup ( WAYPOINT_LIST_DATE_FORMAT );
 592
 593         GList *gl = waypoints_and_layers;
 594         while ( gl ) {
 595                 trw_layer_waypoint_list_add ( (vik_trw_waypoint_list_t*)gl->data, store, height_units, date_format );
 596                 gl = g_list_next ( gl );
 597         }
 598         g_free ( date_format );
 599
 600         GtkWidget *view = gtk_tree_view_new();
 601         GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
 602         g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 603         GtkTreeViewColumn *column;
 604         GtkTreeViewColumn *sort_by_column;
 605
 606         gint column_runner = 0;
 607         if ( show_layer_names ) {
 608                 // Insert column for the layer name when viewing multi layers
 609                 column = my_new_column_text ( _("Layer"), renderer, view, column_runner++ );
 610                 g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 611                 gtk_tree_view_column_set_expand ( column, TRUE );
 612                 // remember the layer column so we can sort by it later
 613                 sort_by_column = column;
 614         }
 615         else
 616                 column_runner++;
 617
 618         column = my_new_column_text ( _("Name"), renderer, view, column_runner++ );
 619         gtk_tree_view_column_set_expand ( column, TRUE );
 620         if ( !show_layer_names )
 621                 // remember the name column so we can sort by it later
 622                 sort_by_column = column;
 623
 624         column = my_new_column_text ( _("Date"), renderer, view, column_runner++ );
 625         gtk_tree_view_column_set_resizable ( column, TRUE );
 626
 627         GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new ();
 628         column = gtk_tree_view_column_new_with_attributes ( _("Visible"), renderer_toggle, "active", column_runner, NULL );
 629         gtk_tree_view_column_set_sort_column_id ( column, column_runner );
 630         gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
 631         column_runner++;
 632
 633         column = my_new_column_text ( _("Comment"), renderer, view, column_runner++ );
 634         gtk_tree_view_column_set_expand ( column, TRUE );
 635
 636         if ( height_units == VIK_UNITS_HEIGHT_FEET )
 637                 (void)my_new_column_text ( _("Max Height\n(Feet)"), renderer, view, column_runner++ );
 638         else
 639                 (void)my_new_column_text ( _("Max Height\n(Metres)"), renderer, view, column_runner++ );
 640
 641         GtkCellRenderer *renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
 642         g_object_set (G_OBJECT (renderer_pixbuf), "xalign", 0.5, NULL);
 643         column = gtk_tree_view_column_new_with_attributes ( _("Symbol"), renderer_pixbuf, "pixbuf", column_runner++, NULL );
 644         // Special sort required for pixbufs
 645         gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE(store), column_runner, sort_pixbuf_compare_func, NULL, NULL );
 646         gtk_tree_view_column_set_sort_column_id ( column, column_runner );
 647         gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
 648
 649         gtk_tree_view_set_model ( GTK_TREE_VIEW(view), GTK_TREE_MODEL(store) );
 650         gtk_tree_selection_set_mode ( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE );
 651         gtk_tree_view_set_rules_hint ( GTK_TREE_VIEW(view), TRUE );
 652
 653         g_object_unref(store);
 654
 655         GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
 656         gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
 657         gtk_container_add ( GTK_CONTAINER(scrolledwindow), view );
 658
 659         g_object_set ( view, "has-tooltip", TRUE, NULL);
 660
 661         g_signal_connect ( view, "query-tooltip", G_CALLBACK (trw_layer_waypoint_tooltip_cb), NULL );
 662         //g_signal_connect ( gtk_tree_view_get_selection (GTK_TREE_VIEW(view)), "changed", G_CALLBACK(trw_layer_waypoint_select_cb), view );
 663
 664         g_signal_connect ( view, "popup-menu", G_CALLBACK(trw_layer_waypoint_menu_popup), waypoints_and_layers );
 665         g_signal_connect ( view, "button-press-event", G_CALLBACK(trw_layer_waypoint_button_pressed), waypoints_and_layers );
 666
 667         gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0);
 668
 669         // Set ordering of the initial view by one of the name columns
 670         gtk_tree_view_column_clicked ( sort_by_column );
 671
 672         // Ensure a reasonable number of items are shown
 673         //  TODO: may be save window size, column order, sorted by between invocations.
 674         gtk_window_set_default_size ( GTK_WINDOW(dialog), show_layer_names ? 700 : 500, 400 );
 675 }
 676
 677
 678 /**
 679  * vik_trw_layer_waypoint_list_show_dialog:
 680  * @title:                    The title for the dialog
 681  * @vl:                       The #VikLayer passed on into get_waypoints_and_layers_cb()
 682  * @user_data:                Data passed on into get_waypoints_and_layers_cb()
 683  * @get_waypoints_and_layers_cb: The function to call to construct items to be analysed
 684  * @show_layer_names:         Normally only set when called from an aggregate level
 685  *
 686  * Common method for showing a list of waypoints with extended information
 687  *
 688  */
 689 void vik_trw_layer_waypoint_list_show_dialog ( gchar *title,
 690                                                VikLayer *vl,
 691                                                gpointer user_data,
 692                                                VikTrwlayerGetWaypointsAndLayersFunc get_waypoints_and_layers_cb,
 693                                                gboolean show_layer_names )
 694 {
 695         GtkWidget *dialog = gtk_dialog_new_with_buttons ( title,
 696                                                           VIK_GTK_WINDOW_FROM_LAYER(vl),
 697                                                           GTK_DIALOG_DESTROY_WITH_PARENT,
 698                                                           GTK_STOCK_CLOSE,
 699                                                           GTK_RESPONSE_CLOSE,
 700                                                           NULL );
 701
 702         GList *gl = get_waypoints_and_layers_cb ( vl, user_data );
 703
 704         vik_trw_layer_waypoint_list_internal ( dialog, gl, show_layer_names );
 705
 706         // Use response to close the dialog with tidy up
 707         g_signal_connect ( G_OBJECT(dialog), "response", G_CALLBACK(waypoint_close_cb), gl );
 708
 709         gtk_widget_show_all ( dialog );
 710         // Yes - set the size *AGAIN* - this time widgets are expanded nicely
 711         gtk_window_resize ( GTK_WINDOW(dialog), show_layer_names ? 800 : 600, 400 );
 712
 713         // ATM lock out on dialog run - to prevent list contents being manipulated in other parts of the GUI whilst shown here.
 714         gtk_dialog_run (GTK_DIALOG (dialog));
 715         // Unfortunately seems subsequently opening the Waypoint Properties we can't interact with it until this dialog is closed
 716         // Thus this dialog is then forcibly closed when opening the properties.
 717
 718         // Occassionally the 'View' doesn't update the viewport properly
 719         //  viewport center + zoom is changed but the viewport isn't updated
 720         // not sure why yet..
 721 }