*
* Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
* Copyright (C) 2005-2006, Alex Foobarian <foobarian@gmail.com>
- * Copyright (C) 2012, Rob Norris <rw_norris@hotmail.com>
+ * Copyright (C) 2012-2013, Rob Norris <rw_norris@hotmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include "viklayer_defaults.h"
#include "icons/icons.h"
#include "vikexttools.h"
+#include "vikexttool_datasources.h"
#include "garminsymbols.h"
#include "vikmapslayer.h"
#include "geonamessearch.h"
// Signals
static void open_window ( VikWindow *vw, GSList *files );
-static void statusbar_update ( VikWindow *vw, vik_statusbar_type_t vs_type, const gchar *message );
static void destroy_window ( GtkWidget *widget,
gpointer data );
static gboolean key_press_event( VikWindow *vw, GdkEventKey *event, gpointer data );
+static void center_changed_cb ( VikWindow *vw );
static void window_configure_event ( VikWindow *vw );
static void draw_sync ( VikWindow *vw );
static void draw_redraw ( VikWindow *vw );
gboolean pan_move;
gint pan_x, pan_y;
+ gint delayed_pan_x, delayed_pan_y; // Temporary storage
+ gboolean single_click_pending;
guint draw_image_width, draw_image_height;
gboolean draw_image_save_as_png;
gchar *filename;
gboolean modified;
+ VikLoadType_t loaded_type;
GtkWidget *open_dia, *save_dia;
GtkWidget *save_img_dia, *save_img_dir_dia;
enum {
VW_NEWWINDOW_SIGNAL,
VW_OPENWINDOW_SIGNAL,
- VW_STATUSBAR_UPDATE_SIGNAL,
VW_LAST_SIGNAL
};
}
/**
- * For signalling the update from a background thread
+ * Returns the 'project' filename
*/
-void vik_window_signal_statusbar_update (VikWindow *vw, const gchar* message, vik_statusbar_type_t vs_type)
+const gchar *vik_window_get_filename (VikWindow *vw)
{
- g_signal_emit ( G_OBJECT(vw), window_signals[VW_STATUSBAR_UPDATE_SIGNAL], 0, vs_type, message );
+ return vw->filename;
}
+typedef struct {
+ VikStatusbar *vs;
+ vik_statusbar_type_t vs_type;
+ gchar* message; // Always make a copy of this data
+} statusbar_idle_data;
+
/**
* For the actual statusbar update!
*/
-static gboolean statusbar_idle_update ( gpointer indata )
+static gboolean statusbar_idle_update ( statusbar_idle_data *sid )
{
- gpointer *data = indata;
- vik_statusbar_set_message ( data[0], GPOINTER_TO_INT(data[2]), data[1] );
+ vik_statusbar_set_message ( sid->vs, sid->vs_type, sid->message );
+ g_free ( sid->message );
+ g_free ( sid );
return FALSE;
}
/**
- * Update statusbar in the main thread
+ * vik_window_statusbar_update:
+ * @vw: The main window in which the statusbar will be updated.
+ * @message: The string to be displayed. This is copied.
+ * @vs_type: The part of the statusbar to be updated.
+ *
+ * This updates any part of the statusbar with the new string.
+ * It handles calling from the main thread or any background thread
+ * ATM this mostly used from background threads - as from the main thread
+ * one may use the vik_statusbar_set_message() directly.
*/
-static void window_statusbar_update ( VikWindow *vw, const gchar* message, vik_statusbar_type_t vs_type )
+void vik_window_statusbar_update ( VikWindow *vw, const gchar* message, vik_statusbar_type_t vs_type )
{
- // ATM we know the message has been statically allocated so this is OK (no need to handle any freeing)
- static gpointer data[3];
- data[0] = vw->viking_vs;
- data[1] = (gchar*) message;
- data[2] = GINT_TO_POINTER(vs_type);
- g_idle_add ( (GSourceFunc) statusbar_idle_update, data );
+ statusbar_idle_data *sid = g_malloc ( sizeof (statusbar_idle_data) );
+ sid->vs = vw->viking_vs;
+ sid->vs_type = vs_type;
+ sid->message = g_strdup ( message );
+
+ if ( g_thread_self() == vik_window_get_thread ( vw ) ) {
+ g_idle_add ( (GSourceFunc) statusbar_idle_update, sid );
+ }
+ else {
+ // From a background thread
+ gdk_threads_add_idle ( (GSourceFunc) statusbar_idle_update, sid );
+ }
}
// Actual signal handlers
gtk_main_quit ();
}
-static void statusbar_update ( VikWindow *vw, vik_statusbar_type_t vs_type, const gchar *message )
-{
- window_statusbar_update ( vw, message, vs_type );
-}
+#define VIK_SETTINGS_WIN_SIDEPANEL "window_sidepanel"
+#define VIK_SETTINGS_WIN_STATUSBAR "window_statusbar"
+#define VIK_SETTINGS_WIN_TOOLBAR "window_toolbar"
+// Menubar setting to off is never auto saved in case it's accidentally turned off
+// It's not so obvious so to recover the menu visibility.
+// Thus this value is for setting manually via editting the settings file directly
+#define VIK_SETTINGS_WIN_MENUBAR "window_menubar"
VikWindow *vik_window_new_window ()
{
G_CALLBACK (vik_window_new_window), NULL);
g_signal_connect (G_OBJECT (vw), "openwindow",
G_CALLBACK (open_window), NULL);
- g_signal_connect (G_OBJECT (vw), "statusbarupdate",
- G_CALLBACK (statusbar_update), vw);
gtk_widget_show_all ( GTK_WIDGET(vw) );
+ if ( a_vik_get_restore_window_state() ) {
+ // These settings are applied after the show all as these options hide widgets
+ gboolean sidepanel;
+ if ( a_settings_get_boolean ( VIK_SETTINGS_WIN_SIDEPANEL, &sidepanel ) )
+ if ( ! sidepanel ) {
+ gtk_widget_hide ( GTK_WIDGET(vw->viking_vlp) );
+ GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewSidePanel" );
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), FALSE );
+ }
+
+ gboolean statusbar;
+ if ( a_settings_get_boolean ( VIK_SETTINGS_WIN_STATUSBAR, &statusbar ) )
+ if ( ! statusbar ) {
+ gtk_widget_hide ( GTK_WIDGET(vw->viking_vs) );
+ GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewStatusBar" );
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), FALSE );
+ }
+
+ gboolean toolbar;
+ if ( a_settings_get_boolean ( VIK_SETTINGS_WIN_TOOLBAR, &toolbar ) )
+ if ( ! toolbar ) {
+ gtk_widget_hide ( GTK_WIDGET(vw->toolbar) );
+ GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewToolBar" );
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), FALSE );
+ }
+
+ gboolean menubar;
+ if ( a_settings_get_boolean ( VIK_SETTINGS_WIN_MENUBAR, &menubar ) )
+ if ( ! menubar ) {
+ gtk_widget_hide ( gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu" ) );
+ GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewMainMenu" );
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), FALSE );
+ }
+ }
window_count++;
return vw;
return NULL;
}
+/**
+ * determine_location_thread:
+ * @vw: The window that will get updated
+ * @threaddata: Data used by our background thread mechanism
+ *
+ * Use the features in vikgoto to determine where we are
+ * Then set up the viewport:
+ * 1. To goto the location
+ * 2. Set an appropriate level zoom for the location type
+ * 3. Some statusbar message feedback
+ */
+static int determine_location_thread ( VikWindow *vw, gpointer threaddata )
+{
+ struct LatLon ll;
+ gchar *name = NULL;
+ gint ans = a_vik_goto_where_am_i ( vw->viking_vvp, &ll, &name );
+
+ int result = a_background_thread_progress ( threaddata, 1.0 );
+ if ( result != 0 ) {
+ vik_window_statusbar_update ( vw, _("Location lookup aborted"), VIK_STATUSBAR_INFO );
+ return -1; /* Abort thread */
+ }
+
+ if ( ans ) {
+ // Zoom out a little
+ gdouble zoom = 16.0;
+
+ if ( ans == 2 ) {
+ // Position found with city precision - so zoom out more
+ zoom = 128.0;
+ }
+ else if ( ans == 3 ) {
+ // Position found via country name search - so zoom wayyyy out
+ zoom = 2048.0;
+ }
+
+ vik_viewport_set_zoom ( vw->viking_vvp, zoom );
+ vik_viewport_set_center_latlon ( vw->viking_vvp, &ll, FALSE );
+
+ gchar *message = g_strdup_printf ( _("Location found: %s"), name );
+ vik_window_statusbar_update ( vw, message, VIK_STATUSBAR_INFO );
+ g_free ( name );
+ g_free ( message );
+
+ // Signal to redraw from the background
+ vik_layers_panel_emit_update ( vw->viking_vlp );
+ }
+ else
+ vik_window_statusbar_update ( vw, _("Unable to determine location"), VIK_STATUSBAR_INFO );
+
+ return 0;
+}
+
+/**
+ * Steps to be taken once initial loading has completed
+ */
+void vik_window_new_window_finish ( VikWindow *vw )
+{
+ // Don't add a map if we've loaded a Viking file already
+ if ( vw->filename )
+ return;
+
+ if ( a_vik_get_startup_method ( ) == VIK_STARTUP_METHOD_SPECIFIED_FILE ) {
+ vik_window_open_file ( vw, a_vik_get_startup_file(), TRUE );
+ if ( vw->filename )
+ return;
+ }
+
+ // Maybe add a default map layer
+ if ( a_vik_get_add_default_map_layer () ) {
+ VikMapsLayer *vml = VIK_MAPS_LAYER ( vik_layer_create(VIK_LAYER_MAPS, vw->viking_vvp, FALSE) );
+ vik_layer_rename ( VIK_LAYER(vml), _("Default Map") );
+ vik_aggregate_layer_add_layer ( vik_layers_panel_get_top_layer(vw->viking_vlp), VIK_LAYER(vml), TRUE );
+
+ draw_update ( vw );
+ }
+
+ // If not loaded any file, maybe try the location lookup
+ if ( vw->loaded_type == LOAD_TYPE_READ_FAILURE ) {
+ if ( a_vik_get_startup_method ( ) == VIK_STARTUP_METHOD_AUTO_LOCATION ) {
+
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, _("Trying to determine location...") );
+
+ a_background_thread ( GTK_WINDOW(vw),
+ _("Determining location"),
+ (vik_thr_func) determine_location_thread,
+ vw,
+ NULL,
+ NULL,
+ 1 );
+ }
+ }
+}
+
static void open_window ( VikWindow *vw, GSList *files )
{
gboolean change_fn = (g_slist_length(files) == 1); /* only change fn if one file */
while ( cur_file ) {
// Only open a new window if a viking file
gchar *file_name = cur_file->data;
- if (vw != NULL && check_file_magic_vik ( file_name ) ) {
+ if (vw != NULL && vw->filename && check_file_magic_vik ( file_name ) ) {
VikWindow *newvw = vik_window_new_window ();
if (newvw)
vik_window_open_file ( newvw, file_name, TRUE );
window_list = g_slist_remove ( window_list, vw );
gdk_cursor_unref ( vw->busy_cursor );
+ int tt;
+ for (tt = 0; tt < vw->vt->n_tools; tt++ )
+ if ( vw->vt->tools[tt].ti.destroy )
+ vw->vt->tools[tt].ti.destroy ( vw->vt->tools[tt].state );
+ g_free ( vw->vt->tools );
+ g_free ( vw->vt );
G_OBJECT_CLASS(parent_class)->finalize(gob);
}
window_signals[VW_NEWWINDOW_SIGNAL] = g_signal_new ( "newwindow", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikWindowClass, newwindow), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
window_signals[VW_OPENWINDOW_SIGNAL] = g_signal_new ( "openwindow", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikWindowClass, openwindow), NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);
- window_signals[VW_STATUSBAR_UPDATE_SIGNAL] = g_signal_new ( "statusbarupdate", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikWindowClass, statusbarupdate), NULL, NULL, g_cclosure_marshal_VOID__UINT_POINTER, G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_POINTER);
object_class = G_OBJECT_CLASS (klass);
return TRUE;
}
+enum {
+ TARGET_URIS,
+};
+
+static void drag_data_received_cb ( GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ GtkSelectionData *selection_data,
+ guint target_type,
+ guint time,
+ gpointer data )
+{
+ gboolean success = FALSE;
+
+ if ( (selection_data != NULL) && (gtk_selection_data_get_length(selection_data) > 0) ) {
+ switch (target_type) {
+ case TARGET_URIS: {
+ gchar *str = (gchar*)gtk_selection_data_get_data(selection_data);
+ g_debug ("drag received string:%s \n", str);
+
+ // Convert string into GSList of individual entries for use with our open signal
+ gchar **entries = g_strsplit(str, "\r\n", 0);
+ GSList *filenames = NULL;
+ gint entry_runner = 0;
+ gchar *entry = entries[entry_runner];
+ while (entry) {
+ if ( g_strcmp0 ( entry, "" ) ) {
+ // Drag+Drop gives URIs. And so in particular, %20 in place of spaces in filenames
+ // thus need to convert the text into a plain string
+ gchar *filename = g_filename_from_uri ( entry, NULL, NULL );
+ if ( filename )
+ filenames = g_slist_append ( filenames, filename );
+ }
+ entry_runner++;
+ entry = entries[entry_runner];
+ }
+
+ if ( filenames )
+ g_signal_emit ( G_OBJECT(VIK_WINDOW_FROM_WIDGET(widget)), window_signals[VW_OPENWINDOW_SIGNAL], 0, filenames );
+ // NB: GSList & contents are freed by main.open_window
+
+ success = TRUE;
+ break;
+ }
+ default: break;
+ }
+ }
+
+ gtk_drag_finish ( context, success, FALSE, time );
+}
+
+#define VIK_SETTINGS_WIN_MAX "window_maximized"
+#define VIK_SETTINGS_WIN_FULLSCREEN "window_fullscreen"
+#define VIK_SETTINGS_WIN_WIDTH "window_width"
+#define VIK_SETTINGS_WIN_HEIGHT "window_height"
+#define VIK_SETTINGS_WIN_SAVE_IMAGE_WIDTH "window_save_image_width"
+#define VIK_SETTINGS_WIN_SAVE_IMAGE_HEIGHT "window_save_image_height"
+#define VIK_SETTINGS_WIN_SAVE_IMAGE_PNG "window_save_image_as_png"
+
static void vik_window_init ( VikWindow *vw )
{
GtkWidget *main_vbox;
gtk_action_activate ( gtk_action_group_get_action ( vw->action_group, "Pan" ) );
vw->filename = NULL;
-
+ vw->loaded_type = LOAD_TYPE_READ_FAILURE; //AKA none
vw->modified = FALSE;
vw->only_updating_coord_mode_ui = FALSE;
vw->pan_move = FALSE;
vw->pan_x = vw->pan_y = -1;
- vw->draw_image_width = DRAW_IMAGE_DEFAULT_WIDTH;
- vw->draw_image_height = DRAW_IMAGE_DEFAULT_HEIGHT;
- vw->draw_image_save_as_png = DRAW_IMAGE_DEFAULT_SAVE_AS_PNG;
+ vw->single_click_pending = FALSE;
+
+ gint draw_image_width;
+ if ( a_settings_get_integer ( VIK_SETTINGS_WIN_SAVE_IMAGE_WIDTH, &draw_image_width ) )
+ vw->draw_image_width = draw_image_width;
+ else
+ vw->draw_image_width = DRAW_IMAGE_DEFAULT_WIDTH;
+ gint draw_image_height;
+ if ( a_settings_get_integer ( VIK_SETTINGS_WIN_SAVE_IMAGE_HEIGHT, &draw_image_height ) )
+ vw->draw_image_height = draw_image_height;
+ else
+ vw->draw_image_height = DRAW_IMAGE_DEFAULT_HEIGHT;
+ gboolean draw_image_save_as_png;
+ if ( a_settings_get_boolean ( VIK_SETTINGS_WIN_SAVE_IMAGE_PNG, &draw_image_save_as_png ) )
+ vw->draw_image_save_as_png = draw_image_save_as_png;
+ else
+ vw->draw_image_save_as_png = DRAW_IMAGE_DEFAULT_SAVE_AS_PNG;
main_vbox = gtk_vbox_new(FALSE, 1);
gtk_container_add (GTK_CONTAINER (vw), main_vbox);
gtk_toolbar_set_icon_size (vw->toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_toolbar_set_style (vw->toolbar, GTK_TOOLBAR_ICONS);
+ vik_ext_tool_datasources_add_menu_items ( vw, vw->uim );
+
GtkWidget * zoom_levels = gtk_ui_manager_get_widget (vw->uim, "/MainMenu/View/SetZoom");
GtkWidget * zoom_levels_menu = create_zoom_menu_all_levels ( vik_viewport_get_zoom(vw->viking_vvp) );
gtk_menu_item_set_submenu (GTK_MENU_ITEM (zoom_levels), zoom_levels_menu);
g_signal_connect (G_OBJECT (vw), "delete_event", G_CALLBACK (delete_event), NULL);
+ // Own signals
+ g_signal_connect_swapped (G_OBJECT(vw->viking_vvp), "updated_center", G_CALLBACK(center_changed_cb), vw);
+ // Signals from GTK
g_signal_connect_swapped (G_OBJECT(vw->viking_vvp), "expose_event", G_CALLBACK(draw_sync), vw);
g_signal_connect_swapped (G_OBJECT(vw->viking_vvp), "configure_event", G_CALLBACK(window_configure_event), vw);
gtk_widget_add_events ( GTK_WIDGET(vw->viking_vvp), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK );
g_signal_connect_swapped (G_OBJECT(vw->viking_vvp), "button_press_event", G_CALLBACK(draw_click), vw);
g_signal_connect_swapped (G_OBJECT(vw->viking_vvp), "button_release_event", G_CALLBACK(draw_release), vw);
g_signal_connect_swapped (G_OBJECT(vw->viking_vvp), "motion_notify_event", G_CALLBACK(draw_mouse_motion), vw);
+
g_signal_connect_swapped (G_OBJECT(vw->viking_vlp), "update", G_CALLBACK(draw_update), vw);
+ g_signal_connect_swapped (G_OBJECT(vw->viking_vlp), "delete_layer", G_CALLBACK(vik_window_clear_highlight), vw);
// Allow key presses to be processed anywhere
g_signal_connect_swapped (G_OBJECT (vw), "key_press_event", G_CALLBACK (key_press_event), vw);
- gtk_window_set_default_size ( GTK_WINDOW(vw), VIKING_WINDOW_WIDTH, VIKING_WINDOW_HEIGHT);
+ // Set initial button sensitivity
+ center_changed_cb ( vw );
hpaned = gtk_hpaned_new ();
gtk_paned_pack1 ( GTK_PANED(hpaned), GTK_WIDGET (vw->viking_vlp), FALSE, FALSE );
window_list = g_slist_prepend ( window_list, vw);
+ gint height = VIKING_WINDOW_HEIGHT;
+ gint width = VIKING_WINDOW_WIDTH;
+
+ if ( a_vik_get_restore_window_state() ) {
+ if ( a_settings_get_integer ( VIK_SETTINGS_WIN_HEIGHT, &height ) ) {
+ // Enforce a basic minimum size
+ if ( height < 160 )
+ height = 160;
+ }
+ else
+ // No setting - so use default
+ height = VIKING_WINDOW_HEIGHT;
+
+ if ( a_settings_get_integer ( VIK_SETTINGS_WIN_WIDTH, &width ) ) {
+ // Enforce a basic minimum size
+ if ( width < 320 )
+ width = 320;
+ }
+ else
+ // No setting - so use default
+ width = VIKING_WINDOW_WIDTH;
+
+ gboolean maxed;
+ if ( a_settings_get_boolean ( VIK_SETTINGS_WIN_MAX, &maxed ) )
+ if ( maxed )
+ gtk_window_maximize ( GTK_WINDOW(vw) );
+
+ gboolean full;
+ if ( a_settings_get_boolean ( VIK_SETTINGS_WIN_FULLSCREEN, &full ) ) {
+ if ( full ) {
+ gtk_window_fullscreen ( GTK_WINDOW(vw) );
+ GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/FullScreen" );
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), TRUE );
+ }
+ }
+ }
+
+ gtk_window_set_default_size ( GTK_WINDOW(vw), width, height );
+
vw->open_dia = NULL;
vw->save_dia = NULL;
vw->save_img_dia = NULL;
vw->save_img_dir_dia = NULL;
+ // Only accept Drag and Drop of files onto the viewport
+ gtk_drag_dest_set ( GTK_WIDGET(vw->viking_vvp), GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY );
+ gtk_drag_dest_add_uri_targets ( GTK_WIDGET(vw->viking_vvp) );
+ g_signal_connect ( GTK_WIDGET(vw->viking_vvp), "drag-data-received", G_CALLBACK(drag_data_received_cb), NULL );
+
// Store the thread value so comparisons can be made to determine the gdk update method
// Hopefully we are storing the main thread value here :)
// [ATM any window initialization is always be performed by the main thread]
default: gtk_widget_destroy ( GTK_WIDGET(dia) ); return ! save_file(NULL, vw);
}
}
+
+ if ( window_count == 1 ) {
+ // On the final window close - save latest state - if it's wanted...
+ if ( a_vik_get_restore_window_state() ) {
+ gint state = gdk_window_get_state ( GTK_WIDGET(vw)->window );
+ gboolean state_max = state & GDK_WINDOW_STATE_MAXIMIZED;
+ a_settings_set_boolean ( VIK_SETTINGS_WIN_MAX, state_max );
+
+ gboolean state_fullscreen = state & GDK_WINDOW_STATE_FULLSCREEN;
+ a_settings_set_boolean ( VIK_SETTINGS_WIN_FULLSCREEN, state_fullscreen );
+
+ a_settings_set_boolean ( VIK_SETTINGS_WIN_SIDEPANEL, GTK_WIDGET_VISIBLE (GTK_WIDGET(vw->viking_vlp)) );
+
+ a_settings_set_boolean ( VIK_SETTINGS_WIN_STATUSBAR, GTK_WIDGET_VISIBLE (GTK_WIDGET(vw->viking_vs)) );
+
+ a_settings_set_boolean ( VIK_SETTINGS_WIN_TOOLBAR, GTK_WIDGET_VISIBLE (GTK_WIDGET(vw->toolbar)) );
+
+ // If supersized - no need to save the enlarged width+height values
+ if ( ! (state_fullscreen || state_max) ) {
+ gint width, height;
+ gtk_window_get_size ( GTK_WINDOW (vw), &width, &height );
+ a_settings_set_integer ( VIK_SETTINGS_WIN_WIDTH, width );
+ a_settings_set_integer ( VIK_SETTINGS_WIN_HEIGHT, height );
+ }
+ }
+
+ a_settings_set_integer ( VIK_SETTINGS_WIN_SAVE_IMAGE_WIDTH, vw->draw_image_width );
+ a_settings_set_integer ( VIK_SETTINGS_WIN_SAVE_IMAGE_HEIGHT, vw->draw_image_height );
+ a_settings_set_boolean ( VIK_SETTINGS_WIN_SAVE_IMAGE_PNG, vw->draw_image_save_as_png );
+ }
+
return FALSE;
}
/* actually draw */
vik_viewport_clear ( vw->viking_vvp);
+ // Main layer drawing
vik_layers_panel_draw_all ( vw->viking_vlp );
+ // Draw highlight (possibly again but ensures it is on top - especially for when tracks overlap)
+ if ( vik_viewport_get_draw_highlight (vw->viking_vvp) ) {
+ if ( vw->containing_vtl && (vw->selected_tracks || vw->selected_waypoints ) ) {
+ vik_trw_layer_draw_highlight_items ( vw->containing_vtl, vw->selected_tracks, vw->selected_waypoints, vw->viking_vvp );
+ }
+ else if ( vw->containing_vtl && (vw->selected_track || vw->selected_waypoint) ) {
+ vik_trw_layer_draw_highlight_item ( vw->containing_vtl, vw->selected_track, vw->selected_waypoint, vw->viking_vvp );
+ }
+ else if ( vw->selected_vtl ) {
+ vik_trw_layer_draw_highlight ( vw->selected_vtl, vw->viking_vvp );
+ }
+ }
+ // Other viewport decoration items on top if they are enabled/in use
vik_viewport_draw_scale ( vw->viking_vvp );
vik_viewport_draw_copyright ( vw->viking_vvp );
vik_viewport_draw_centermark ( vw->viking_vvp );
/* gdk_event_request_motions ( event ); */
}
+/**
+ * Action the single click after a small timeout
+ * If a double click has occurred then this will do nothing
+ */
+static gboolean vik_window_pan_timeout (VikWindow *vw)
+{
+ if ( ! vw->single_click_pending ) {
+ // Double click happened, so don't do anything
+ return FALSE;
+ }
+
+ /* set panning origin */
+ vw->pan_move = FALSE;
+ vw->single_click_pending = FALSE;
+ vik_viewport_set_center_screen ( vw->viking_vvp, vw->delayed_pan_x, vw->delayed_pan_y );
+ draw_update ( vw );
+
+ // Really turn off the pan moving!!
+ vw->pan_x = vw->pan_y = -1;
+ return FALSE;
+}
+
static void vik_window_pan_release ( VikWindow *vw, GdkEventButton *event )
{
- if ( vw->pan_move == FALSE )
- vik_viewport_set_center_screen ( vw->viking_vvp, vw->pan_x, vw->pan_y );
- else
+ gboolean do_draw = TRUE;
+
+ if ( vw->pan_move == FALSE ) {
+ vw->single_click_pending = !vw->single_click_pending;
+
+ if ( vw->single_click_pending ) {
+ // Store offset to use
+ vw->delayed_pan_x = vw->pan_x;
+ vw->delayed_pan_y = vw->pan_y;
+ // Get double click time
+ GtkSettings *gs = gtk_widget_get_settings ( GTK_WIDGET(vw) );
+ GValue dct = G_VALUE_INIT;
+ g_value_init ( &dct, G_TYPE_INT );
+ g_object_get_property ( G_OBJECT(gs), "gtk-double-click-time", &dct );
+ // Give chance for a double click to occur
+ gint timer = g_value_get_int ( &dct ) + 50;
+ g_timeout_add ( timer, (GSourceFunc)vik_window_pan_timeout, vw );
+ do_draw = FALSE;
+ }
+ else {
+ vik_viewport_set_center_screen ( vw->viking_vvp, vw->pan_x, vw->pan_y );
+ }
+ }
+ else {
vik_viewport_set_center_screen ( vw->viking_vvp, vik_viewport_get_width(vw->viking_vvp)/2 - event->x + vw->pan_x,
vik_viewport_get_height(vw->viking_vvp)/2 - event->y + vw->pan_y );
+ }
+
vw->pan_move = FALSE;
vw->pan_x = vw->pan_y = -1;
- draw_update ( vw );
+ if ( do_draw )
+ draw_update ( vw );
}
static void draw_release ( VikWindow *vw, GdkEventButton *event )
(VikToolKeyFunc) ruler_key_press,
FALSE,
GDK_CURSOR_IS_PIXMAP,
- &cursor_ruler_pixbuf };
+ &cursor_ruler_pixbuf,
+ NULL };
/*** end ruler code ********************************************************/
draw_buf_done = FALSE;
}
}
+ else
+ zts->bounds_active = FALSE;
+
return VIK_LAYER_TOOL_ACK;
}
{
guint modifiers = event->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK);
- zts->bounds_active = FALSE;
-
// Ensure haven't just released on the exact same position
// i.e. probably haven't moved the mouse at all
- if ( modifiers == GDK_SHIFT_MASK && !( ( event->x == zts->start_x ) && ( event->y == zts->start_y )) ) {
+ if ( zts->bounds_active && modifiers == GDK_SHIFT_MASK &&
+ ( event->x < zts->start_x-5 || event->x > zts->start_x+5 ) &&
+ ( event->y < zts->start_y-5 || event->y > zts->start_y+5 ) ) {
VikCoord coord1, coord2;
vik_viewport_screen_to_coord ( zts->vw->viking_vvp, zts->start_x, zts->start_y, &coord1);
VikCoord new_center;
vik_coord_load_from_latlon ( &new_center, vik_viewport_get_coord_mode ( zts->vw->viking_vvp ), &average );
- vik_viewport_set_center_coord ( zts->vw->viking_vvp, &new_center );
+ vik_viewport_set_center_coord ( zts->vw->viking_vvp, &new_center, FALSE );
/* Convert into definite 'smallest' and 'largest' positions */
struct LatLon minmin;
zoom = zoom * 2;
vik_viewport_set_zoom ( zts->vw->viking_vvp, zoom );
}
-
- draw_update ( zts->vw );
}
+ else {
+ // When pressing shift and clicking for zoom, then jump three levels
+ if ( modifiers == GDK_SHIFT_MASK ) {
+ // Zoom in/out by three if possible
+ vik_viewport_set_center_screen ( zts->vw->viking_vvp, event->x, event->y );
+ if ( event->button == 1 ) {
+ vik_viewport_zoom_in ( zts->vw->viking_vvp );
+ vik_viewport_zoom_in ( zts->vw->viking_vvp );
+ vik_viewport_zoom_in ( zts->vw->viking_vvp );
+ }
+ else if ( event->button == 3 ) {
+ vik_viewport_zoom_out ( zts->vw->viking_vvp );
+ vik_viewport_zoom_out ( zts->vw->viking_vvp );
+ vik_viewport_zoom_out ( zts->vw->viking_vvp );
+ }
+ }
+ }
+
+ draw_update ( zts->vw );
+
+ // Reset
+ zts->bounds_active = FALSE;
+
return VIK_LAYER_TOOL_ACK;
}
NULL,
FALSE,
GDK_CURSOR_IS_PIXMAP,
- &cursor_zoom_pixbuf };
+ &cursor_zoom_pixbuf,
+ NULL };
/*** end zoom code ********************************************************/
/********************************************************************************
return vw;
}
+// NB Double clicking means this gets called THREE times!!!
static VikLayerToolFuncStatus pantool_click (VikLayer *vl, GdkEventButton *event, VikWindow *vw)
{
vw->modified = TRUE;
- if ( event->button == 1 )
- vik_window_pan_click ( vw, event );
- draw_update ( vw );
+
+ if ( event->type == GDK_2BUTTON_PRESS ) {
+ // Zoom in / out on double click
+ // No need to change the center as that has already occurred in the first click of a double click occurrence
+ if ( event->button == 1 ) {
+ guint modifier = event->state & GDK_SHIFT_MASK;
+ if ( modifier )
+ vik_viewport_zoom_out ( vw->viking_vvp );
+ else
+ vik_viewport_zoom_in ( vw->viking_vvp );
+ }
+ else if ( event->button == 3 )
+ vik_viewport_zoom_out ( vw->viking_vvp );
+
+ draw_update ( vw );
+ }
+ else
+ // Standard pan click
+ if ( event->button == 1 )
+ vik_window_pan_click ( vw, event );
+
return VIK_LAYER_TOOL_ACK;
}
(VikToolMouseFunc) pantool_release,
NULL,
FALSE,
- GDK_FLEUR };
+ GDK_FLEUR,
+ NULL,
+ NULL };
/*** end pan code ********************************************************/
/********************************************************************************
return;
}
- vik_viewport_set_center_coord ( vw->viking_vvp, &new_center );
+ vik_viewport_set_center_coord ( vw->viking_vvp, &new_center, TRUE );
draw_update ( vw );
}
+/**
+ * center_changed_cb:
+ */
+static void center_changed_cb ( VikWindow *vw )
+{
+// ATM Keep back always available, so when we pan - we can jump to the last requested position
+/*
+ GtkAction* action_back = gtk_action_group_get_action ( vw->action_group, "GoBack" );
+ if ( action_back ) {
+ gtk_action_set_sensitive ( action_back, vik_viewport_back_available(vw->viking_vvp) );
+ }
+*/
+ GtkAction* action_forward = gtk_action_group_get_action ( vw->action_group, "GoForward" );
+ if ( action_forward ) {
+ gtk_action_set_sensitive ( action_forward, vik_viewport_forward_available(vw->viking_vvp) );
+ }
+}
+
+/**
+ * draw_goto_back_and_forth:
+ */
+static void draw_goto_back_and_forth ( GtkAction *a, VikWindow *vw )
+{
+ gboolean changed = FALSE;
+ if (!strcmp(gtk_action_get_name(a), "GoBack")) {
+ changed = vik_viewport_go_back ( vw->viking_vvp );
+ }
+ else if (!strcmp(gtk_action_get_name(a), "GoForward")) {
+ changed = vik_viewport_go_forward ( vw->viking_vvp );
+ }
+ else {
+ return;
+ }
+
+ // Recheck buttons sensitivities, as the center changed signal is not sent on back/forward changes
+ // (otherwise we would get stuck in an infinite loop!)
+ center_changed_cb ( vw );
+
+ if ( changed )
+ draw_update ( vw );
+}
+
/**
* Refresh maps displayed
*/
vw->current_tool = TOOL_SELECT;
}
else {
- /* TODO: only enable tools from active layer */
VikLayerTypeEnum layer_id;
for (layer_id=0; layer_id<VIK_LAYER_NUM_TYPES; layer_id++) {
for ( tool_id = 0; tool_id < vik_layer_get_interface(layer_id)->tools_count; tool_id++ ) {
- if (!strcmp(vik_layer_get_interface(layer_id)->tools[tool_id].radioActionEntry.name, gtk_action_get_name(a))) {
+ if (!strcmp(vik_layer_get_interface(layer_id)->tools[tool_id].radioActionEntry.name, gtk_action_get_name(a))) {
vw->current_tool = TOOL_LAYER;
vw->tool_layer_id = layer_id;
vw->tool_tool_id = tool_id;
- }
+ }
}
}
}
menu = gtk_recent_chooser_menu_new_for_manager (manager);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (menu), GTK_RECENT_SORT_MRU);
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (menu), filter);
+ gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (menu), a_vik_get_recent_number_files() );
menu_item = gtk_ui_manager_get_widget (self->uim, "/ui/MainMenu/File/OpenRecentFile");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
{
gdk_window_set_cursor ( gtk_widget_get_window(GTK_WIDGET(vw)), vw->busy_cursor );
// Viewport has a separate cursor
- gdk_window_set_cursor ( GTK_WIDGET(vw->viking_vvp)->window, vw->busy_cursor );
+ gdk_window_set_cursor ( gtk_widget_get_window(GTK_WIDGET(vw->viking_vvp)), vw->busy_cursor );
// Ensure cursor updated before doing stuff
while( gtk_events_pending() )
gtk_main_iteration();
{
gdk_window_set_cursor ( gtk_widget_get_window(GTK_WIDGET(vw)), NULL );
// Restore viewport cursor
- gdk_window_set_cursor ( GTK_WIDGET(vw->viking_vvp)->window, vw->viewport_cursor );
+ gdk_window_set_cursor ( gtk_widget_get_window(GTK_WIDGET(vw->viking_vvp)), vw->viewport_cursor );
}
void vik_window_open_file ( VikWindow *vw, const gchar *filename, gboolean change_filename )
{
vik_window_set_busy_cursor ( vw );
- switch ( a_file_load ( vik_layers_panel_get_top_layer(vw->viking_vlp), vw->viking_vvp, filename ) )
+ // Enable the *new* filename to be accessible by the Layers codez
+ gchar *original_filename = g_strdup ( vw->filename );
+ g_free ( vw->filename );
+ vw->filename = g_strdup ( filename );
+ gboolean success = FALSE;
+ gboolean restore_original_filename = FALSE;
+
+ vw->loaded_type = a_file_load ( vik_layers_panel_get_top_layer(vw->viking_vlp), vw->viking_vvp, filename );
+ switch ( vw->loaded_type )
{
case LOAD_TYPE_READ_FAILURE:
a_dialog_error_msg ( GTK_WINDOW(vw), _("The file you requested could not be opened.") );
// No break, carry on to show any data
case LOAD_TYPE_VIK_SUCCESS:
{
+ restore_original_filename = TRUE; // NB Will actually get inverted by the 'success' component below
GtkWidget *mode_button;
/* Update UI */
if ( change_filename )
g_assert ( mode_button );
gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(mode_button),vik_viewport_get_draw_highlight (vw->viking_vvp) );
}
+ // NB No break, carry on to redraw
//case LOAD_TYPE_OTHER_SUCCESS:
default:
+ success = TRUE;
+ // When LOAD_TYPE_OTHER_SUCCESS *only*, this will maintain the existing Viking project
+ restore_original_filename = ! restore_original_filename;
update_recently_used_document(filename);
draw_update ( vw );
break;
}
+ if ( ! success || restore_original_filename )
+ // Load didn't work or want to keep as the existing Viking project, keep using the original name
+ window_set_filename ( vw, original_filename );
+ g_free ( original_filename );
+
vik_window_clear_busy_cursor ( vw );
}
gtk_file_filter_add_pattern ( filter, "*.gpx" ); // No MIME type available
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(vw->open_dia), filter);
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name ( filter, _("JPG") );
+ gtk_file_filter_add_mime_type ( filter, "image/jpeg");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(vw->open_dia), filter);
+
filter = gtk_file_filter_new ();
gtk_file_filter_set_name( filter, _("Viking") );
gtk_file_filter_add_pattern ( filter, "*.vik" );
}
// Auto append / replace extension with '.vik' to the suggested file name as it's going to be a Viking File
gchar* auto_save_name = g_strdup ( window_get_filename ( vw ) );
- if ( ! check_file_ext ( auto_save_name, ".vik" ) )
+ if ( ! a_file_check_ext ( auto_save_name, ".vik" ) )
auto_save_name = g_strconcat ( auto_save_name, ".vik", NULL );
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER(vw->save_dia), auto_save_name);
// Show some progress
if ( this_success ) {
export_count++;
- gchar *message = g_strconcat ( _("Exporting to file: "), fn, NULL );
+ gchar *message = g_strdup_printf ( _("Exporting to file: %s"), fn );
vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, message );
while ( gtk_events_pending() )
gtk_main_iteration ();
return;
}
- GtkWidget *dialog = gtk_dialog_new_with_buttons ( _("Export to directory"),
+ GtkWidget *dialog = gtk_file_chooser_dialog_new ( _("Export to directory"),
GTK_WINDOW(vw),
- GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL );
-
- GtkWidget *gw = gtk_file_chooser_widget_new ( GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
- gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), gw, TRUE, TRUE, 0 );
-
- // try to make it a nice size - otherwise seems to default to something impractically small
- gtk_window_set_default_size ( GTK_WINDOW(dialog), 600, 300 );
+ gtk_window_set_transient_for ( GTK_WINDOW(dialog), GTK_WINDOW(vw) );
+ gtk_window_set_destroy_with_parent ( GTK_WINDOW(dialog), TRUE );
+ gtk_window_set_modal ( GTK_WINDOW(dialog), TRUE );
gtk_widget_show_all ( dialog );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) {
- gchar *dir = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER(gw) );
+ gchar *dir = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER(dialog) );
gtk_widget_destroy ( dialog );
if ( dir ) {
if ( !export_to ( vw, gl, vft, dir, extension ) )
export_to_common ( vw, FILE_TYPE_KML, ".kml" );
}
+#if !GLIB_CHECK_VERSION(2,26,0)
+typedef struct stat GStatBuf;
+#endif
+
+static void file_properties_cb ( GtkAction *a, VikWindow *vw )
+{
+ gchar *message = NULL;
+ if ( vw->filename ) {
+ if ( g_file_test ( vw->filename, G_FILE_TEST_EXISTS ) ) {
+ // Get some timestamp information of the file
+ GStatBuf stat_buf;
+ if ( g_stat ( vw->filename, &stat_buf ) == 0 ) {
+ gchar time_buf[64];
+ strftime ( time_buf, sizeof(time_buf), "%c", gmtime((const time_t *)&stat_buf.st_mtime) );
+ gchar *size = NULL;
+ gint byte_size = stat_buf.st_size;
+ // See http://en.wikipedia.org/wiki/Megabyte (and Kilobyte)
+ // hence using 1000 rather than 1024
+ // so get output as per 'ls' or the Gtk file open dialog
+ if ( byte_size < 1000 )
+ size = g_strdup_printf ( _("%d bytes"), byte_size );
+ else if ( byte_size < 1000*1000 )
+ size = g_strdup_printf ( _("%3.1f kB"), (gdouble)byte_size / 1000 );
+ else
+ size = g_strdup_printf ( _("%3.1f MB"), (gdouble)byte_size / (1000*1000) );
+ message = g_strdup_printf ( _("%s\n\n%s\n\n%s"), vw->filename, time_buf, size );
+ g_free (size);
+ }
+ }
+ else
+ message = g_strdup ( _("File not accessible") );
+ }
+ else
+ message = g_strdup ( _("No Viking File") );
+
+ // Show the info
+ a_dialog_info_msg ( GTK_WINDOW(vw), message );
+ g_free ( message );
+}
+
static void acquire_from_gps ( GtkAction *a, VikWindow *vw )
{
// Via the file menu, acquiring from a GPS makes a new layer
// thus maintain the behaviour ATM.
// Hence explicit setting here (as the value may be changed elsewhere)
vik_datasource_gps_interface.mode = VIK_DATASOURCE_CREATENEWLAYER;
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_gps_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_gps_interface, NULL, NULL );
}
static void acquire_from_file ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_file_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_file_interface, NULL, NULL );
}
-#ifdef VIK_CONFIG_GOOGLE
-static void acquire_from_google ( GtkAction *a, VikWindow *vw )
+static void acquire_from_routing ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_google_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_routing_interface, NULL, NULL );
}
-#endif
#ifdef VIK_CONFIG_OPENSTREETMAP
static void acquire_from_osm ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_osm_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_osm_interface, NULL, NULL );
}
static void acquire_from_my_osm ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_osm_my_traces_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_osm_my_traces_interface, NULL, NULL );
}
#endif
#ifdef VIK_CONFIG_GEOCACHES
static void acquire_from_gc ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_gc_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_gc_interface, NULL, NULL );
}
#endif
static void acquire_from_geotag ( GtkAction *a, VikWindow *vw )
{
vik_datasource_geotag_interface.mode = VIK_DATASOURCE_CREATENEWLAYER;
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_geotag_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_geotag_interface, NULL, NULL );
}
#endif
#ifdef VIK_CONFIG_GEONAMES
static void acquire_from_wikipedia ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_wikipedia_interface );
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_wikipedia_interface, NULL, NULL );
}
#endif
+static void acquire_from_url ( GtkAction *a, VikWindow *vw )
+{
+ vik_datasource_url_interface.mode = VIK_DATASOURCE_CREATENEWLAYER;
+ a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_url_interface, NULL, NULL );
+}
+
static void goto_default_location( GtkAction *a, VikWindow *vw)
{
struct LatLon ll;
ll.lat = a_vik_get_default_lat();
ll.lon = a_vik_get_default_long();
- vik_viewport_set_center_latlon(vw->viking_vvp, &ll);
+ vik_viewport_set_center_latlon(vw->viking_vvp, &ll, TRUE);
vik_layers_panel_emit_update(vw->viking_vlp);
}
// Want to update all TrackWaypoint layers
GList *layers = vik_layers_panel_get_all_layers_of_type ( vw->viking_vlp, VIK_LAYER_TRW, TRUE );
- GList *iter = g_list_first ( layers );
- while ( iter ) {
+ if ( !layers )
+ return;
+
+ while ( layers ) {
// Reset the individual waypoints themselves due to the preferences change
- VikTrwLayer *vtl = VIK_TRW_LAYER(VIK_LAYER(layers->data));
+ VikTrwLayer *vtl = VIK_TRW_LAYER(layers->data);
vik_trw_layer_reset_waypoints ( vtl );
- iter = g_list_next ( iter );
+ layers = g_list_next ( layers );
}
g_list_free ( layers );
VIK_LAYER_WIDGET_SPINBUTTON,
NULL,
NULL,
- NULL },
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ },
};
VikLayerParam pref_lon[] = {
{ VIK_LAYER_NUM_TYPES,
VIK_LAYER_WIDGET_SPINBUTTON,
NULL,
NULL,
- NULL },
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ },
};
/* Get current center */
utm.northing -= ((gdouble)y - (((gdouble)tiles_h)+1)/2) * (h*zoom);
/* move to correct place. */
- vik_viewport_set_center_utm ( vw->viking_vvp, &utm );
+ vik_viewport_set_center_utm ( vw->viking_vvp, &utm, FALSE );
draw_redraw ( vw );
}
}
- vik_viewport_set_center_utm ( vw->viking_vvp, &utm_orig );
+ vik_viewport_set_center_utm ( vw->viking_vvp, &utm_orig, FALSE );
vik_viewport_set_xmpp ( vw->viking_vvp, old_xmpp );
vik_viewport_set_ympp ( vw->viking_vvp, old_ympp );
vik_viewport_configure ( vw->viking_vvp );
png_radio = gtk_radio_button_new_with_label ( NULL, _("Save as PNG") );
jpeg_radio = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(png_radio), _("Save as JPEG") );
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), png_radio, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), jpeg_radio, FALSE, FALSE, 0);
+
if ( ! vw->draw_image_save_as_png )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(jpeg_radio), TRUE );
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), win_warning_label, FALSE, FALSE, 0);
#endif
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), current_window_button, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), png_radio, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), jpeg_radio, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), zoom_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), zoom_combo, FALSE, FALSE, 0);
if ( !fn )
return;
- gint active = gtk_combo_box_get_active ( GTK_COMBO_BOX(zoom_combo) );
- gdouble zoom = pow (2, active-2 );
+ gint active_z = gtk_combo_box_get_active ( GTK_COMBO_BOX(zoom_combo) );
+ gdouble zoom = pow (2, active_z-2 );
if ( one_image_only )
save_image_file ( vw, fn,
{ "Acquire", GTK_STOCK_GO_DOWN, N_("A_cquire"), NULL, NULL, (GCallback)NULL },
{ "AcquireGPS", NULL, N_("From _GPS..."), NULL, N_("Transfer data from a GPS device"), (GCallback)acquire_from_gps },
{ "AcquireGPSBabel", NULL, N_("Import File With GPS_Babel..."), NULL, N_("Import file via GPSBabel converter"), (GCallback)acquire_from_file },
-#ifdef VIK_CONFIG_GOOGLE
- { "AcquireGoogle", NULL, N_("Google _Directions..."), NULL, N_("Get driving directions from Google"), (GCallback)acquire_from_google },
-#endif
+ { "AcquireRouting", NULL, N_("_Directions..."), NULL, N_("Get driving directions"), (GCallback)acquire_from_routing },
#ifdef VIK_CONFIG_OPENSTREETMAP
{ "AcquireOSM", NULL, N_("_OSM Traces..."), NULL, N_("Get traces from OpenStreetMap"), (GCallback)acquire_from_osm },
{ "AcquireMyOSM", NULL, N_("_My OSM Traces..."), NULL, N_("Get Your Own Traces from OpenStreetMap"), (GCallback)acquire_from_my_osm },
#ifdef VIK_CONFIG_GEOTAG
{ "AcquireGeotag", NULL, N_("From Geotagged _Images..."), NULL, N_("Create waypoints from geotagged images"), (GCallback)acquire_from_geotag },
#endif
+ { "AcquireURL", NULL, N_("From _URL..."), NULL, N_("Get a file from a URL"), (GCallback)acquire_from_url },
#ifdef VIK_CONFIG_GEONAMES
{ "AcquireWikipedia", NULL, N_("From _Wikipedia Waypoints"), NULL, N_("Create waypoints from Wikipedia items in the current view"), (GCallback)acquire_from_wikipedia },
#endif
{ "Save", GTK_STOCK_SAVE, N_("_Save"), "<control>S", N_("Save the file"), (GCallback)save_file },
{ "SaveAs", GTK_STOCK_SAVE_AS, N_("Save _As..."), NULL, N_("Save the file under different name"), (GCallback)save_file_as },
+ { "FileProperties", NULL, N_("Properties..."), NULL, N_("File Properties"), (GCallback)file_properties_cb },
{ "GenImg", GTK_STOCK_CLEAR, N_("_Generate Image File..."), NULL, N_("Save a snapshot of the workspace into a file"), (GCallback)draw_to_image_file_cb },
{ "GenImgDir", GTK_STOCK_DND_MULTIPLE, N_("Generate _Directory of Images..."), NULL, N_("FIXME:IMGDIR"), (GCallback)draw_to_image_dir_cb },
{ "Print", GTK_STOCK_PRINT, N_("_Print..."), NULL, N_("Print maps"), (GCallback)print_cb },
{ "Exit", GTK_STOCK_QUIT, N_("E_xit"), "<control>W", N_("Exit the program"), (GCallback)window_close },
{ "SaveExit", GTK_STOCK_QUIT, N_("Save and Exit"), NULL, N_("Save and Exit the program"), (GCallback)save_file_and_exit },
+ { "GoBack", GTK_STOCK_GO_BACK, N_("Go to the Pre_vious Location"), NULL, N_("Go to the previous location"), (GCallback)draw_goto_back_and_forth },
+ { "GoForward", GTK_STOCK_GO_FORWARD, N_("Go to the _Next Location"), NULL, N_("Go to the next location"), (GCallback)draw_goto_back_and_forth },
{ "GotoDefaultLocation", GTK_STOCK_HOME, N_("Go to the _Default Location"), NULL, N_("Go to the default location"), (GCallback)goto_default_location },
{ "GotoSearch", GTK_STOCK_JUMP_TO, N_("Go to _Location..."), NULL, N_("Go to address/place using text search"), (GCallback)goto_address },
{ "GotoLL", GTK_STOCK_JUMP_TO, N_("_Go to Lat/Lon..."), NULL, N_("Go to arbitrary lat/lon coordinate"), (GCallback)draw_goto_cb },
gtk_action_group_add_radio_actions (action_group, mode_entries, G_N_ELEMENTS (mode_entries), 4, (GCallback)window_change_coord_mode_cb, window);
// Use this to see if GPSBabel is available:
- if ( a_babel_device_list ) {
+ if ( a_babel_available () ) {
// If going to add more entries then might be worth creating a menu_gpsbabel.xml.h file
if ( gtk_ui_manager_add_ui_from_string ( uim,
"<ui><menubar name='MainMenu'><menu action='File'><menu action='Export'><menuitem action='ExportKML'/></menu></menu></menubar></ui>",
action.callback = (GCallback)menu_addlayer_cb;
gtk_action_group_add_actions(action_group, &action, 1, window);
+ g_free ( (gchar*)action.label );
+
if ( vik_layer_get_interface(i)->tools_count ) {
gtk_ui_manager_add_ui(uim, mid, "/ui/MainMenu/Tools/", vik_layer_get_interface(i)->name, NULL, GTK_UI_MANAGER_SEPARATOR, FALSE);
gtk_ui_manager_add_ui(uim, mid, "/ui/MainToolbar/ToolItems/", vik_layer_get_interface(i)->name, NULL, GTK_UI_MANAGER_SEPARATOR, FALSE);
}
GtkActionEntry action_dl;
+ gchar *layername = g_strdup_printf ( "Layer%s", vik_layer_get_interface(i)->fixed_layer_name );
gtk_ui_manager_add_ui(uim, mid, "/ui/MainMenu/Edit/LayerDefaults",
vik_layer_get_interface(i)->name,
- g_strdup_printf("Layer%s", vik_layer_get_interface(i)->fixed_layer_name),
+ layername,
GTK_UI_MANAGER_MENUITEM, FALSE);
+ g_free (layername);
// For default layers use action names of the form 'Layer<LayerName>'
// This is to avoid clashing with just the layer name used above for the tool actions
action_dl.tooltip = NULL;
action_dl.callback = (GCallback)layer_defaults_cb;
gtk_action_group_add_actions(action_group, &action_dl, 1, window);
+ g_free ( (gchar*)action_dl.name );
+ g_free ( (gchar*)action_dl.label );
}
g_object_unref (icon_factory);