*
* 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-2015, 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 "background.h"
#include "acquire.h"
#include "datasources.h"
+#include "geojson.h"
#include "vikgoto.h"
#include "dems.h"
#include "mapcache.h"
#include "print.h"
#include "preferences.h"
+#include "toolbar.h"
+#include "viklayer_defaults.h"
#include "icons/icons.h"
#include "vikexttools.h"
+#include "vikexttool_datasources.h"
#include "garminsymbols.h"
+#include "vikmapslayer.h"
+#include "vikrouting.h"
+#include "geonamessearch.h"
+#include "dir.h"
+#include "kmz.h"
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
// why not be allowed to open a thousand more...
#define MAX_WINDOWS 1024
static guint window_count = 0;
+static GSList *window_list = NULL;
#define VIKING_WINDOW_WIDTH 1000
#define VIKING_WINDOW_HEIGHT 800
#define DRAW_IMAGE_DEFAULT_HEIGHT 1024
#define DRAW_IMAGE_DEFAULT_SAVE_AS_PNG TRUE
+// The last used directories
+static gchar *last_folder_files_uri = NULL;
+static gchar *last_folder_images_uri = NULL;
+
static void window_finalize ( GObject *gob );
static GObjectClass *parent_class;
-static void window_init ( VikWindow *vw );
-static void window_class_init ( VikWindowClass *klass );
static void window_set_filename ( VikWindow *vw, const gchar *filename );
+static const gchar *window_get_filename ( VikWindow *vw );
static VikWindow *window_new ();
// Signals
static void open_window ( VikWindow *vw, GSList *files );
-static void statusbar_update ( VikWindow *vw, const gchar *message, vik_statusbar_type_t vs_type );
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 );
static void draw_mouse_motion ( VikWindow *vw, GdkEventMotion *event );
static void draw_zoom_cb ( GtkAction *a, VikWindow *vw );
static void draw_goto_cb ( GtkAction *a, VikWindow *vw );
+static void draw_refresh_cb ( GtkAction *a, VikWindow *vw );
static void draw_status ( VikWindow *vw );
/* End Drawing Functions */
+static void toggle_draw_scale ( GtkAction *a, VikWindow *vw );
+static void toggle_draw_centermark ( GtkAction *a, VikWindow *vw );
+static void toggle_draw_highlight ( GtkAction *a, VikWindow *vw );
+
static void menu_addlayer_cb ( GtkAction *a, VikWindow *vw );
static void menu_properties_cb ( GtkAction *a, VikWindow *vw );
static void menu_delete_layer_cb ( GtkAction *a, VikWindow *vw );
VikWindow *vw;
} toolbox_tools_t;
-static void menu_tool_cb ( GtkAction *old, GtkAction *a, VikWindow *vw );
+static void menu_cb ( GtkAction *old, GtkAction *a, VikWindow *vw );
+static void window_change_coord_mode_cb ( GtkAction *old, GtkAction *a, VikWindow *vw );
static toolbox_tools_t* toolbox_create(VikWindow *vw);
static void toolbox_add_tool(toolbox_tools_t *vt, VikToolInterface *vti, gint layer_type );
static int toolbox_get_tool(toolbox_tools_t *vt, const gchar *tool_name);
struct _VikWindow {
GtkWindow gtkwindow;
+ GtkWidget *hpaned;
VikViewport *viking_vvp;
VikLayersPanel *viking_vlp;
VikStatusbar *viking_vs;
+ VikToolbar *viking_vtb;
- GtkToolbar *toolbar;
+ GtkWidget *main_vbox;
+ GtkWidget *menu_hbox;
- GtkItemFactory *item_factory;
+ GdkCursor *busy_cursor;
+ GdkCursor *viewport_cursor; // only a reference
/* tool management state */
guint current_tool;
GtkActionGroup *action_group;
+ // Display controls
+ // NB scale, centermark and highlight are in viewport.
+ gboolean show_full_screen;
+ gboolean show_side_panel;
+ gboolean show_statusbar;
+ gboolean show_toolbar;
+ gboolean show_main_menu;
+
+ gboolean select_move;
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;
-
- GtkWidget *open_dia, *save_dia;
- GtkWidget *save_img_dia, *save_img_dir_dia;
+ VikLoadType_t loaded_type;
gboolean only_updating_coord_mode_ui; /* hack for a bug in GTK */
GtkUIManager *uim;
+ GThread *thread;
/* half-drawn update */
VikLayer *trigger;
VikCoord trigger_center;
/* Store at this level for highlighted selection drawing since it applies to the viewport and the layers panel */
/* Only one of these items can be selected at the same time */
gpointer selected_vtl; /* notionally VikTrwLayer */
- gpointer selected_tracks; /* notionally GList */
+ GHashTable *selected_tracks;
gpointer selected_track; /* notionally VikTrack */
- gpointer selected_waypoints; /* notionally GList */
+ GHashTable *selected_waypoints;
gpointer selected_waypoint; /* notionally VikWaypoint */
/* only use for individual track or waypoint */
- ////// NEED TO THINK ABOUT VALIDITY OF THESE //////
- ////// i.e. what happens when stuff is deleted elsewhere //////
- ////// Generally seems alright as can not access them //////
- ////// containing_vtl now seems unecessary //////
/* For track(s) & waypoint(s) it is the layer they are in - this helps refering to the individual item easier */
gpointer containing_vtl; /* notionally VikTrwLayer */
};
enum {
VW_NEWWINDOW_SIGNAL,
VW_OPENWINDOW_SIGNAL,
- VW_STATUSBAR_UPDATE_SIGNAL,
VW_LAST_SIGNAL
};
// TODO get rid of this as this is unnecessary duplication...
static gchar *tool_names[NUMBER_OF_TOOLS] = { N_("Pan"), N_("Zoom"), N_("Ruler"), N_("Select") };
-GType vik_window_get_type (void)
-{
- static GType vw_type = 0;
-
- if (!vw_type)
- {
- static const GTypeInfo vw_info =
- {
- sizeof (VikWindowClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) window_class_init, /* class_init */
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof (VikWindow),
- 0,
- (GInstanceInitFunc) window_init,
- };
- vw_type = g_type_register_static ( GTK_TYPE_WINDOW, "VikWindow", &vw_info, 0 );
- }
-
- return vw_type;
-}
+G_DEFINE_TYPE (VikWindow, vik_window, GTK_TYPE_WINDOW)
VikViewport * vik_window_viewport(VikWindow *vw)
{
}
/**
- * 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, message, vs_type );
+ 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 );
+ GThread *thread = vik_window_get_thread ( vw );
+ if ( !thread )
+ // Do nothing
+ return;
+
+ 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() == thread ) {
+ 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
static void destroy_window ( GtkWidget *widget,
gpointer data )
{
- if ( ! --window_count )
+ g_debug ( "%s", __FUNCTION__ );
+ if ( ! --window_count ) {
+ g_free ( last_folder_files_uri );
+ g_free ( last_folder_images_uri );
gtk_main_quit ();
+ }
}
-static void statusbar_update ( VikWindow *vw, const gchar *message, vik_statusbar_type_t vs_type )
-{
- 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 ()
{
{
VikWindow *vw = window_new ();
+ if ( window_count == 0 ) {
+ vik_window_statusbar_update ( vw, _("This is Viking "VIKING_VERSION), VIK_STATUSBAR_INFO );
+ }
+
g_signal_connect (G_OBJECT (vw), "destroy",
G_CALLBACK (destroy_window), NULL);
g_signal_connect (G_OBJECT (vw), "newwindow",
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 ( toolbar_get_widget (vw->viking_vtb) );
+ 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;
+
+ // 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 ( BACKGROUND_POOL_REMOTE,
+ GTK_WINDOW(vw),
+ _("Determining location"),
+ (vik_thr_func) determine_location_thread,
+ vw,
+ NULL,
+ NULL,
+ 1 );
+ }
+ }
+}
+
static void open_window ( VikWindow *vw, GSList *files )
{
+ if ( !vw )
+ return;
gboolean change_fn = (g_slist_length(files) == 1); /* only change fn if one file */
GSList *cur_file = files;
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->filename && check_file_magic_vik ( file_name ) ) {
VikWindow *newvw = vik_window_new_window ();
if (newvw)
- vik_window_open_file ( newvw, file_name, change_fn );
+ vik_window_open_file ( newvw, file_name, TRUE );
}
else {
vik_window_open_file ( vw, file_name, change_fn );
action = gtk_action_group_get_action(vw->action_group,
layer_interface->tools[j].radioActionEntry.name);
g_object_set(action, "sensitive", i == vl->type, NULL);
+ toolbar_action_set_sensitive ( vw->viking_vtb, vik_layer_get_interface(i)->tools[j].radioActionEntry.name, i == vl->type );
}
}
}
a_background_remove_window ( vw );
+ 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 );
+
+ vik_toolbar_finalize ( vw->viking_vtb );
+
G_OBJECT_CLASS(parent_class)->finalize(gob);
}
-static void window_class_init ( VikWindowClass *klass )
+static void vik_window_class_init ( VikWindowClass *klass )
{
/* destructor */
GObjectClass *object_class;
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, gtk_marshal_VOID__POINTER_UINT, G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_UINT);
object_class = G_OBJECT_CLASS (klass);
}
-static void window_init ( VikWindow *vw )
+static void zoom_changed (GtkMenuShell *menushell,
+ gpointer user_data)
{
- GtkWidget *main_vbox;
- GtkWidget *hpaned;
+ VikWindow *vw = VIK_WINDOW (user_data);
+
+ GtkWidget *aw = gtk_menu_get_active ( GTK_MENU (menushell) );
+ gint active = GPOINTER_TO_INT(g_object_get_data ( G_OBJECT (aw), "position" ));
+
+ gdouble zoom_request = pow (2, active-5 );
+
+ // But has it really changed?
+ gdouble current_zoom = vik_viewport_get_zoom ( vw->viking_vvp );
+ if ( current_zoom != 0.0 && zoom_request != current_zoom ) {
+ vik_viewport_set_zoom ( vw->viking_vvp, zoom_request );
+ // Force drawing update
+ draw_update ( vw );
+ }
+}
+
+/**
+ * @mpp: The initial zoom level
+ */
+static GtkWidget *create_zoom_menu_all_levels ( gdouble mpp )
+{
+ GtkWidget *menu = gtk_menu_new ();
+ char *itemLabels[] = { "0.031", "0.063", "0.125", "0.25", "0.5", "1", "2", "4", "8", "16", "32", "64", "128", "256", "512", "1024", "2048", "4096", "8192", "16384", "32768" };
+
+ int i;
+ for (i = 0 ; i < G_N_ELEMENTS(itemLabels) ; i++)
+ {
+ GtkWidget *item = gtk_menu_item_new_with_label (itemLabels[i]);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+ gtk_widget_show (item);
+ g_object_set_data (G_OBJECT (item), "position", GINT_TO_POINTER(i));
+ }
+
+ gint active = 5 + round ( log (mpp) / log (2) );
+ // Ensure value derived from mpp is in bounds of the menu
+ if ( active >= G_N_ELEMENTS(itemLabels) )
+ active = G_N_ELEMENTS(itemLabels) - 1;
+ if ( active < 0 )
+ active = 0;
+ gtk_menu_set_active ( GTK_MENU(menu), active );
+
+ return menu;
+}
+
+static GtkWidget *create_zoom_combo_all_levels ()
+{
+ GtkWidget *combo = vik_combo_box_text_new();
+ vik_combo_box_text_append ( combo, "0.25");
+ vik_combo_box_text_append ( combo, "0.5");
+ vik_combo_box_text_append ( combo, "1");
+ vik_combo_box_text_append ( combo, "2");
+ vik_combo_box_text_append ( combo, "4");
+ vik_combo_box_text_append ( combo, "8");
+ vik_combo_box_text_append ( combo, "16");
+ vik_combo_box_text_append ( combo, "32");
+ vik_combo_box_text_append ( combo, "64");
+ vik_combo_box_text_append ( combo, "128");
+ vik_combo_box_text_append ( combo, "256");
+ vik_combo_box_text_append ( combo, "512");
+ vik_combo_box_text_append ( combo, "1024");
+ vik_combo_box_text_append ( combo, "2048");
+ vik_combo_box_text_append ( combo, "4096");
+ vik_combo_box_text_append ( combo, "8192");
+ vik_combo_box_text_append ( combo, "16384");
+ vik_combo_box_text_append ( combo, "32768");
+ /* Create tooltip */
+ gtk_widget_set_tooltip_text (combo, _("Select zoom level"));
+ return combo;
+}
+
+static gint zoom_popup_handler (GtkWidget *widget)
+{
+ GtkMenu *menu;
+
+ g_return_val_if_fail (widget != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_MENU (widget), FALSE);
+
+ /* The "widget" is the menu that was supplied when
+ * g_signal_connect_swapped() was called.
+ */
+ menu = GTK_MENU (widget);
+
+ gtk_menu_popup (menu, NULL, NULL, NULL, NULL,
+ 1, gtk_get_current_event_time());
+ 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 );
+}
+
+static void toolbar_tool_cb ( GtkAction *old, GtkAction *current, gpointer gp )
+{
+ VikWindow *vw = (VikWindow*)gp;
+ GtkAction *action = gtk_action_group_get_action ( vw->action_group, gtk_action_get_name(current) );
+ if ( action )
+ gtk_action_activate ( action );
+}
+static void toolbar_reload_cb ( GtkActionGroup *grp, gpointer gp )
+{
+ VikWindow *vw = (VikWindow*)gp;
+ center_changed_cb ( vw );
+}
+
+#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_PANE_POSITION "window_horizontal_pane_position"
+#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"
+#define VIK_SETTINGS_WIN_COPY_CENTRE_FULL_FORMAT "window_copy_centre_full_format"
+
+#define VIKING_ACCELERATOR_KEY_FILE "keys.rc"
+
+static void vik_window_init ( VikWindow *vw )
+{
vw->action_group = NULL;
vw->viking_vvp = vik_viewport_new();
vw->viking_vs = vik_statusbar_new();
vw->vt = toolbox_create(vw);
+ vw->viking_vtb = vik_toolbar_new ();
window_create_ui(vw);
window_set_filename (vw, NULL);
- vw->toolbar = GTK_TOOLBAR(gtk_ui_manager_get_widget (vw->uim, "/MainToolbar"));
- // Set the default tool
- gtk_action_activate ( gtk_action_group_get_action ( vw->action_group, "Pan" ) );
+ vw->busy_cursor = gdk_cursor_new ( GDK_WATCH );
vw->filename = NULL;
- vw->item_factory = NULL;
-
+ vw->loaded_type = LOAD_TYPE_READ_FAILURE; //AKA none
vw->modified = FALSE;
vw->only_updating_coord_mode_ui = FALSE;
-
+
+ vw->select_move = 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;
- main_vbox = gtk_vbox_new(FALSE, 1);
- gtk_container_add (GTK_CONTAINER (vw), main_vbox);
+ 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;
+
+ vw->main_vbox = gtk_vbox_new(FALSE, 1);
+ gtk_container_add (GTK_CONTAINER (vw), vw->main_vbox);
+ vw->menu_hbox = gtk_hbox_new(FALSE, 1);
+ GtkWidget *menu_bar = gtk_ui_manager_get_widget (vw->uim, "/MainMenu");
+ gtk_box_pack_start (GTK_BOX(vw->menu_hbox), menu_bar, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX(vw->main_vbox), vw->menu_hbox, FALSE, TRUE, 0);
+
+ toolbar_init(vw->viking_vtb,
+ &vw->gtkwindow,
+ vw->main_vbox,
+ vw->menu_hbox,
+ toolbar_tool_cb,
+ toolbar_reload_cb,
+ (gpointer)vw); // This auto packs toolbar into the vbox
+ // Must be performed post toolbar init
+ gint i,j;
+ for (i=0; i<VIK_LAYER_NUM_TYPES; i++) {
+ for ( j = 0; j < vik_layer_get_interface(i)->tools_count; j++ ) {
+ toolbar_action_set_sensitive ( vw->viking_vtb, vik_layer_get_interface(i)->tools[j].radioActionEntry.name, FALSE );
+ }
+ }
- gtk_box_pack_start (GTK_BOX(main_vbox), gtk_ui_manager_get_widget (vw->uim, "/MainMenu"), FALSE, TRUE, 0);
- gtk_box_pack_start (GTK_BOX(main_vbox), GTK_WIDGET(vw->toolbar), FALSE, TRUE, 0);
- 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 );
- vik_ext_tools_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(zoom_levels_menu), "selection-done", G_CALLBACK(zoom_changed), vw);
+ g_signal_connect_swapped ( G_OBJECT(vw->viking_vs), "clicked", G_CALLBACK(zoom_popup_handler), 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);
- g_signal_connect_swapped (G_OBJECT (vw->viking_vvp), "key_press_event", G_CALLBACK (key_press_event), 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 );
- gtk_paned_pack2 ( GTK_PANED(hpaned), GTK_WIDGET (vw->viking_vvp), TRUE, TRUE );
+ vw->hpaned = gtk_hpaned_new ();
+ gtk_paned_pack1 ( GTK_PANED(vw->hpaned), GTK_WIDGET (vw->viking_vlp), FALSE, TRUE );
+ gtk_paned_pack2 ( GTK_PANED(vw->hpaned), GTK_WIDGET (vw->viking_vvp), TRUE, TRUE );
/* This packs the button into the window (a gtk container). */
- gtk_box_pack_start (GTK_BOX(main_vbox), hpaned, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX(vw->main_vbox), vw->hpaned, TRUE, TRUE, 0);
- gtk_box_pack_end (GTK_BOX(main_vbox), GTK_WIDGET(vw->viking_vs), FALSE, TRUE, 0);
+ gtk_box_pack_end (GTK_BOX(vw->main_vbox), GTK_WIDGET(vw->viking_vs), FALSE, TRUE, 0);
a_background_add_window ( vw );
- vw->open_dia = NULL;
- vw->save_dia = NULL;
- vw->save_img_dia = NULL;
- vw->save_img_dir_dia = NULL;
+ 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 ) {
+ vw->show_full_screen = TRUE;
+ gtk_window_fullscreen ( GTK_WINDOW(vw) );
+ GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/FullScreen" );
+ if ( check_box )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), TRUE );
+ }
+ }
+
+ gint position = -1; // Let GTK determine default positioning
+ if ( !a_settings_get_integer ( VIK_SETTINGS_WIN_PANE_POSITION, &position ) ) {
+ position = -1;
+ }
+ gtk_paned_set_position ( GTK_PANED(vw->hpaned), position );
+ }
+
+ gtk_window_set_default_size ( GTK_WINDOW(vw), width, height );
+
+ vw->show_side_panel = TRUE;
+ vw->show_statusbar = TRUE;
+ vw->show_toolbar = TRUE;
+ vw->show_main_menu = TRUE;
+
+ // 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]
+ vw->thread = g_thread_self();
+
+ // Set the default tool + mode
+ gtk_action_activate ( gtk_action_group_get_action ( vw->action_group, "Pan" ) );
+ gtk_action_activate ( gtk_action_group_get_action ( vw->action_group, "ModeMercator" ) );
+
+ gchar *accel_file_name = g_build_filename ( a_get_viking_dir(), VIKING_ACCELERATOR_KEY_FILE, NULL );
+ gtk_accel_map_load ( accel_file_name );
+ g_free ( accel_file_name );
}
static VikWindow *window_new ()
return VIK_WINDOW ( g_object_new ( VIK_WINDOW_TYPE, NULL ) );
}
+/**
+ * Update the displayed map
+ * Only update the top most visible map layer
+ * ATM this assumes (as per defaults) the top most map has full alpha setting
+ * such that other other maps even though they may be active will not be seen
+ * It's more complicated to work out which maps are actually visible due to alpha settings
+ * and overkill for this simple refresh method.
+ */
+static void simple_map_update ( VikWindow *vw, gboolean only_new )
+{
+ // Find the most relevent single map layer to operate on
+ VikLayer *vl = vik_aggregate_layer_get_top_visible_layer_of_type (vik_layers_panel_get_top_layer(vw->viking_vlp), VIK_LAYER_MAPS);
+ if ( vl )
+ vik_maps_layer_download ( VIK_MAPS_LAYER(vl), vw->viking_vvp, only_new );
+}
+
+/**
+ * This is the global key press handler
+ * Global shortcuts are available at any time and hence are not restricted to when a certain tool is enabled
+ */
static gboolean key_press_event( VikWindow *vw, GdkEventKey *event, gpointer data )
{
+ // The keys handled here are not in the menuing system for a couple of reasons:
+ // . Keeps the menu size compact (alebit at expense of discoverably)
+ // . Allows differing key bindings to perform the same actions
+
+ // First decide if key events are related to the maps layer
+ gboolean map_download = FALSE;
+ gboolean map_download_only_new = TRUE; // Only new or reload
+
+ GdkModifierType modifiers = gtk_accelerator_get_default_mod_mask();
+
+ // Standard 'Refresh' keys: F5 or Ctrl+r
+ // Note 'F5' is actually handled via draw_refresh_cb() later on
+ // (not 'R' it's 'r' notice the case difference!!)
+ if ( event->keyval == GDK_r && (event->state & modifiers) == GDK_CONTROL_MASK ) {
+ map_download = TRUE;
+ map_download_only_new = TRUE;
+ }
+ // Full cache reload with Ctrl+F5 or Ctrl+Shift+r [This is not in the menu system]
+ // Note the use of uppercase R here since shift key has been pressed
+ else if ( (event->keyval == GDK_F5 && (event->state & modifiers) == GDK_CONTROL_MASK ) ||
+ ( event->keyval == GDK_R && (event->state & modifiers) == (GDK_CONTROL_MASK + GDK_SHIFT_MASK) ) ) {
+ map_download = TRUE;
+ map_download_only_new = FALSE;
+ }
+ // Standard Ctrl+KP+ / Ctrl+KP- to zoom in/out respectively
+ else if ( event->keyval == GDK_KEY_KP_Add && (event->state & modifiers) == GDK_CONTROL_MASK ) {
+ vik_viewport_zoom_in ( vw->viking_vvp );
+ draw_update(vw);
+ return TRUE; // handled keypress
+ }
+ else if ( event->keyval == GDK_KEY_KP_Subtract && (event->state & modifiers) == GDK_CONTROL_MASK ) {
+ vik_viewport_zoom_out ( vw->viking_vvp );
+ draw_update(vw);
+ return TRUE; // handled keypress
+ }
+
+ if ( map_download ) {
+ simple_map_update ( vw, map_download_only_new );
+ return TRUE; // handled keypress
+ }
+
VikLayer *vl = vik_layers_panel_get_selected ( vw->viking_vlp );
if (vl && vw->vt->active_tool != -1 && vw->vt->tools[vw->vt->active_tool].ti.key_press ) {
gint ltype = vw->vt->tools[vw->vt->active_tool].layer_type;
return vw->vt->tools[vw->vt->active_tool].ti.key_press(vl, event, vw->vt->tools[vw->vt->active_tool].state);
}
- // No layer - but enable window tool keypress processing - these should be able to handle a NULL layer
- if ( vw->vt->tools[vw->vt->active_tool].ti.key_press ) {
- return vw->vt->tools[vw->vt->active_tool].ti.key_press ( vl, event, vw->vt->tools[vw->vt->active_tool].state );
+ // Ensure called only on window tools (i.e. not on any of the Layer tools since the layer is NULL)
+ if ( vw->current_tool < TOOL_LAYER ) {
+ // No layer - but enable window tool keypress processing - these should be able to handle a NULL layer
+ if ( vw->vt->tools[vw->vt->active_tool].ti.key_press ) {
+ return vw->vt->tools[vw->vt->active_tool].ti.key_press ( vl, event, vw->vt->tools[vw->vt->active_tool].state );
+ }
}
/* Restore Main Menu via Escape key if the user has hidden it */
_("Do you want to save the changes you made to the document \"%s\"?\n"
"\n"
"Your changes will be lost if you don't save them."),
- vw->filename ? a_file_basename ( vw->filename ) : _("Untitled") ) );
+ window_get_filename ( vw ) ) );
gtk_dialog_add_buttons ( dia, _("Don't Save"), GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_YES, NULL );
switch ( gtk_dialog_run ( dia ) )
{
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 (toolbar_get_widget(vw->viking_vtb)) );
+
+ // 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_PANE_POSITION, gtk_paned_get_position (GTK_PANED(vw->hpaned)) );
+ }
+
+ 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 );
+
+ gchar *accel_file_name = g_build_filename ( a_get_viking_dir(), VIKING_ACCELERATOR_KEY_FILE, NULL );
+ gtk_accel_map_save ( accel_file_name );
+ g_free ( accel_file_name );
+ }
+
return FALSE;
}
{
vik_viewport_sync(vw->viking_vvp);
draw_status ( vw );
- /* other things may be necc here later. */
+}
+
+/*
+ * Split the status update, as sometimes only need to update the tool part
+ * also on initialization the zoom related stuff is not ready to be used
+ */
+static void draw_status_tool ( VikWindow *vw )
+{
+ if ( vw->current_tool == TOOL_LAYER )
+ // Use tooltip rather than the internal name as the tooltip is i8n
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_TOOL, vik_layer_get_interface(vw->tool_layer_id)->tools[vw->tool_tool_id].radioActionEntry.tooltip );
+ else
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_TOOL, _(tool_names[vw->current_tool]) );
}
static void draw_status ( VikWindow *vw )
else
/* xmpp should be a whole number so don't show useless .000 bit */
g_snprintf ( zoom_level, 22, "%d %s", (int)xmpp, unit );
- if ( vw->current_tool == TOOL_LAYER )
- // Use tooltip rather than the internal name as the tooltip is i8n
- vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_TOOL, vik_layer_get_interface(vw->tool_layer_id)->tools[vw->tool_tool_id].radioActionEntry.tooltip );
- else
- vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_TOOL, _(tool_names[vw->current_tool]) );
vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_ZOOM, zoom_level );
+
+ draw_status_tool ( vw );
}
void vik_window_set_redraw_trigger(VikLayer *vl)
if (first) {
// This is a hack to set the cursor corresponding to the first tool
// FIXME find the correct way to initialize both tool and its cursor
- const GdkCursor *cursor = NULL;
first = 0;
- cursor = toolbox_get_cursor(vw->vt, "Pan");
+ vw->viewport_cursor = (GdkCursor *)toolbox_get_cursor(vw->vt, "Pan");
/* We set cursor, even if it is NULL: it resets to default */
- gdk_window_set_cursor ( GTK_WIDGET(vw->viking_vvp)->window, (GdkCursor *)cursor );
+ gdk_window_set_cursor ( gtk_widget_get_window(GTK_WIDGET(vw->viking_vvp)), vw->viewport_cursor );
}
}
/* 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 );
static gboolean draw_buf(gpointer data)
{
gpointer *pass_along = data;
- gdk_threads_enter();
gdk_draw_drawable (pass_along[0], pass_along[1],
pass_along[2], 0, 0, 0, 0, -1, -1);
draw_buf_done = TRUE;
- gdk_threads_leave();
return FALSE;
}
}
}
+/**
+ * get_location_strings:
+ *
+ * Utility function to get positional strings for the given location
+ * lat and lon strings will get allocated and so need to be freed after use
+ */
+static void get_location_strings ( VikWindow *vw, struct UTM utm, gchar **lat, gchar **lon )
+{
+ if ( vik_viewport_get_drawmode ( vw->viking_vvp ) == VIK_VIEWPORT_DRAWMODE_UTM ) {
+ // Reuse lat for the first part (Zone + N or S, and lon for the second part (easting and northing) of a UTM format:
+ // ZONE[N|S] EASTING NORTHING
+ *lat = g_malloc(4*sizeof(gchar));
+ // NB zone is stored in a char but is an actual number
+ g_snprintf (*lat, 4, "%d%c", utm.zone, utm.letter);
+ *lon = g_malloc(16*sizeof(gchar));
+ g_snprintf (*lon, 16, "%d %d", (gint)utm.easting, (gint)utm.northing);
+ }
+ else {
+ struct LatLon ll;
+ a_coords_utm_to_latlon ( &utm, &ll );
+ a_coords_latlon_to_string ( &ll, lat, lon );
+ }
+}
+
static void draw_mouse_motion (VikWindow *vw, GdkEventMotion *event)
{
static VikCoord coord;
static struct UTM utm;
- static struct LatLon ll;
#define BUFFER_SIZE 50
static char pointer_buf[BUFFER_SIZE];
gchar *lat = NULL, *lon = NULL;
vik_viewport_screen_to_coord ( vw->viking_vvp, event->x, event->y, &coord );
vik_coord_to_utm ( &coord, &utm );
- a_coords_utm_to_latlon ( &utm, &ll );
- a_coords_latlon_to_string ( &ll, &lat, &lon );
+
+ get_location_strings ( vw, utm, &lat, &lon );
+
/* Change interpolate method according to scale */
zoom = vik_viewport_get_zoom(vw->viking_vvp);
if (zoom > 2.0)
/* 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 = { 0 }; // = G_VALUE_INIT; // GLIB 2.30+ only
+ 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 )
********************************************************************************/
static void draw_ruler(VikViewport *vvp, GdkDrawable *d, GdkGC *gc, gint x1, gint y1, gint x2, gint y2, gdouble distance)
{
- PangoFontDescription *pfd;
PangoLayout *pl;
gchar str[128];
GdkGC *labgc = vik_viewport_new_gc ( vvp, "#cccccc", 1);
gdouble len = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
gdouble dx = (x2-x1)/len*10;
gdouble dy = (y2-y1)/len*10;
- gdouble c = cos(15.0 * M_PI/180.0);
- gdouble s = sin(15.0 * M_PI/180.0);
+ gdouble c = cos(DEG2RAD(15.0));
+ gdouble s = sin(DEG2RAD(15.0));
gdouble angle;
gdouble baseangle = 0;
gint i;
/* draw compass */
#define CR 80
#define CW 4
- angle = atan2(dy, dx) + M_PI_2;
-
- if ( vik_viewport_get_drawmode ( vvp ) == VIK_VIEWPORT_DRAWMODE_UTM) {
- VikCoord test;
- struct LatLon ll;
- struct UTM u;
- gint tx, ty;
-
- vik_viewport_screen_to_coord ( vvp, x1, y1, &test );
- vik_coord_to_latlon ( &test, &ll );
- ll.lat += vik_viewport_get_ympp ( vvp ) * vik_viewport_get_height ( vvp ) / 11000.0; // about 11km per degree latitude
- a_coords_latlon_to_utm ( &ll, &u );
- vik_coord_load_from_utm ( &test, VIK_VIEWPORT_DRAWMODE_UTM, &u );
- vik_viewport_coord_to_screen ( vvp, &test, &tx, &ty );
-
- baseangle = M_PI - atan2(tx-x1, ty-y1);
- angle -= baseangle;
- }
- if (angle<0)
- angle+=2*M_PI;
- if (angle>2*M_PI)
- angle-=2*M_PI;
+ vik_viewport_compute_bearing ( vvp, x1, y1, x2, y2, &angle, &baseangle );
{
GdkColor color;
gdk_color_parse("#2255cc", &color);
gdk_gc_set_rgb_fg_color(thickgc, &color);
}
- gdk_draw_arc (d, thickgc, FALSE, x1-CR+CW/2, y1-CR+CW/2, 2*CR-CW, 2*CR-CW, (90 - baseangle*180/M_PI)*64, -angle*180/M_PI*64);
+ gdk_draw_arc (d, thickgc, FALSE, x1-CR+CW/2, y1-CR+CW/2, 2*CR-CW, 2*CR-CW, (90 - RAD2DEG(baseangle))*64, -RAD2DEG(angle)*64);
gdk_gc_copy(thickgc, gc);
gdk_gc_set_line_attributes(thickgc, 2, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);
for (i=0; i<180; i++) {
- c = cos(i*M_PI/90.0 + baseangle);
- s = sin(i*M_PI/90.0 + baseangle);
+ c = cos(DEG2RAD(i)*2 + baseangle);
+ s = sin(DEG2RAD(i)*2 + baseangle);
if (i%5) {
gdk_draw_line (d, gc, x1 + CR*c, y1 + CR*s, x1 + (CR+CW)*c, y1 + (CR+CW)*s);
gint wb, hb, xb, yb;
pl = gtk_widget_create_pango_layout (GTK_WIDGET(vvp), NULL);
-
- pfd = pango_font_description_from_string ("Sans 8"); // FIXME: settable option? global variable?
- pango_layout_set_font_description (pl, pfd);
- pango_font_description_free (pfd);
-
+ pango_layout_set_font_description (pl, gtk_widget_get_style(GTK_WIDGET(vvp))->font_desc);
pango_layout_set_text(pl, "N", -1);
gdk_draw_layout(d, gc, x1-5, y1-CR-3*CW-8, pl);
switch (dist_units) {
case VIK_UNITS_DISTANCE_KILOMETRES:
if (distance >= 1000 && distance < 100000) {
- g_sprintf(str, "%3.2f km", distance/1000.0);
+ g_sprintf(str, "%3.2f km", distance/1000.0);
} else if (distance < 1000) {
- g_sprintf(str, "%d m", (int)distance);
+ g_sprintf(str, "%d m", (int)distance);
} else {
- g_sprintf(str, "%d km", (int)distance/1000);
+ g_sprintf(str, "%d km", (int)distance/1000);
}
break;
case VIK_UNITS_DISTANCE_MILES:
if (distance >= VIK_MILES_TO_METERS(1) && distance < VIK_MILES_TO_METERS(100)) {
- g_sprintf(str, "%3.2f miles", VIK_METERS_TO_MILES(distance));
+ g_sprintf(str, "%3.2f miles", VIK_METERS_TO_MILES(distance));
} else if (distance < VIK_MILES_TO_METERS(1)) {
- g_sprintf(str, "%d yards", (int)(distance*1.0936133));
+ g_sprintf(str, "%d yards", (int)(distance*1.0936133));
+ } else {
+ g_sprintf(str, "%d miles", (int)VIK_METERS_TO_MILES(distance));
+ }
+ break;
+ case VIK_UNITS_DISTANCE_NAUTICAL_MILES:
+ if (distance >= VIK_NAUTICAL_MILES_TO_METERS(1) && distance < VIK_NAUTICAL_MILES_TO_METERS(100)) {
+ g_sprintf(str, "%3.2f NM", VIK_METERS_TO_NAUTICAL_MILES(distance));
+ } else if (distance < VIK_NAUTICAL_MILES_TO_METERS(1)) {
+ g_sprintf(str, "%d yards", (int)(distance*1.0936133));
} else {
- g_sprintf(str, "%d miles", (int)VIK_METERS_TO_MILES(distance));
+ g_sprintf(str, "%d NM", (int)VIK_METERS_TO_NAUTICAL_MILES(distance));
}
break;
default:
LABEL(xd, yd, wd, hd);
/* draw label with bearing */
- g_sprintf(str, "%3.1f°", angle*180.0/M_PI);
+ g_sprintf(str, "%3.1f°", RAD2DEG(angle));
pango_layout_set_text(pl, str, -1);
pango_layout_get_pixel_size ( pl, &wb, &hb );
xb = x1 + CR*cos(angle-M_PI_2);
vik_units_distance_t dist_units = a_vik_get_units_distance ();
switch (dist_units) {
case VIK_UNITS_DISTANCE_KILOMETRES:
- temp = g_strdup_printf ( "%s %s DIFF %f meters", lat, lon, vik_coord_diff( &coord, &(s->oldcoord) ) );
- break;
+ temp = g_strdup_printf ( "%s %s DIFF %f meters", lat, lon, vik_coord_diff( &coord, &(s->oldcoord) ) );
+ break;
case VIK_UNITS_DISTANCE_MILES:
- temp = g_strdup_printf ( "%s %s DIFF %f miles", lat, lon, VIK_METERS_TO_MILES(vik_coord_diff( &coord, &(s->oldcoord) )) );
- break;
+ temp = g_strdup_printf ( "%s %s DIFF %f miles", lat, lon, VIK_METERS_TO_MILES(vik_coord_diff( &coord, &(s->oldcoord) )) );
+ break;
+ case VIK_UNITS_DISTANCE_NAUTICAL_MILES:
+ temp = g_strdup_printf ( "%s %s DIFF %f NM", lat, lon, VIK_METERS_TO_NAUTICAL_MILES(vik_coord_diff( &coord, &(s->oldcoord) )) );
+ break;
default:
- temp = g_strdup_printf ("Just to keep the compiler happy");
- g_critical("Houston, we've had a problem. distance=%d", dist_units);
+ temp = g_strdup_printf ("Just to keep the compiler happy");
+ g_critical("Houston, we've had a problem. distance=%d", dist_units);
}
s->has_oldcoord = FALSE;
w1 = vik_viewport_get_width(vvp);
h1 = vik_viewport_get_height(vvp);
if (!buf) {
- buf = gdk_pixmap_new ( GTK_WIDGET(vvp)->window, w1, h1, -1 );
+ buf = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), w1, h1, -1 );
}
gdk_drawable_get_size(buf, &w2, &h2);
if (w1 != w2 || h1 != h2) {
g_object_unref ( G_OBJECT ( buf ) );
- buf = gdk_pixmap_new ( GTK_WIDGET(vvp)->window, w1, h1, -1 );
+ buf = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), w1, h1, -1 );
}
vik_viewport_screen_to_coord ( vvp, (gint) event->x, (gint) event->y, &coord );
vik_coord_to_latlon ( &coord, &ll );
vik_viewport_coord_to_screen ( vvp, &s->oldcoord, &oldx, &oldy );
- gdk_draw_drawable (buf, GTK_WIDGET(vvp)->style->black_gc,
+ gdk_draw_drawable (buf, gtk_widget_get_style(GTK_WIDGET(vvp))->black_gc,
vik_viewport_get_pixmap(vvp), 0, 0, 0, 0, -1, -1);
- draw_ruler(vvp, buf, GTK_WIDGET(vvp)->style->black_gc, oldx, oldy, event->x, event->y, vik_coord_diff( &coord, &(s->oldcoord)) );
+ draw_ruler(vvp, buf, gtk_widget_get_style(GTK_WIDGET(vvp))->black_gc, oldx, oldy, event->x, event->y, vik_coord_diff( &coord, &(s->oldcoord)) );
if (draw_buf_done) {
static gpointer pass_along[3];
- pass_along[0] = GTK_WIDGET(vvp)->window;
- pass_along[1] = GTK_WIDGET(vvp)->style->black_gc;
+ pass_along[0] = gtk_widget_get_window(GTK_WIDGET(vvp));
+ pass_along[1] = gtk_widget_get_style(GTK_WIDGET(vvp))->black_gc;
pass_along[2] = buf;
g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, draw_buf, pass_along, NULL);
draw_buf_done = FALSE;
case VIK_UNITS_DISTANCE_MILES:
temp = g_strdup_printf ( "%s %s DIFF %f miles", lat, lon, VIK_METERS_TO_MILES (vik_coord_diff( &coord, &(s->oldcoord) )) );
break;
+ case VIK_UNITS_DISTANCE_NAUTICAL_MILES:
+ temp = g_strdup_printf ( "%s %s DIFF %f NM", lat, lon, VIK_METERS_TO_NAUTICAL_MILES (vik_coord_diff( &coord, &(s->oldcoord) )) );
+ break;
default:
temp = g_strdup_printf ("Just to keep the compiler happy");
g_critical("Houston, we've had a problem. distance=%d", dist_units);
ruler_deactivate ( vl, s );
return TRUE;
}
+ // Regardless of whether we used it, return false so other GTK things may use it
return FALSE;
}
-static VikToolInterface ruler_tool =
- { { "Ruler", "vik-icon-ruler", N_("_Ruler"), "<control><shift>R", N_("Ruler Tool"), 2 },
+static VikToolInterface ruler_tool =
+ // NB Ctrl+Shift+R is used for Refresh (deemed more important), so use 'U' instead
+ { { "Ruler", "vik-icon-ruler", N_("_Ruler"), "<control><shift>U", N_("Ruler Tool"), 2 },
(VikToolConstructorFunc) ruler_create,
(VikToolDestructorFunc) ruler_destroy,
(VikToolActivationFunc) NULL,
(VikToolKeyFunc) ruler_key_press,
FALSE,
GDK_CURSOR_IS_PIXMAP,
- &cursor_ruler_pixbuf };
+ &cursor_ruler_pixbuf,
+ NULL };
/*** end ruler code ********************************************************/
if ( !zts->pixmap ) {
// Totally new
- zts->pixmap = gdk_pixmap_new ( GTK_WIDGET(zts->vw->viking_vvp)->window, w1, h1, -1 );
+ zts->pixmap = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(zts->vw->viking_vvp)), w1, h1, -1 );
}
gdk_drawable_get_size ( zts->pixmap, &w2, &h2 );
if ( w1 != w2 || h1 != h2 ) {
// Has changed - delete and recreate with new values
g_object_unref ( G_OBJECT ( zts->pixmap ) );
- zts->pixmap = gdk_pixmap_new ( GTK_WIDGET(zts->vw->viking_vvp)->window, w1, h1, -1 );
+ zts->pixmap = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(zts->vw->viking_vvp)), w1, h1, -1 );
}
}
// Blank out currently drawn area
gdk_draw_drawable ( zts->pixmap,
- GTK_WIDGET(zts->vw->viking_vvp)->style->black_gc,
+ gtk_widget_get_style(GTK_WIDGET(zts->vw->viking_vvp))->black_gc,
vik_viewport_get_pixmap(zts->vw->viking_vvp),
0, 0, 0, 0, -1, -1);
}
// Draw the box
- gdk_draw_rectangle (zts->pixmap, GTK_WIDGET(zts->vw->viking_vvp)->style->black_gc, FALSE, xx, yy, width, height);
+ gdk_draw_rectangle (zts->pixmap, gtk_widget_get_style(GTK_WIDGET(zts->vw->viking_vvp))->black_gc, FALSE, xx, yy, width, height);
// Only actually draw when there's time to do so
if (draw_buf_done) {
static gpointer pass_along[3];
- pass_along[0] = GTK_WIDGET(zts->vw->viking_vvp)->window;
- pass_along[1] = GTK_WIDGET(zts->vw->viking_vvp)->style->black_gc;
+ pass_along[0] = gtk_widget_get_window(GTK_WIDGET(zts->vw->viking_vvp));
+ pass_along[1] = gtk_widget_get_style(GTK_WIDGET(zts->vw->viking_vvp))->black_gc;
pass_along[2] = zts->pixmap;
g_idle_add_full (G_PRIORITY_HIGH_IDLE + 10, draw_buf, pass_along, NULL);
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 ********************************************************/
/********************************************************************************
ck->cont = !vik_layer_get_interface(vl->type)->select_click ( vl, ck->event, ck->vvp, ck->tool_edit );
}
+#ifdef WINDOWS
+// Hopefully Alt keys by default
+#define VIK_MOVE_MODIFIER GDK_MOD1_MASK
+#else
+// Alt+mouse on Linux desktops tend to be used by the desktop manager
+// Thus use an alternate modifier - you may need to set something into this group
+#define VIK_MOVE_MODIFIER GDK_MOD5_MASK
+#endif
+
static VikLayerToolFuncStatus selecttool_click (VikLayer *vl, GdkEventButton *event, tool_ed_t *t)
{
+ t->vw->select_move = FALSE;
/* Only allow selection on primary button */
if ( event->button == 1 ) {
- /* Enable click to apply callback to potentially all track/waypoint layers */
- /* Useful as we can find things that aren't necessarily in the currently selected layer */
- GList* gl = vik_layers_panel_get_all_layers_of_type ( t->vw->viking_vlp, VIK_LAYER_TRW, FALSE ); // Don't get invisible layers
- clicker ck;
- ck.cont = TRUE;
- ck.vvp = t->vw->viking_vvp;
- ck.event = event;
- ck.tool_edit = t;
- g_list_foreach ( gl, (GFunc) click_layer_selected, &ck );
- g_list_free ( gl );
-
- // If nothing found then deselect & redraw screen if necessary to remove the highlight
- if ( ck.cont ) {
- GtkTreeIter iter;
- VikTreeview *vtv = vik_layers_panel_get_treeview ( t->vw->viking_vlp );
-
- if ( vik_treeview_get_selected_iter ( vtv, &iter ) ) {
- // Only clear if selected thing is a TrackWaypoint layer or a sublayer
- gint type = vik_treeview_item_get_type ( vtv, &iter );
- if ( type == VIK_TREEVIEW_TYPE_SUBLAYER ||
- VIK_LAYER(vik_treeview_item_get_pointer ( vtv, &iter ))->type == VIK_LAYER_TRW ) {
+
+ if ( event->state & VIK_MOVE_MODIFIER )
+ vik_window_pan_click ( t->vw, event );
+ else {
+ /* Enable click to apply callback to potentially all track/waypoint layers */
+ /* Useful as we can find things that aren't necessarily in the currently selected layer */
+ GList* gl = vik_layers_panel_get_all_layers_of_type ( t->vw->viking_vlp, VIK_LAYER_TRW, FALSE ); // Don't get invisible layers
+ clicker ck;
+ ck.cont = TRUE;
+ ck.vvp = t->vw->viking_vvp;
+ ck.event = event;
+ ck.tool_edit = t;
+ g_list_foreach ( gl, (GFunc) click_layer_selected, &ck );
+ g_list_free ( gl );
+
+ // If nothing found then deselect & redraw screen if necessary to remove the highlight
+ if ( ck.cont ) {
+ GtkTreeIter iter;
+ VikTreeview *vtv = vik_layers_panel_get_treeview ( t->vw->viking_vlp );
+
+ if ( vik_treeview_get_selected_iter ( vtv, &iter ) ) {
+ // Only clear if selected thing is a TrackWaypoint layer or a sublayer
+ gint type = vik_treeview_item_get_type ( vtv, &iter );
+ if ( type == VIK_TREEVIEW_TYPE_SUBLAYER ||
+ VIK_LAYER(vik_treeview_item_get_pointer ( vtv, &iter ))->type == VIK_LAYER_TRW ) {
- vik_treeview_item_unselect ( vtv, &iter );
- if ( vik_window_clear_highlight ( t->vw ) )
- draw_update ( t->vw );
- }
+ vik_treeview_item_unselect ( vtv, &iter );
+ if ( vik_window_clear_highlight ( t->vw ) )
+ draw_update ( t->vw );
+ }
+ }
+ }
+ else {
+ // Something found - so enable movement
+ t->vw->select_move = TRUE;
}
}
}
return VIK_LAYER_TOOL_ACK;
}
-static VikLayerToolFuncStatus selecttool_move (VikLayer *vl, GdkEventButton *event, tool_ed_t *t)
+static VikLayerToolFuncStatus selecttool_move (VikLayer *vl, GdkEventMotion *event, tool_ed_t *t)
{
- /* Only allow selection on primary button */
- if ( event->button == 1 ) {
+ if ( t->vw->select_move ) {
// Don't care about vl here
if ( t->vtl )
if ( vik_layer_get_interface(VIK_LAYER_TRW)->select_move )
- vik_layer_get_interface(VIK_LAYER_TRW)->select_move ( vl, event, t->vvp, t );
+ vik_layer_get_interface(VIK_LAYER_TRW)->select_move ( vl, event, t->vvp, t );
}
+ else
+ // Optional Panning
+ if ( event->state & VIK_MOVE_MODIFIER )
+ vik_window_pan_move ( t->vw, event );
+
return VIK_LAYER_TOOL_ACK;
}
static VikLayerToolFuncStatus selecttool_release (VikLayer *vl, GdkEventButton *event, tool_ed_t *t)
{
- /* Only allow selection on primary button */
- if ( event->button == 1 ) {
+ if ( t->vw->select_move ) {
// Don't care about vl here
if ( t->vtl )
if ( vik_layer_get_interface(VIK_LAYER_TRW)->select_release )
- vik_layer_get_interface(VIK_LAYER_TRW)->select_release ( (VikLayer*)t->vtl, event, t->vvp, t );
+ vik_layer_get_interface(VIK_LAYER_TRW)->select_release ( (VikLayer*)t->vtl, event, t->vvp, t );
}
+
+ if ( event->button == 1 && (event->state & VIK_MOVE_MODIFIER) )
+ vik_window_pan_release ( t->vw, event );
+
+ // Force pan off incase it was on
+ t->vw->pan_move = FALSE;
+ t->vw->pan_x = t->vw->pan_y = -1;
+
+ // End of this select movement
+ t->vw->select_move = FALSE;
+
return VIK_LAYER_TOOL_ACK;
}
static void draw_pan_cb ( GtkAction *a, VikWindow *vw )
{
+ // Since the treeview cell editting intercepts standard keyboard handlers, it means we can receive events here
+ // Thus if currently editting, ensure we don't move the viewport when Ctrl+<arrow> is received
+ VikLayer *sel = vik_layers_panel_get_selected ( vw->viking_vlp );
+ if ( sel && vik_treeview_get_editing ( sel->vt ) )
+ return;
+
if (!strcmp(gtk_action_get_name(a), "PanNorth")) {
vik_viewport_set_center_screen ( vw->viking_vvp, vik_viewport_get_width(vw->viking_vvp)/2, 0 );
} else if (!strcmp(gtk_action_get_name(a), "PanEast")) {
draw_update ( vw );
}
-static void full_screen_cb ( GtkAction *a, VikWindow *vw )
-{
- GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/FullScreen" );
- g_assert(check_box);
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box));
- if ( state )
- gtk_window_fullscreen ( GTK_WINDOW(vw) );
- else
- gtk_window_unfullscreen ( GTK_WINDOW(vw) );
-}
-
static void draw_zoom_cb ( GtkAction *a, VikWindow *vw )
{
guint what = 128;
draw_update ( vw );
}
-void draw_goto_cb ( GtkAction *a, VikWindow *vw )
+static void draw_goto_cb ( GtkAction *a, VikWindow *vw )
{
VikCoord new_center;
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) );
+ }
+
+ toolbar_action_set_sensitive ( vw->viking_vtb, "GoForward", 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
+ */
+static void draw_refresh_cb ( GtkAction *a, VikWindow *vw )
+{
+ // Only get 'new' maps
+ simple_map_update ( vw, TRUE );
+}
+
static void menu_addlayer_cb ( GtkAction *a, VikWindow *vw )
{
- gint type;
+ VikLayerTypeEnum type;
for ( type = 0; type < VIK_LAYER_NUM_TYPES; type++ ) {
if (!strcmp(vik_layer_get_interface(type)->name, gtk_action_get_name(a))) {
if ( vik_layers_panel_new_layer ( vw->viking_vlp, type ) ) {
- draw_update ( vw );
- vw->modified = TRUE;
+ draw_update ( vw );
+ vw->modified = TRUE;
}
}
}
static void menu_paste_layer_cb ( GtkAction *a, VikWindow *vw )
{
- if ( a_clipboard_paste ( vw->viking_vlp ) )
+ if ( vik_layers_panel_paste_selected ( vw->viking_vlp ) )
{
vw->modified = TRUE;
}
#ifdef WINDOWS
ShellExecute(NULL, "open", ""PACKAGE".pdf", NULL, NULL, SW_SHOWNORMAL);
#else /* WINDOWS */
-#if GTK_CHECK_VERSION (2, 14, 0)
gchar *uri;
uri = g_strdup_printf("ghelp:%s", PACKAGE);
- gtk_show_uri(NULL, uri, GDK_CURRENT_TIME, NULL);
+ GError *error = NULL;
+ gboolean show = gtk_show_uri (NULL, uri, GDK_CURRENT_TIME, &error);
+ if ( !show && !error )
+ // No error to show, so unlikely this will get called
+ a_dialog_error_msg ( GTK_WINDOW(vw), _("The help system is not available.") );
+ else if ( error ) {
+ // Main error path
+ a_dialog_error_msg_extra ( GTK_WINDOW(vw), _("Help is not available because: %s.\nEnsure a Mime Type ghelp handler program is installed (e.g. yelp)."), error->message );
+ g_error_free ( error );
+ }
g_free(uri);
-#endif
#endif /* WINDOWS */
}
+static void toggle_side_panel ( VikWindow *vw )
+{
+ vw->show_side_panel = !vw->show_side_panel;
+ if ( vw->show_side_panel )
+ gtk_widget_show(GTK_WIDGET(vw->viking_vlp));
+ else
+ gtk_widget_hide(GTK_WIDGET(vw->viking_vlp));
+}
+
+static void toggle_full_screen ( VikWindow *vw )
+{
+ vw->show_full_screen = !vw->show_full_screen;
+ if ( vw->show_full_screen )
+ gtk_window_fullscreen ( GTK_WINDOW(vw) );
+ else
+ gtk_window_unfullscreen ( GTK_WINDOW(vw) );
+}
+
+static void toggle_statusbar ( VikWindow *vw )
+{
+ vw->show_statusbar = !vw->show_statusbar;
+ if ( vw->show_statusbar )
+ gtk_widget_show ( GTK_WIDGET(vw->viking_vs) );
+ else
+ gtk_widget_hide ( GTK_WIDGET(vw->viking_vs) );
+}
+
+static void toggle_toolbar ( VikWindow *vw )
+{
+ vw->show_toolbar = !vw->show_toolbar;
+ if ( vw->show_toolbar )
+ gtk_widget_show ( toolbar_get_widget (vw->viking_vtb) );
+ else
+ gtk_widget_hide ( toolbar_get_widget (vw->viking_vtb) );
+}
+
+static void toggle_main_menu ( VikWindow *vw )
+{
+ vw->show_main_menu = !vw->show_main_menu;
+ if ( vw->show_main_menu )
+ gtk_widget_show ( gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu" ) );
+ else
+ gtk_widget_hide ( gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu" ) );
+}
+
+// Only for 'view' toggle menu widgets ATM.
+GtkWidget *get_show_widget_by_name(VikWindow *vw, const gchar *name)
+{
+ g_return_val_if_fail(name != NULL, NULL);
+
+ // ATM only FullScreen is *not* in SetShow path
+ gchar *path;
+ if ( g_strcmp0 ("FullScreen", name ) )
+ path = g_strconcat("/ui/MainMenu/View/SetShow/", name, NULL);
+ else
+ path = g_strconcat("/ui/MainMenu/View/", name, NULL);
+
+ GtkWidget *widget = gtk_ui_manager_get_widget(vw->uim, path);
+ g_free(path);
+
+ return widget;
+}
+
+static void tb_view_side_panel_cb ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vw->show_side_panel;
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else
+ toggle_side_panel ( vw );
+}
+
+static void tb_full_screen_cb ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vw->show_full_screen;
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else
+ toggle_full_screen ( vw );
+}
+
+static void tb_view_statusbar_cb ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vw->show_statusbar;
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else
+ toggle_statusbar ( vw );
+}
+
+static void tb_view_toolbar_cb ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vw->show_toolbar;
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else
+ toggle_toolbar ( vw );
+}
+
+static void tb_view_main_menu_cb ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vw->show_main_menu;
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else
+ toggle_main_menu ( vw );
+}
+
+static void tb_set_draw_scale ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vik_viewport_get_draw_scale ( vw->viking_vvp );
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else {
+ vik_viewport_set_draw_scale ( vw->viking_vvp, next_state );
+ draw_update ( vw );
+ }
+}
+
+static void tb_set_draw_centermark ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vik_viewport_get_draw_centermark ( vw->viking_vvp );
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else {
+ vik_viewport_set_draw_centermark ( vw->viking_vvp, next_state );
+ draw_update ( vw );
+ }
+}
+
+static void tb_set_draw_highlight ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vik_viewport_get_draw_highlight ( vw->viking_vvp );
+ GtkWidget *check_box = get_show_widget_by_name ( vw, gtk_action_get_name(a) );
+ gboolean menu_state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
+ if ( next_state != menu_state )
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), next_state );
+ else {
+ vik_viewport_set_draw_highlight ( vw->viking_vvp, next_state );
+ draw_update ( vw );
+ }
+}
+
static void help_about_cb ( GtkAction *a, VikWindow *vw )
{
a_dialog_about(GTK_WINDOW(vw));
}
+static void help_cache_info_cb ( GtkAction *a, VikWindow *vw )
+{
+ // NB: No i18n as this is just for debug
+ gint byte_size = a_mapcache_get_size();
+ gchar *msg_sz = NULL;
+ gchar *msg = NULL;
+#if GLIB_CHECK_VERSION(2,30,0)
+ msg_sz = g_format_size_full ( byte_size, G_FORMAT_SIZE_LONG_FORMAT );
+#else
+ msg_sz = g_format_size_for_display ( byte_size );
+#endif
+ msg = g_strdup_printf ( "Map Cache size is %s with %d items", msg_sz, a_mapcache_get_count());
+ a_dialog_info_msg_extra ( GTK_WINDOW(vw), "%s", msg );
+ g_free ( msg_sz );
+ g_free ( msg );
+}
+
+static void back_forward_info_cb ( GtkAction *a, VikWindow *vw )
+{
+ vik_viewport_show_centers ( vw->viking_vvp, GTK_WINDOW(vw) );
+}
+
static void menu_delete_layer_cb ( GtkAction *a, VikWindow *vw )
{
if ( vik_layers_panel_get_selected ( vw->viking_vlp ) )
a_dialog_info_msg ( GTK_WINDOW(vw), _("You must select a layer to delete.") );
}
+static void full_screen_cb ( GtkAction *a, VikWindow *vw )
+{
+ gboolean next_state = !vw->show_full_screen;
+ GtkToggleToolButton *tbutton = (GtkToggleToolButton *)toolbar_get_widget_by_name ( vw->viking_vtb, gtk_action_get_name(a) );
+ if ( tbutton ) {
+ gboolean tb_state = gtk_toggle_tool_button_get_active ( tbutton );
+ if ( next_state != tb_state )
+ gtk_toggle_tool_button_set_active ( tbutton, next_state );
+ else
+ toggle_full_screen ( vw );
+ }
+ else
+ toggle_full_screen ( vw );
+}
+
static void view_side_panel_cb ( GtkAction *a, VikWindow *vw )
{
- GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewSidePanel" );
- g_assert(check_box);
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box));
- if ( state )
- gtk_widget_show(GTK_WIDGET(vw->viking_vlp));
+ gboolean next_state = !vw->show_side_panel;
+ GtkToggleToolButton *tbutton = (GtkToggleToolButton *)toolbar_get_widget_by_name ( vw->viking_vtb, gtk_action_get_name(a) );
+ if ( tbutton ) {
+ gboolean tb_state = gtk_toggle_tool_button_get_active ( tbutton );
+ if ( next_state != tb_state )
+ gtk_toggle_tool_button_set_active ( tbutton, next_state );
+ else
+ toggle_side_panel ( vw );
+ }
else
- gtk_widget_hide(GTK_WIDGET(vw->viking_vlp));
+ toggle_side_panel ( vw );
}
static void view_statusbar_cb ( GtkAction *a, VikWindow *vw )
{
- GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewStatusBar" );
- if ( !check_box )
- return;
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
- if ( state )
- gtk_widget_show ( GTK_WIDGET(vw->viking_vs) );
+ gboolean next_state = !vw->show_statusbar;
+ GtkToggleToolButton *tbutton = (GtkToggleToolButton *)toolbar_get_widget_by_name ( vw->viking_vtb, gtk_action_get_name(a) );
+ if ( tbutton ) {
+ gboolean tb_state = gtk_toggle_tool_button_get_active ( tbutton );
+ if ( next_state != tb_state )
+ gtk_toggle_tool_button_set_active ( tbutton, next_state );
+ else
+ toggle_statusbar ( vw );
+ }
else
- gtk_widget_hide ( GTK_WIDGET(vw->viking_vs) );
+ toggle_statusbar ( vw );
}
static void view_toolbar_cb ( GtkAction *a, VikWindow *vw )
{
- GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewToolbar" );
- if ( !check_box )
- return;
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
- if ( state )
- gtk_widget_show ( GTK_WIDGET(vw->toolbar) );
+ gboolean next_state = !vw->show_toolbar;
+ GtkToggleToolButton *tbutton = (GtkToggleToolButton *)toolbar_get_widget_by_name ( vw->viking_vtb, gtk_action_get_name(a) );
+ if ( tbutton ) {
+ gboolean tb_state = gtk_toggle_tool_button_get_active ( tbutton );
+ if ( next_state != tb_state )
+ gtk_toggle_tool_button_set_active ( tbutton, next_state );
+ else
+ toggle_toolbar ( vw );
+ }
else
- gtk_widget_hide ( GTK_WIDGET(vw->toolbar) );
+ toggle_toolbar ( vw );
}
static void view_main_menu_cb ( GtkAction *a, VikWindow *vw )
{
- GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ViewMainMenu" );
- if ( !check_box )
- return;
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box) );
- if ( !state )
- gtk_widget_hide ( gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu" ) );
+ gboolean next_state = !vw->show_main_menu;
+ GtkToggleToolButton *tbutton = (GtkToggleToolButton *)toolbar_get_widget_by_name ( vw->viking_vtb, gtk_action_get_name(a) );
+ if ( tbutton ) {
+ gboolean tb_state = gtk_toggle_tool_button_get_active ( tbutton );
+ if ( next_state != tb_state )
+ gtk_toggle_tool_button_set_active ( tbutton, next_state );
+ else
+ toggle_main_menu ( vw );
+ }
else
- gtk_widget_show ( gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu" ) );
+ toggle_main_menu ( vw );
}
/***************************************
vt->n_tools = 0;
vt->active_tool = -1;
vt->vw = vw;
- if (!vw->viking_vvp) {
- g_critical("no viewport found.");
- exit(1);
- }
return vt;
}
if (tool == vt->n_tools) {
g_critical("trying to activate a non-existent tool...");
- exit(1);
+ return;
}
/* is the tool already active? */
if (vt->active_tool == tool) {
toolbox_tool_t *t = &vt->tools[tool];
if (t->ti.cursor == NULL) {
if (t->ti.cursor_type == GDK_CURSOR_IS_PIXMAP && t->ti.cursor_data != NULL) {
- GError *cursor_load_err = NULL;
- GdkPixbuf *cursor_pixbuf = gdk_pixbuf_from_pixdata (t->ti.cursor_data, FALSE, &cursor_load_err);
+ GdkPixbuf *cursor_pixbuf = gdk_pixbuf_from_pixdata (t->ti.cursor_data, FALSE, NULL);
/* TODO: settable offeset */
t->ti.cursor = gdk_cursor_new_from_pixbuf ( gdk_display_get_default(), cursor_pixbuf, 3, 3 );
g_object_unref ( G_OBJECT(cursor_pixbuf) );
gtk_action_activate ( gtk_action_group_get_action ( vw->action_group, vik_layer_get_interface(layer_id)->tools[tool_id].radioActionEntry.name ) );
}
-/* this function gets called whenever a toolbar tool is clicked */
-static void menu_tool_cb ( GtkAction *old, GtkAction *a, VikWindow *vw )
+// Be careful with usage - as it may trigger actions being continually alternately by the menu and toolbar items
+// DON'T Use this from menu callback with toggle toolbar items!!
+static void toolbar_sync ( VikWindow *vw, const gchar *name, gboolean state )
{
- /* White Magic, my friends ... White Magic... */
- int layer_id, tool_id;
- const GdkCursor *cursor = NULL;
+ GtkToggleToolButton *tbutton = (GtkToggleToolButton *)toolbar_get_widget_by_name ( vw->viking_vtb, name );
+ if ( tbutton ) {
+ // Causes toggle signal action to be raised.
+ gtk_toggle_tool_button_set_active ( tbutton, state );
+ }
+}
- toolbox_activate(vw->vt, gtk_action_get_name(a));
+/* this function gets called whenever a menu is clicked */
+// Note old is not used
+static void menu_cb ( GtkAction *old, GtkAction *a, VikWindow *vw )
+{
+ // Ensure Toolbar kept in sync
+ const gchar *name = gtk_action_get_name(a);
+ toolbar_sync ( vw, name, TRUE );
+
+ /* White Magic, my friends ... White Magic... */
+ gint tool_id;
+ toolbox_activate(vw->vt, name);
- cursor = toolbox_get_cursor(vw->vt, gtk_action_get_name(a));
+ vw->viewport_cursor = (GdkCursor *)toolbox_get_cursor(vw->vt, name);
- if ( GTK_WIDGET(vw->viking_vvp)->window )
+ if ( gtk_widget_get_window(GTK_WIDGET(vw->viking_vvp)) )
/* We set cursor, even if it is NULL: it resets to default */
- gdk_window_set_cursor ( GTK_WIDGET(vw->viking_vvp)->window, (GdkCursor *)cursor );
+ gdk_window_set_cursor ( gtk_widget_get_window(GTK_WIDGET(vw->viking_vvp)), vw->viewport_cursor );
- if (!strcmp(gtk_action_get_name(a), "Pan")) {
+ if (!g_strcmp0(name, "Pan")) {
vw->current_tool = TOOL_PAN;
}
- else if (!strcmp(gtk_action_get_name(a), "Zoom")) {
+ else if (!g_strcmp0(name, "Zoom")) {
vw->current_tool = TOOL_ZOOM;
}
- else if (!strcmp(gtk_action_get_name(a), "Ruler")) {
+ else if (!g_strcmp0(name, "Ruler")) {
vw->current_tool = TOOL_RULER;
}
- else if (!strcmp(gtk_action_get_name(a), "Select")) {
+ else if (!g_strcmp0(name, "Select")) {
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 (!g_strcmp0(vik_layer_get_interface(layer_id)->tools[tool_id].radioActionEntry.name, name)) {
vw->current_tool = TOOL_LAYER;
vw->tool_layer_id = layer_id;
vw->tool_tool_id = tool_id;
- }
+ }
}
}
}
- draw_status ( vw );
+ draw_status_tool ( vw );
}
static void window_set_filename ( VikWindow *vw, const gchar *filename )
if ( filename == NULL )
{
vw->filename = NULL;
- file = _("Untitled");
}
else
{
vw->filename = g_strdup(filename);
- file = a_file_basename ( filename );
}
+
+ /* Refresh window's title */
+ file = window_get_filename ( vw );
title = g_strdup_printf( "%s - Viking", file );
gtk_window_set_title ( GTK_WINDOW(vw), title );
g_free ( title );
}
+static const gchar *window_get_filename ( VikWindow *vw )
+{
+ return vw->filename ? a_file_basename ( vw->filename ) : _("Untitled");
+}
+
GtkWidget *vik_window_get_drawmode_button ( VikWindow *vw, VikViewportDrawMode mode )
{
GtkWidget *mode_button;
return vw->pan_move;
}
+/**
+ * Remove the potentially auto added map
+ */
+static void remove_default_map_layer ( VikWindow *vw )
+{
+ if ( a_vik_get_add_default_map_layer () ) {
+ VikAggregateLayer *top = vik_layers_panel_get_top_layer(vw->viking_vlp);
+ if ( vik_aggregate_layer_count(top) == 1 ) {
+ VikLayer *vl = vik_aggregate_layer_get_top_visible_layer_of_type (top, VIK_LAYER_MAPS);
+ // Could try to compare name vs _("Default Map") but this might have i8n issues if not translated
+ if ( vl )
+ vik_aggregate_layer_delete_layer ( top, vl );
+ }
+ }
+}
+
static void on_activate_recent_item (GtkRecentChooser *chooser,
VikWindow *self)
{
// NB: GSList & contents are freed by main.open_window
}
else {
+ remove_default_map_layer ( self );
vik_window_open_file ( self, path, TRUE );
g_free ( path );
}
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);
G_CALLBACK (on_activate_recent_item), (gpointer) self);
}
-static void update_recently_used_document(const gchar *filename)
+/*
+ *
+ */
+static void update_recently_used_document (VikWindow *vw, const gchar *filename)
{
/* Update Recently Used Document framework */
GtkRecentManager *manager = gtk_recent_manager_get_default();
recent_data->is_private = FALSE;
if (!gtk_recent_manager_add_full (manager, uri, recent_data))
{
- g_warning (_("Unable to add '%s' to the list of recently used documents"), uri);
+ gchar *msg = g_strdup_printf (_("Unable to add '%s' to the list of recently used documents"), uri);
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, msg );
+ g_free ( msg );
}
g_free (uri);
g_slice_free (GtkRecentData, recent_data);
}
+/**
+ * Call this before doing things that may take a long time and otherwise not show any other feedback
+ * such as loading and saving files
+ */
+void vik_window_set_busy_cursor ( VikWindow *vw )
+{
+ 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_get_window(GTK_WIDGET(vw->viking_vvp)), vw->busy_cursor );
+ // Ensure cursor updated before doing stuff
+ while( gtk_events_pending() )
+ gtk_main_iteration();
+}
+
+void vik_window_clear_busy_cursor ( VikWindow *vw )
+{
+ gdk_window_set_cursor ( gtk_widget_get_window(GTK_WIDGET(vw)), NULL );
+ // Restore 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 )
{
- switch ( a_file_load ( vik_layers_panel_get_top_layer(vw->viking_vlp), vw->viking_vvp, filename ) )
+ vik_window_set_busy_cursor ( vw );
+
+ // 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, vw->containing_vtl, 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.") );
case LOAD_TYPE_UNSUPPORTED_FAILURE:
a_dialog_error_msg_extra ( GTK_WINDOW(vw), _("Unsupported file type for %s"), filename );
break;
+ case LOAD_TYPE_VIK_FAILURE_NON_FATAL:
+ {
+ // Since we can process .vik files with issues just show a warning in the status bar
+ // Not that a user can do much about it... or tells them what this issue is yet...
+ gchar *msg = g_strdup_printf (_("WARNING: issues encountered loading %s"), a_file_basename (filename) );
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, msg );
+ g_free ( msg );
+ }
+ // 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 )
vw->only_updating_coord_mode_ui = FALSE;
vik_layers_panel_change_coord_mode ( vw->viking_vlp, vik_viewport_get_coord_mode ( vw->viking_vvp ) );
-
- mode_button = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ShowScale" );
- g_assert ( mode_button );
- gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(mode_button),vik_viewport_get_draw_scale(vw->viking_vvp) );
- mode_button = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ShowCenterMark" );
- g_assert ( mode_button );
- gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(mode_button),vik_viewport_get_draw_centermark(vw->viking_vvp) );
-
- mode_button = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ShowHighlight" );
- g_assert ( mode_button );
- gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(mode_button),vik_viewport_get_draw_highlight (vw->viking_vvp) );
+ // Slightly long winded methods to align loaded viewport settings with the UI
+ // Since the rewrite for toolbar + menu actions
+ // there no longer exists a simple way to directly change the UI to a value for toggle settings
+ // it only supports toggling the existing setting (otherwise get infinite loops in trying to align tb+menu elements)
+ // Thus get state, compare them, if different then invert viewport setting and (re)sync the setting (via toggling)
+ gboolean vp_state_scale = vik_viewport_get_draw_scale ( vw->viking_vvp );
+ gboolean ui_state_scale = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(get_show_widget_by_name(vw, "ShowScale")) );
+ if ( vp_state_scale != ui_state_scale ) {
+ vik_viewport_set_draw_scale ( vw->viking_vvp, !vp_state_scale );
+ toggle_draw_scale ( NULL, vw );
+ }
+ gboolean vp_state_centermark = vik_viewport_get_draw_centermark ( vw->viking_vvp );
+ gboolean ui_state_centermark = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(get_show_widget_by_name(vw, "ShowCenterMark")) );
+ if ( vp_state_centermark != ui_state_centermark ) {
+ vik_viewport_set_draw_centermark ( vw->viking_vvp, !vp_state_centermark );
+ toggle_draw_centermark ( NULL, vw );
+ }
+ gboolean vp_state_highlight = vik_viewport_get_draw_highlight ( vw->viking_vvp );
+ gboolean ui_state_highlight = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(get_show_widget_by_name(vw, "ShowHighlight")) );
+ if ( vp_state_highlight != ui_state_highlight ) {
+ vik_viewport_set_draw_highlight ( vw->viking_vvp, !vp_state_highlight );
+ toggle_draw_highlight ( NULL, vw );
+ }
}
+ // NB No break, carry on to redraw
//case LOAD_TYPE_OTHER_SUCCESS:
default:
- update_recently_used_document(filename);
+ 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 (vw, 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 );
}
+
static void load_file ( GtkAction *a, VikWindow *vw )
{
GSList *files = NULL;
g_critical("Houston, we've had a problem.");
return;
}
-
- if ( ! vw->open_dia )
- {
- vw->open_dia = gtk_file_chooser_dialog_new (_("Please select a GPS data file to open. "),
- GTK_WINDOW(vw),
- GTK_FILE_CHOOSER_ACTION_OPEN,
- GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
- NULL);
- GtkFileFilter *filter;
- // NB file filters are listed this way for alphabetical ordering
+
+ GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Please select a GPS data file to open. "),
+ GTK_WINDOW(vw),
+ GTK_FILE_CHOOSER_ACTION_OPEN,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+ NULL);
+ if ( last_folder_files_uri )
+ gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(dialog), last_folder_files_uri );
+
+ GtkFileFilter *filter;
+ // NB file filters are listed this way for alphabetical ordering
#ifdef VIK_CONFIG_GEOCACHES
- filter = gtk_file_filter_new ();
- gtk_file_filter_set_name( filter, _("Geocaching") );
- gtk_file_filter_add_pattern ( filter, "*.loc" ); // 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, _("Geocaching") );
+ gtk_file_filter_add_pattern ( filter, "*.loc" ); // No MIME type available
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
#endif
- filter = gtk_file_filter_new ();
- gtk_file_filter_set_name( filter, _("Google Earth") );
- gtk_file_filter_add_mime_type ( filter, "application/vnd.google-earth.kml+xml");
- gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(vw->open_dia), filter);
-
- filter = gtk_file_filter_new ();
- gtk_file_filter_set_name( filter, _("GPX") );
- 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, _("Viking") );
- gtk_file_filter_add_pattern ( filter, "*.vik" );
- gtk_file_filter_add_pattern ( filter, "*.viking" );
- gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(vw->open_dia), filter);
-
- // NB could have filters for gpspoint (*.gps,*.gpsoint?) + gpsmapper (*.gsm,*.gpsmapper?)
- // However assume this are barely used and thus not worthy of inclusion
- // as they'll just make the options too many and have no clear file pattern
- // one can always use the all option
- filter = gtk_file_filter_new ();
- gtk_file_filter_set_name( filter, _("All") );
- gtk_file_filter_add_pattern ( filter, "*" );
- gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(vw->open_dia), filter);
- // Default to any file - same as before open filters were added
- gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(vw->open_dia), filter);
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name( filter, _("Google Earth") );
+ gtk_file_filter_add_mime_type ( filter, "application/vnd.google-earth.kml+xml");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name( filter, _("GPX") );
+ gtk_file_filter_add_pattern ( filter, "*.gpx" ); // No MIME type available
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), 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(dialog), filter);
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name( filter, _("Viking") );
+ gtk_file_filter_add_pattern ( filter, "*.vik" );
+ gtk_file_filter_add_pattern ( filter, "*.viking" );
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
+
+ // NB could have filters for gpspoint (*.gps,*.gpsoint?) + gpsmapper (*.gsm,*.gpsmapper?)
+ // However assume this are barely used and thus not worthy of inclusion
+ // as they'll just make the options too many and have no clear file pattern
+ // one can always use the all option
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name( filter, _("All") );
+ gtk_file_filter_add_pattern ( filter, "*" );
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
+ // Default to any file - same as before open filters were added
+ gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog), filter);
+
+ gtk_file_chooser_set_select_multiple ( GTK_FILE_CHOOSER(dialog), TRUE );
+ gtk_window_set_transient_for ( GTK_WINDOW(dialog), GTK_WINDOW(vw) );
+ gtk_window_set_destroy_with_parent ( GTK_WINDOW(dialog), TRUE );
- gtk_file_chooser_set_select_multiple ( GTK_FILE_CHOOSER(vw->open_dia), TRUE );
- gtk_window_set_transient_for ( GTK_WINDOW(vw->open_dia), GTK_WINDOW(vw) );
- gtk_window_set_destroy_with_parent ( GTK_WINDOW(vw->open_dia), TRUE );
- }
- if ( gtk_dialog_run ( GTK_DIALOG(vw->open_dia) ) == GTK_RESPONSE_ACCEPT )
+ if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
- gtk_widget_hide ( vw->open_dia );
+ g_free ( last_folder_files_uri );
+ last_folder_files_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(dialog) );
+
#ifdef VIKING_PROMPT_IF_MODIFIED
if ( (vw->modified || vw->filename) && newwindow )
#else
if ( vw->filename && newwindow )
#endif
- g_signal_emit ( G_OBJECT(vw), window_signals[VW_OPENWINDOW_SIGNAL], 0, gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER(vw->open_dia) ) );
+ g_signal_emit ( G_OBJECT(vw), window_signals[VW_OPENWINDOW_SIGNAL], 0, gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER(dialog) ) );
else {
- files = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER(vw->open_dia) );
+
+ files = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER(dialog) );
gboolean change_fn = newwindow && (g_slist_length(files)==1); /* only change fn if one file */
-
+ gboolean first_vik_file = TRUE;
cur_file = files;
while ( cur_file ) {
+
gchar *file_name = cur_file->data;
- vik_window_open_file ( vw, file_name, change_fn );
+ if ( newwindow && check_file_magic_vik ( file_name ) ) {
+ // Load first of many .vik files in current window
+ if ( first_vik_file ) {
+ remove_default_map_layer ( vw );
+ vik_window_open_file ( vw, file_name, TRUE );
+ first_vik_file = FALSE;
+ }
+ else {
+ // Load each subsequent .vik file in a separate window
+ VikWindow *newvw = vik_window_new_window ();
+ if (newvw)
+ vik_window_open_file ( newvw, file_name, TRUE );
+ }
+ }
+ else
+ // Other file types
+ vik_window_open_file ( vw, file_name, change_fn );
+
g_free (file_name);
cur_file = g_slist_next (cur_file);
}
g_slist_free (files);
}
}
- else
- gtk_widget_hide ( vw->open_dia );
+ gtk_widget_destroy ( dialog );
}
static gboolean save_file_as ( GtkAction *a, VikWindow *vw )
{
gboolean rv = FALSE;
const gchar *fn;
- if ( ! vw->save_dia )
- {
- vw->save_dia = gtk_file_chooser_dialog_new (_("Save as Viking File."),
- GTK_WINDOW(vw),
- GTK_FILE_CHOOSER_ACTION_SAVE,
- GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
- NULL);
- gtk_window_set_transient_for ( GTK_WINDOW(vw->save_dia), GTK_WINDOW(vw) );
- gtk_window_set_destroy_with_parent ( GTK_WINDOW(vw->save_dia), TRUE );
- }
- while ( gtk_dialog_run ( GTK_DIALOG(vw->save_dia) ) == GTK_RESPONSE_ACCEPT )
+ GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Save as Viking File."),
+ GTK_WINDOW(vw),
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+ NULL);
+ if ( last_folder_files_uri )
+ gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(dialog), last_folder_files_uri );
+
+ GtkFileFilter *filter;
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name( filter, _("All") );
+ gtk_file_filter_add_pattern ( filter, "*" );
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name( filter, _("Viking") );
+ gtk_file_filter_add_pattern ( filter, "*.vik" );
+ gtk_file_filter_add_pattern ( filter, "*.viking" );
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(dialog), filter);
+ // Default to a Viking file
+ gtk_file_chooser_set_filter (GTK_FILE_CHOOSER(dialog), filter);
+
+ gtk_window_set_transient_for ( GTK_WINDOW(dialog), GTK_WINDOW(vw) );
+ gtk_window_set_destroy_with_parent ( GTK_WINDOW(dialog), TRUE );
+
+ // 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 ( ! 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(dialog), auto_save_name);
+
+ while ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
- fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(vw->save_dia) );
- if ( g_file_test ( fn, G_FILE_TEST_EXISTS ) == FALSE || a_dialog_yes_or_no ( GTK_WINDOW(vw->save_dia), _("The file \"%s\" exists, do you wish to overwrite it?"), a_file_basename ( fn ) ) )
+ fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(dialog) );
+ if ( g_file_test ( fn, G_FILE_TEST_EXISTS ) == FALSE || a_dialog_yes_or_no ( GTK_WINDOW(dialog), _("The file \"%s\" exists, do you wish to overwrite it?"), a_file_basename ( fn ) ) )
{
window_set_filename ( vw, fn );
rv = window_save ( vw );
- vw->modified = FALSE;
+ if ( rv ) {
+ vw->modified = FALSE;
+ g_free ( last_folder_files_uri );
+ last_folder_files_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(dialog) );
+ }
break;
}
}
- gtk_widget_hide ( vw->save_dia );
+ g_free ( auto_save_name );
+ gtk_widget_destroy ( dialog );
return rv;
}
static gboolean window_save ( VikWindow *vw )
{
+ vik_window_set_busy_cursor ( vw );
+ gboolean success = TRUE;
+
if ( a_file_save ( vik_layers_panel_get_top_layer ( vw->viking_vlp ), vw->viking_vvp, vw->filename ) )
{
- update_recently_used_document ( vw->filename );
- return TRUE;
+ update_recently_used_document ( vw, vw->filename );
}
else
{
a_dialog_error_msg ( GTK_WINDOW(vw), _("The filename you requested could not be opened for writing.") );
- return FALSE;
+ success = FALSE;
}
+ vik_window_clear_busy_cursor ( vw );
+ return success;
}
static gboolean save_file ( GtkAction *a, VikWindow *vw )
}
}
+/**
+ * export_to:
+ *
+ * Export all TRW Layers in the list to individual files in the specified directory
+ *
+ * Returns: %TRUE on success
+ */
+static gboolean export_to ( VikWindow *vw, GList *gl, VikFileType_t vft, const gchar *dir, const gchar *extension )
+{
+ gboolean success = TRUE;
+
+ gint export_count = 0;
+
+ vik_window_set_busy_cursor ( vw );
+
+ while ( gl ) {
+
+ gchar *fn = g_strconcat ( dir, G_DIR_SEPARATOR_S, VIK_LAYER(gl->data)->name, extension, NULL );
+
+ // Some protection in attempting to write too many same named files
+ // As this will get horribly slow...
+ gboolean safe = FALSE;
+ gint ii = 2;
+ while ( ii < 5000 ) {
+ if ( g_file_test ( fn, G_FILE_TEST_EXISTS ) ) {
+ // Try rename
+ g_free ( fn );
+ fn = g_strdup_printf ( "%s%s%s#%03d%s", dir, G_DIR_SEPARATOR_S, VIK_LAYER(gl->data)->name, ii, extension );
+ }
+ else {
+ safe = TRUE;
+ break;
+ }
+ ii++;
+ }
+ if ( ii == 5000 )
+ success = FALSE;
+
+ // NB: We allow exporting empty layers
+ if ( safe ) {
+ gboolean this_success = a_file_export ( VIK_TRW_LAYER(gl->data), fn, vft, NULL, TRUE );
+
+ // Show some progress
+ if ( this_success ) {
+ export_count++;
+ 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 ();
+ g_free ( message );
+ }
+
+ success = success && this_success;
+ }
+
+ g_free ( fn );
+ gl = g_list_next ( gl );
+ }
+
+ vik_window_clear_busy_cursor ( vw );
+
+ // Confirm what happened.
+ gchar *message = g_strdup_printf ( _("Exported files: %d"), export_count );
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, message );
+ g_free ( message );
+
+ return success;
+}
+
+static void export_to_common ( VikWindow *vw, VikFileType_t vft, const gchar *extension )
+{
+ GList *gl = vik_layers_panel_get_all_layers_of_type ( vw->viking_vlp, VIK_LAYER_TRW, TRUE );
+
+ if ( !gl ) {
+ a_dialog_info_msg ( GTK_WINDOW(vw), _("Nothing to Export!") );
+ return;
+ }
+
+ GtkWidget *dialog = gtk_file_chooser_dialog_new ( _("Export to directory"),
+ GTK_WINDOW(vw),
+ GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
+ GTK_STOCK_CANCEL,
+ GTK_RESPONSE_REJECT,
+ GTK_STOCK_OK,
+ GTK_RESPONSE_ACCEPT,
+ NULL );
+ 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(dialog) );
+ gtk_widget_destroy ( dialog );
+ if ( dir ) {
+ if ( !export_to ( vw, gl, vft, dir, extension ) )
+ a_dialog_error_msg ( GTK_WINDOW(vw),_("Could not convert all files") );
+ g_free ( dir );
+ }
+ }
+ else
+ gtk_widget_destroy ( dialog );
+
+ g_list_free ( gl );
+}
+
+static void export_to_gpx ( GtkAction *a, VikWindow *vw )
+{
+ export_to_common ( vw, FILE_TYPE_GPX, ".gpx" );
+}
+
+static void export_to_kml ( GtkAction *a, VikWindow *vw )
+{
+ export_to_common ( vw, FILE_TYPE_KML, ".kml" );
+}
+
+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;
+#if GLIB_CHECK_VERSION(2,30,0)
+ size = g_format_size_full ( byte_size, G_FORMAT_SIZE_DEFAULT );
+#else
+ size = g_format_size_for_display ( byte_size );
+#endif
+ 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 my_acquire ( VikWindow *vw, VikDataSourceInterface *datasource )
+{
+ vik_datasource_mode_t mode = datasource->mode;
+ if ( mode == VIK_DATASOURCE_AUTO_LAYER_MANAGEMENT )
+ mode = VIK_DATASOURCE_CREATENEWLAYER;
+ a_acquire ( vw, vw->viking_vlp, vw->viking_vvp, mode, datasource, NULL, NULL );
+}
+
static void acquire_from_gps ( GtkAction *a, VikWindow *vw )
{
- // Via the file menu, acquiring from a GPS makes a new layer
- // this has always been the way (not entirely sure if this was the real intention!)
- // 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 );
+ my_acquire ( vw, &vik_datasource_gps_interface );
}
static void acquire_from_file ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_file_interface );
+ my_acquire ( vw, &vik_datasource_file_interface );
}
-#ifdef VIK_CONFIG_GOOGLE_DIRECTIONS
-static void acquire_from_google ( GtkAction *a, VikWindow *vw )
+static void acquire_from_geojson ( GtkAction *a, VikWindow *vw )
{
- a_acquire(vw, vw->viking_vlp, vw->viking_vvp, &vik_datasource_google_interface );
+ my_acquire ( vw, &vik_datasource_geojson_interface );
+}
+
+static void acquire_from_routing ( GtkAction *a, VikWindow *vw )
+{
+ my_acquire ( vw, &vik_datasource_routing_interface );
}
-#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 );
+ my_acquire ( vw, &vik_datasource_osm_interface );
+}
+
+static void acquire_from_my_osm ( GtkAction *a, VikWindow *vw )
+{
+ my_acquire ( vw, &vik_datasource_osm_my_traces_interface );
}
#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 );
+ my_acquire ( vw, &vik_datasource_gc_interface );
}
#endif
#ifdef VIK_CONFIG_GEOTAG
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 );
+ my_acquire ( vw, &vik_datasource_geotag_interface );
+}
+#endif
+
+#ifdef VIK_CONFIG_GEONAMES
+static void acquire_from_wikipedia ( GtkAction *a, VikWindow *vw )
+{
+ my_acquire ( vw, &vik_datasource_wikipedia_interface );
}
#endif
+static void acquire_from_url ( GtkAction *a, VikWindow *vw )
+{
+ my_acquire ( vw, &vik_datasource_url_interface );
+}
+
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);
}
static void goto_address( GtkAction *a, VikWindow *vw)
{
- a_vik_goto(vw, vw->viking_vlp, vw->viking_vvp);
+ a_vik_goto ( vw, vw->viking_vvp );
+ vik_layers_panel_emit_update ( vw->viking_vlp );
}
static void mapcache_flush_cb ( GtkAction *a, VikWindow *vw )
a_mapcache_flush();
}
+static void menu_copy_centre_cb ( GtkAction *a, VikWindow *vw )
+{
+ const VikCoord* coord;
+ struct UTM utm;
+ gchar *lat = NULL, *lon = NULL;
+
+ coord = vik_viewport_get_center ( vw->viking_vvp );
+ vik_coord_to_utm ( coord, &utm );
+
+ gboolean full_format = FALSE;
+ (void)a_settings_get_boolean ( VIK_SETTINGS_WIN_COPY_CENTRE_FULL_FORMAT, &full_format );
+
+ if ( full_format )
+ // Bells & Whistles - may include degrees, minutes and second symbols
+ get_location_strings ( vw, utm, &lat, &lon );
+ else {
+ // Simple x.xx y.yy format
+ struct LatLon ll;
+ a_coords_utm_to_latlon ( &utm, &ll );
+ lat = g_strdup_printf ( "%.6f", ll.lat );
+ lon = g_strdup_printf ( "%.6f", ll.lon );
+ }
+
+ gchar *msg = g_strdup_printf ( "%s %s", lat, lon );
+ g_free (lat);
+ g_free (lon);
+
+ a_clipboard_copy ( VIK_CLIPBOARD_DATA_TEXT, 0, 0, 0, msg, NULL );
+
+ g_free ( msg );
+}
+
+static void layer_defaults_cb ( GtkAction *a, VikWindow *vw )
+{
+ gchar **texts = g_strsplit ( gtk_action_get_name(a), "Layer", 0 );
+
+ if ( !texts[1] )
+ return; // Internally broken :(
+
+ if ( ! a_layer_defaults_show_window ( GTK_WINDOW(vw), texts[1] ) )
+ a_dialog_info_msg ( GTK_WINDOW(vw), _("This layer has no configurable properties.") );
+ // NB no update needed
+
+ g_strfreev ( texts );
+}
+
+static void preferences_change_update ( VikWindow *vw, gpointer data )
+{
+ // Want to update all TrackWaypoint layers
+ GList *layers = vik_layers_panel_get_all_layers_of_type ( vw->viking_vlp, VIK_LAYER_TRW, TRUE );
+
+ if ( !layers )
+ return;
+
+ while ( layers ) {
+ // Reset the individual waypoints themselves due to the preferences change
+ VikTrwLayer *vtl = VIK_TRW_LAYER(layers->data);
+ vik_trw_layer_reset_waypoints ( vtl );
+ layers = g_list_next ( layers );
+ }
+
+ g_list_free ( layers );
+
+ draw_update ( vw );
+}
+
static void preferences_cb ( GtkAction *a, VikWindow *vw )
{
gboolean wp_icon_size = a_vik_get_use_large_waypoint_icons();
a_preferences_show_window ( GTK_WINDOW(vw) );
- // Delete icon indexing 'cache' and so automatically regenerates with the new setting when changed
- if (wp_icon_size != a_vik_get_use_large_waypoint_icons())
+ // Has the waypoint size setting changed?
+ if (wp_icon_size != a_vik_get_use_large_waypoint_icons()) {
+ // Delete icon indexing 'cache' and so automatically regenerates with the new setting when changed
clear_garmin_icon_syms ();
- draw_update ( vw );
+ // Update all windows
+ g_slist_foreach ( window_list, (GFunc) preferences_change_update, NULL );
+ }
+
+ // Ensure TZ Lookup initialized
+ if ( a_vik_get_time_ref_frame() == VIK_TIME_REF_WORLD )
+ vu_setup_lat_lon_tz_lookup();
+
+ toolbar_apply_settings ( vw->viking_vtb, vw->main_vbox, vw->menu_hbox, TRUE );
}
static void default_location_cb ( GtkAction *a, VikWindow *vw )
/* Simplistic repeat of preference setting
Only the name & type are important for setting the preference via this 'external' way */
VikLayerParam pref_lat[] = {
- { VIKING_PREFERENCES_NAMESPACE "default_latitude",
+ { VIK_LAYER_NUM_TYPES,
+ VIKING_PREFERENCES_NAMESPACE "default_latitude",
VIK_LAYER_PARAM_DOUBLE,
- VIK_LOCATION_LAT,
+ VIK_LAYER_GROUP_NONE,
NULL,
VIK_LAYER_WIDGET_SPINBUTTON,
NULL,
- NULL },
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ },
};
VikLayerParam pref_lon[] = {
- { VIKING_PREFERENCES_NAMESPACE "default_longitude",
+ { VIK_LAYER_NUM_TYPES,
+ VIKING_PREFERENCES_NAMESPACE "default_longitude",
VIK_LAYER_PARAM_DOUBLE,
- VIK_LOCATION_LONG,
+ VIK_LAYER_GROUP_NONE,
NULL,
VIK_LAYER_WIDGET_SPINBUTTON,
NULL,
- NULL },
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ },
};
/* Get current center */
a_preferences_save_to_file();
}
+/**
+ * Delete All
+ */
static void clear_cb ( GtkAction *a, VikWindow *vw )
{
- vik_layers_panel_clear ( vw->viking_vlp );
- window_set_filename ( vw, NULL );
- draw_update ( vw );
+ // Do nothing if empty
+ VikAggregateLayer *top = vik_layers_panel_get_top_layer(vw->viking_vlp);
+ if ( ! vik_aggregate_layer_is_empty(top) ) {
+ if ( a_dialog_yes_or_no ( GTK_WINDOW(vw), _("Are you sure you wish to delete all layers?"), NULL ) ) {
+ vik_layers_panel_clear ( vw->viking_vlp );
+ window_set_filename ( vw, NULL );
+ draw_update ( vw );
+ }
+ }
}
static void window_close ( GtkAction *a, VikWindow *vw )
}
}
-static void save_image_file ( VikWindow *vw, const gchar *fn, guint w, guint h, gdouble zoom, gboolean save_as_png )
+static void save_image_file ( VikWindow *vw, const gchar *fn, guint w, guint h, gdouble zoom, gboolean save_as_png, gboolean save_kmz )
{
/* more efficient way: stuff draws directly to pixbuf (fork viewport) */
GdkPixbuf *pixbuf_to_save;
gdouble old_xmpp, old_ympp;
GError *error = NULL;
+ GtkWidget *msgbox = gtk_message_dialog_new ( GTK_WINDOW(vw),
+ GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_INFO,
+ GTK_BUTTONS_NONE,
+ _("Generating image file...") );
+
+ g_signal_connect_swapped (msgbox, "response", G_CALLBACK (gtk_widget_destroy), msgbox);
+ // Ensure dialog shown
+ gtk_widget_show_all ( msgbox );
+ // Try harder...
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, _("Generating image file...") );
+ while ( gtk_events_pending() )
+ gtk_main_iteration ();
+ // Despite many efforts & variations, GTK on my Linux system doesn't show the actual msgbox contents :(
+ // At least the empty box can give a clue something's going on + the statusbar msg...
+ // Windows version under Wine OK!
+
/* backup old zoom & set new */
old_xmpp = vik_viewport_get_xmpp ( vw->viking_vvp );
old_ympp = vik_viewport_get_ympp ( vw->viking_vvp );
/* save buffer as file. */
pixbuf_to_save = gdk_pixbuf_get_from_drawable ( NULL, GDK_DRAWABLE(vik_viewport_get_pixmap ( vw->viking_vvp )), NULL, 0, 0, 0, 0, w, h);
- gdk_pixbuf_save ( pixbuf_to_save, fn, save_as_png ? "png" : "jpeg", &error, NULL );
- if (error)
- {
- g_warning("Unable to write to file %s: %s", fn, error->message );
- g_error_free (error);
+ if ( !pixbuf_to_save ) {
+ g_warning("Failed to generate internal pixmap size: %d x %d", w, h);
+ gtk_message_dialog_set_markup ( GTK_MESSAGE_DIALOG(msgbox), _("Failed to generate internal image.\n\nTry creating a smaller image.") );
+ goto cleanup;
+ }
+
+ int ans = 0; // Default to success
+
+ if ( save_kmz ) {
+ gdouble north, east, south, west;
+ vik_viewport_get_min_max_lat_lon ( vw->viking_vvp, &south, &north, &west, &east );
+ ans = kmz_save_file ( pixbuf_to_save, fn, north, east, south, west );
+ }
+ else {
+ gdk_pixbuf_save ( pixbuf_to_save, fn, save_as_png ? "png" : "jpeg", &error, NULL );
+ if (error) {
+ g_warning("Unable to write to file %s: %s", fn, error->message );
+ g_error_free (error);
+ ans = 42;
+ }
}
+
+ if ( ans == 0 )
+ gtk_message_dialog_set_markup ( GTK_MESSAGE_DIALOG(msgbox), _("Image file generated.") );
+ else
+ gtk_message_dialog_set_markup ( GTK_MESSAGE_DIALOG(msgbox), _("Failed to generate image file.") );
+
g_object_unref ( G_OBJECT(pixbuf_to_save) );
+ cleanup:
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, "" );
+ gtk_dialog_add_button ( GTK_DIALOG(msgbox), GTK_STOCK_OK, GTK_RESPONSE_OK );
+ gtk_dialog_run ( GTK_DIALOG(msgbox) ); // Don't care about the result
+
/* pretend like nothing happened ;) */
vik_viewport_set_xmpp ( vw->viking_vvp, old_xmpp );
vik_viewport_set_ympp ( vw->viking_vvp, old_ympp );
g_assert ( vik_viewport_get_coord_mode ( vw->viking_vvp ) == VIK_COORD_UTM );
- g_mkdir(fn,0777);
+ if ( g_mkdir(fn,0777) != 0 )
+ g_warning ( "%s: Failed to create directory %s", __FUNCTION__, fn );
utm_orig = *((const struct UTM *)vik_viewport_get_center ( vw->viking_vvp ));
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 );
gdk_pixbuf_save ( pixbuf_to_save, name_of_file, save_as_png ? "png" : "jpeg", &error, NULL );
if (error)
{
- g_warning("Unable to write to file %s: %s", name_of_file, error->message );
+ gchar *msg = g_strdup_printf (_("Unable to write to file %s: %s"), name_of_file, error->message );
+ vik_statusbar_set_message ( vw->viking_vs, VIK_STATUSBAR_INFO, msg );
+ g_free ( msg );
g_error_free (error);
}
}
}
- 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 );
{
VikWindow *vw = VIK_WINDOW(pass_along[0]);
GtkSpinButton *width_spin = GTK_SPIN_BUTTON(pass_along[1]), *height_spin = GTK_SPIN_BUTTON(pass_along[2]);
- GtkSpinButton *zoom_spin = GTK_SPIN_BUTTON(pass_along[3]);
+
+ gint active = gtk_combo_box_get_active ( GTK_COMBO_BOX(pass_along[3]) );
+ gdouble zoom = pow (2, active-2 );
+
gdouble width_min, width_max, height_min, height_max;
gint width, height;
gtk_spin_button_get_range ( height_spin, &height_min, &height_max );
/* TODO: support for xzoom and yzoom values */
- width = vik_viewport_get_width ( vw->viking_vvp ) * vik_viewport_get_xmpp ( vw->viking_vvp ) / gtk_spin_button_get_value ( zoom_spin );
- height = vik_viewport_get_height ( vw->viking_vvp ) * vik_viewport_get_xmpp ( vw->viking_vvp ) / gtk_spin_button_get_value ( zoom_spin );
+ width = vik_viewport_get_width ( vw->viking_vvp ) * vik_viewport_get_xmpp ( vw->viking_vvp ) / zoom;
+ height = vik_viewport_get_height ( vw->viking_vvp ) * vik_viewport_get_xmpp ( vw->viking_vvp ) / zoom;
if ( width > width_max || width < width_min || height > height_max || height < height_min )
a_dialog_info_msg ( GTK_WINDOW(vw), _("Viewable region outside allowable pixel size bounds for image. Clipping width/height values.") );
static void draw_to_image_file_total_area_cb (GtkSpinButton *spinbutton, gpointer *pass_along)
{
GtkSpinButton *width_spin = GTK_SPIN_BUTTON(pass_along[1]), *height_spin = GTK_SPIN_BUTTON(pass_along[2]);
- GtkSpinButton *zoom_spin = GTK_SPIN_BUTTON(pass_along[3]);
+
+ gint active = gtk_combo_box_get_active ( GTK_COMBO_BOX(pass_along[3]) );
+ gdouble zoom = pow (2, active-2 );
+
gchar *label_text;
gdouble w, h;
- w = gtk_spin_button_get_value(width_spin) * gtk_spin_button_get_value(zoom_spin);
- h = gtk_spin_button_get_value(height_spin) * gtk_spin_button_get_value(zoom_spin);
+ w = gtk_spin_button_get_value(width_spin) * zoom;
+ h = gtk_spin_button_get_value(height_spin) * zoom;
if (pass_along[4]) /* save many images; find TOTAL area covered */
{
w *= gtk_spin_button_get_value(GTK_SPIN_BUTTON(pass_along[4]));
case VIK_UNITS_DISTANCE_MILES:
label_text = g_strdup_printf ( _("Total area: %ldm x %ldm (%.3f sq. miles)"), (glong)w, (glong)h, (w*h/2589988.11));
break;
+ case VIK_UNITS_DISTANCE_NAUTICAL_MILES:
+ label_text = g_strdup_printf ( _("Total area: %ldm x %ldm (%.3f sq. NM)"), (glong)w, (glong)h, (w*h/(1852.0*1852.0)));
+ break;
default:
label_text = g_strdup_printf ("Just to keep the compiler happy");
g_critical("Houston, we've had a problem. distance=%d", dist_units);
g_free ( label_text );
}
-static void draw_to_image_file ( VikWindow *vw, const gchar *fn, gboolean one_image_only )
+typedef enum {
+ VW_GEN_SINGLE_IMAGE,
+ VW_GEN_DIRECTORY_OF_IMAGES,
+ VW_GEN_KMZ_FILE,
+} img_generation_t;
+
+/*
+ * Get an allocated filename (or directory as specified)
+ */
+static gchar* draw_image_filename ( VikWindow *vw, img_generation_t img_gen )
+{
+ gchar *fn = NULL;
+ if ( img_gen != VW_GEN_DIRECTORY_OF_IMAGES )
+ {
+ // Single file
+ GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Save Image"),
+ GTK_WINDOW(vw),
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+ NULL);
+ if ( last_folder_images_uri )
+ gtk_file_chooser_set_current_folder_uri ( GTK_FILE_CHOOSER(dialog), last_folder_images_uri );
+
+ GtkFileChooser *chooser = GTK_FILE_CHOOSER ( dialog );
+ /* Add filters */
+ GtkFileFilter *filter;
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name ( filter, _("All") );
+ gtk_file_filter_add_pattern ( filter, "*" );
+ gtk_file_chooser_add_filter ( chooser, filter );
+
+ if ( img_gen == VW_GEN_KMZ_FILE ) {
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name ( filter, _("KMZ") );
+ gtk_file_filter_add_mime_type ( filter, "vnd.google-earth.kmz");
+ gtk_file_filter_add_pattern ( filter, "*.kmz" );
+ gtk_file_chooser_add_filter ( chooser, filter );
+ gtk_file_chooser_set_filter ( chooser, filter );
+ }
+ else {
+ 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 ( chooser, filter );
+
+ if ( !vw->draw_image_save_as_png )
+ gtk_file_chooser_set_filter ( chooser, filter );
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name ( filter, _("PNG") );
+ gtk_file_filter_add_mime_type ( filter, "image/png");
+ gtk_file_chooser_add_filter ( chooser, filter );
+
+ if ( vw->draw_image_save_as_png )
+ gtk_file_chooser_set_filter ( chooser, filter );
+ }
+
+ gtk_window_set_transient_for ( GTK_WINDOW(dialog), GTK_WINDOW(vw) );
+ gtk_window_set_destroy_with_parent ( GTK_WINDOW(dialog), TRUE );
+
+ if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) {
+ g_free ( last_folder_images_uri );
+ last_folder_images_uri = gtk_file_chooser_get_current_folder_uri ( GTK_FILE_CHOOSER(dialog) );
+
+ fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(dialog) );
+ if ( g_file_test ( fn, G_FILE_TEST_EXISTS ) )
+ if ( ! a_dialog_yes_or_no ( GTK_WINDOW(dialog), _("The file \"%s\" exists, do you wish to overwrite it?"), a_file_basename ( fn ) ) )
+ fn = NULL;
+ }
+ gtk_widget_destroy ( dialog );
+ }
+ else {
+ // A directory
+ // For some reason this method is only written to work in UTM...
+ if ( vik_viewport_get_coord_mode(vw->viking_vvp) != VIK_COORD_UTM ) {
+ a_dialog_error_msg ( GTK_WINDOW(vw), _("You must be in UTM mode to use this feature") );
+ return fn;
+ }
+
+ GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Choose a directory to hold images"),
+ GTK_WINDOW(vw),
+ GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
+ NULL);
+ gtk_window_set_transient_for ( GTK_WINDOW(dialog), GTK_WINDOW(vw) );
+ gtk_window_set_destroy_with_parent ( GTK_WINDOW(dialog), TRUE );
+
+ if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) {
+ fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(dialog) );
+ }
+ gtk_widget_destroy ( dialog );
+ }
+ return fn;
+}
+
+static void draw_to_image_file ( VikWindow *vw, img_generation_t img_gen )
{
/* todo: default for answers inside VikWindow or static (thruout instance) */
GtkWidget *dialog = gtk_dialog_new_with_buttons ( _("Save to Image File"), GTK_WINDOW(vw),
GTK_RESPONSE_ACCEPT,
NULL );
GtkWidget *width_label, *width_spin, *height_label, *height_spin;
- GtkWidget *png_radio, *jpeg_radio;
GtkWidget *current_window_button;
gpointer current_window_pass_along[7];
- GtkWidget *zoom_label, *zoom_spin;
+ GtkWidget *zoom_label, *zoom_combo;
GtkWidget *total_size_label;
- /* only used if (!one_image_only) */
+ // only used for VW_GEN_DIRECTORY_OF_IMAGES
GtkWidget *tiles_width_spin = NULL, *tiles_height_spin = NULL;
-
width_label = gtk_label_new ( _("Width (pixels):") );
- width_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new ( vw->draw_image_width, 10, 5000, 10, 100, 0 )), 10, 0 );
+ width_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new ( vw->draw_image_width, 10, 50000, 10, 100, 0 )), 10, 0 );
height_label = gtk_label_new ( _("Height (pixels):") );
- height_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new ( vw->draw_image_height, 10, 5000, 10, 100, 0 )), 10, 0 );
-
+ height_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new ( vw->draw_image_height, 10, 50000, 10, 100, 0 )), 10, 0 );
+#ifdef WINDOWS
+ GtkWidget *win_warning_label = gtk_label_new ( _("WARNING: USING LARGE IMAGES OVER 10000x10000\nMAY CRASH THE PROGRAM!") );
+#endif
zoom_label = gtk_label_new ( _("Zoom (meters per pixel):") );
/* TODO: separate xzoom and yzoom factors */
- zoom_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new ( vik_viewport_get_xmpp(vw->viking_vvp), VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM/2.0, 1, 100, 0 )), 16, 0);
+ zoom_combo = create_zoom_combo_all_levels();
+
+ gdouble mpp = vik_viewport_get_xmpp(vw->viking_vvp);
+ gint active = 2 + round ( log (mpp) / log (2) );
+
+ // Can we not hard code size here?
+ if ( active > 17 )
+ active = 17;
+ if ( active < 0 )
+ active = 0;
+ gtk_combo_box_set_active ( GTK_COMBO_BOX(zoom_combo), active );
total_size_label = gtk_label_new ( NULL );
current_window_pass_along [0] = vw;
current_window_pass_along [1] = width_spin;
current_window_pass_along [2] = height_spin;
- current_window_pass_along [3] = zoom_spin;
- current_window_pass_along [4] = NULL; /* used for one_image_only != 1 */
- current_window_pass_along [5] = NULL;
+ current_window_pass_along [3] = zoom_combo;
+ current_window_pass_along [4] = NULL; // Only for directory of tiles: width
+ current_window_pass_along [5] = NULL; // Only for directory of tiles: height
current_window_pass_along [6] = total_size_label;
g_signal_connect ( G_OBJECT(current_window_button), "button_press_event", G_CALLBACK(draw_to_image_file_current_window_cb), current_window_pass_along );
- 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") );
+ GtkWidget *png_radio = gtk_radio_button_new_with_label ( NULL, _("Save as PNG") );
+ GtkWidget *jpeg_radio = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON(png_radio), _("Save as JPEG") );
+
+ if ( img_gen == VW_GEN_KMZ_FILE ) {
+ // Don't show image type selection if creating a KMZ (always JPG internally)
+ // Start with viewable area by default
+ draw_to_image_file_current_window_cb ( current_window_button, NULL, current_window_pass_along );
+ } else {
+ 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))), png_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(dialog)->vbox), width_label, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), width_spin, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), height_label, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), height_spin, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), current_window_button, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), png_radio, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), jpeg_radio, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), zoom_label, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), zoom_spin, FALSE, FALSE, 0);
-
- if ( ! one_image_only )
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), width_label, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), width_spin, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), height_label, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), height_spin, FALSE, FALSE, 0);
+#ifdef WINDOWS
+ 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))), 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 ( img_gen == VW_GEN_DIRECTORY_OF_IMAGES )
{
GtkWidget *tiles_width_label, *tiles_height_label;
-
tiles_width_label = gtk_label_new ( _("East-west image tiles:") );
tiles_width_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new ( 5, 1, 10, 1, 100, 0 )), 1, 0 );
tiles_height_label = gtk_label_new ( _("North-south image tiles:") );
tiles_height_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new ( 5, 1, 10, 1, 100, 0 )), 1, 0 );
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), tiles_width_label, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), tiles_width_spin, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), tiles_height_label, FALSE, FALSE, 0);
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), tiles_height_spin, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tiles_width_label, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tiles_width_spin, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tiles_height_label, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tiles_height_spin, FALSE, FALSE, 0);
current_window_pass_along [4] = tiles_width_spin;
current_window_pass_along [5] = tiles_height_spin;
g_signal_connect ( G_OBJECT(tiles_width_spin), "value-changed", G_CALLBACK(draw_to_image_file_total_area_cb), current_window_pass_along );
g_signal_connect ( G_OBJECT(tiles_height_spin), "value-changed", G_CALLBACK(draw_to_image_file_total_area_cb), current_window_pass_along );
}
- gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), total_size_label, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), total_size_label, FALSE, FALSE, 0);
g_signal_connect ( G_OBJECT(width_spin), "value-changed", G_CALLBACK(draw_to_image_file_total_area_cb), current_window_pass_along );
g_signal_connect ( G_OBJECT(height_spin), "value-changed", G_CALLBACK(draw_to_image_file_total_area_cb), current_window_pass_along );
- g_signal_connect ( G_OBJECT(zoom_spin), "value-changed", G_CALLBACK(draw_to_image_file_total_area_cb), current_window_pass_along );
+ g_signal_connect ( G_OBJECT(zoom_combo), "changed", G_CALLBACK(draw_to_image_file_total_area_cb), current_window_pass_along );
draw_to_image_file_total_area_cb ( NULL, current_window_pass_along ); /* set correct size info now */
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
- gtk_widget_show_all ( GTK_DIALOG(dialog)->vbox );
+ gtk_widget_show_all ( gtk_dialog_get_content_area(GTK_DIALOG(dialog)) );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT )
{
gtk_widget_hide ( GTK_WIDGET(dialog) );
- if ( one_image_only )
+
+ gchar *fn = draw_image_filename ( vw, img_gen );
+ if ( !fn )
+ return;
+
+ gint active_z = gtk_combo_box_get_active ( GTK_COMBO_BOX(zoom_combo) );
+ gdouble zoom = pow (2, active_z-2 );
+
+ if ( img_gen == VW_GEN_SINGLE_IMAGE )
save_image_file ( vw, fn,
vw->draw_image_width = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(width_spin) ),
vw->draw_image_height = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(height_spin) ),
- gtk_spin_button_get_value ( GTK_SPIN_BUTTON(zoom_spin) ), /* do not save this value, default is current zoom */
- vw->draw_image_save_as_png = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(png_radio) ) );
+ zoom,
+ vw->draw_image_save_as_png = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(png_radio) ),
+ FALSE );
+ else if ( img_gen == VW_GEN_KMZ_FILE ) {
+ // Remove some viewport overlays as these aren't useful in KMZ file.
+ gboolean restore_xhair = vik_viewport_get_draw_centermark ( vw->viking_vvp );
+ if ( restore_xhair )
+ vik_viewport_set_draw_centermark ( vw->viking_vvp, FALSE );
+ gboolean restore_scale = vik_viewport_get_draw_scale ( vw->viking_vvp );
+ if ( restore_scale )
+ vik_viewport_set_draw_scale ( vw->viking_vvp, FALSE );
+
+ save_image_file ( vw,
+ fn,
+ gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(width_spin) ),
+ gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(height_spin) ),
+ zoom,
+ FALSE, // JPG
+ TRUE );
+
+ if ( restore_xhair )
+ vik_viewport_set_draw_centermark ( vw->viking_vvp, TRUE );
+ if ( restore_scale )
+ vik_viewport_set_draw_scale ( vw->viking_vvp, TRUE );
+ if ( restore_xhair || restore_scale )
+ draw_update ( vw );
+ }
else {
// NB is in UTM mode ATM
save_image_dir ( vw, fn,
vw->draw_image_width = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(width_spin) ),
vw->draw_image_height = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(height_spin) ),
- gtk_spin_button_get_value ( GTK_SPIN_BUTTON(zoom_spin) ), /* do not save this value, default is current zoom */
+ zoom,
vw->draw_image_save_as_png = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON(png_radio) ),
gtk_spin_button_get_value ( GTK_SPIN_BUTTON(tiles_width_spin) ),
gtk_spin_button_get_value ( GTK_SPIN_BUTTON(tiles_height_spin) ) );
}
+
+ g_free ( fn );
}
gtk_widget_destroy ( GTK_WIDGET(dialog) );
}
-
-static void draw_to_image_file_cb ( GtkAction *a, VikWindow *vw )
+static void draw_to_kmz_file_cb ( GtkAction *a, VikWindow *vw )
{
- gchar *fn;
- if (!vw->save_img_dia) {
- vw->save_img_dia = gtk_file_chooser_dialog_new (_("Save Image"),
- GTK_WINDOW(vw),
- GTK_FILE_CHOOSER_ACTION_SAVE,
- GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
- NULL);
- gtk_window_set_transient_for ( GTK_WINDOW(vw->save_img_dia), GTK_WINDOW(vw) );
- gtk_window_set_destroy_with_parent ( GTK_WINDOW(vw->save_img_dia), TRUE );
+ if ( vik_viewport_get_coord_mode(vw->viking_vvp) == VIK_COORD_UTM ) {
+ a_dialog_error_msg ( GTK_WINDOW(vw), _("This feature is not available in UTM mode") );
+ return;
}
+ // NB ATM This only generates a KMZ file with the current viewport image - intended mostly for map images [but will include any lines/icons from track & waypoints that are drawn]
+ // (it does *not* include a full KML dump of every track, waypoint etc...)
+ draw_to_image_file ( vw, VW_GEN_KMZ_FILE );
+}
- while ( gtk_dialog_run ( GTK_DIALOG(vw->save_img_dia) ) == GTK_RESPONSE_ACCEPT )
- {
- fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(vw->save_img_dia) );
- if ( g_file_test ( fn, G_FILE_TEST_EXISTS ) == FALSE || a_dialog_yes_or_no ( GTK_WINDOW(vw->save_img_dia), _("The file \"%s\" exists, do you wish to overwrite it?"), a_file_basename ( fn ) ) )
- {
- draw_to_image_file ( vw, fn, TRUE );
- break;
- }
- g_free(fn);
- fn = NULL;
- }
- gtk_widget_hide ( vw->save_img_dia );
+static void draw_to_image_file_cb ( GtkAction *a, VikWindow *vw )
+{
+ draw_to_image_file ( vw, VW_GEN_SINGLE_IMAGE );
}
static void draw_to_image_dir_cb ( GtkAction *a, VikWindow *vw )
{
- gchar *fn = NULL;
-
- if ( vik_viewport_get_coord_mode(vw->viking_vvp) != VIK_COORD_UTM ) {
- a_dialog_error_msg ( GTK_WINDOW(vw), _("You must be in UTM mode to use this feature") );
- return;
- }
+ draw_to_image_file ( vw, VW_GEN_DIRECTORY_OF_IMAGES );
+}
- if (!vw->save_img_dir_dia) {
- vw->save_img_dir_dia = gtk_file_chooser_dialog_new (_("Choose a directory to hold images"),
- GTK_WINDOW(vw),
- GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
- GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
- NULL);
- gtk_window_set_transient_for ( GTK_WINDOW(vw->save_img_dir_dia), GTK_WINDOW(vw) );
- gtk_window_set_destroy_with_parent ( GTK_WINDOW(vw->save_img_dir_dia), TRUE );
- }
-
- while ( gtk_dialog_run ( GTK_DIALOG(vw->save_img_dir_dia) ) == GTK_RESPONSE_ACCEPT )
- {
- fn = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(vw->save_img_dir_dia) );
- if ( fn )
- {
- draw_to_image_file ( vw, fn, FALSE );
- g_free(fn);
- fn = NULL;
- break;
- }
+/**
+ *
+ */
+static void import_kmz_file_cb ( GtkAction *a, VikWindow *vw )
+{
+ GtkWidget *dialog = gtk_file_chooser_dialog_new (_("Open File"),
+ GTK_WINDOW(vw),
+ GTK_FILE_CHOOSER_ACTION_OPEN,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+ NULL);
+
+ GtkFileFilter *filter;
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name ( filter, _("KMZ") );
+ gtk_file_filter_add_mime_type ( filter, "vnd.google-earth.kmz");
+ gtk_file_filter_add_pattern ( filter, "*.kmz" );
+ gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER(dialog), filter );
+ gtk_file_chooser_set_filter ( GTK_FILE_CHOOSER(dialog), filter );
+
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name( filter, _("All") );
+ gtk_file_filter_add_pattern ( filter, "*" );
+ gtk_file_chooser_add_filter ( GTK_FILE_CHOOSER(dialog), filter );
+ // Default to any file - same as before open filters were added
+ gtk_file_chooser_set_filter ( GTK_FILE_CHOOSER(dialog), filter );
+
+ if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) {
+ gchar *fn = gtk_file_chooser_get_filename ( GTK_FILE_CHOOSER(dialog) );
+ // TODO convert ans value into readable explaination of failure...
+ int ans = kmz_open_file ( fn, vw->viking_vvp, vw->viking_vlp );
+ if ( ans )
+ a_dialog_error_msg_extra ( GTK_WINDOW(vw), _("Unable to import %s."), fn );
+
+ draw_update ( vw );
}
- gtk_widget_hide ( vw->save_img_dir_dia );
+ gtk_widget_destroy ( dialog );
}
-#if GTK_CHECK_VERSION(2,10,0)
static void print_cb ( GtkAction *a, VikWindow *vw )
{
a_print(vw, vw->viking_vvp);
}
-#endif
/* really a misnomer: changes coord mode (actual coordinates) AND/OR draw mode (viewport only) */
static void window_change_coord_mode_cb ( GtkAction *old_a, GtkAction *a, VikWindow *vw )
{
+ const gchar *name = gtk_action_get_name(a);
+ GtkToggleToolButton *tbutton = (GtkToggleToolButton *)toolbar_get_widget_by_name ( vw->viking_vtb, name );
+ if ( tbutton )
+ gtk_toggle_tool_button_set_active ( tbutton, TRUE );
+
VikViewportDrawMode drawmode;
- if (!strcmp(gtk_action_get_name(a), "ModeUTM")) {
+ if (!g_strcmp0(name, "ModeUTM")) {
drawmode = VIK_VIEWPORT_DRAWMODE_UTM;
}
- else if (!strcmp(gtk_action_get_name(a), "ModeLatLon")) {
+ else if (!g_strcmp0(name, "ModeLatLon")) {
drawmode = VIK_VIEWPORT_DRAWMODE_LATLON;
}
- else if (!strcmp(gtk_action_get_name(a), "ModeExpedia")) {
+ else if (!g_strcmp0(name, "ModeExpedia")) {
drawmode = VIK_VIEWPORT_DRAWMODE_EXPEDIA;
}
- else if (!strcmp(gtk_action_get_name(a), "ModeMercator")) {
+ else if (!g_strcmp0(name, "ModeMercator")) {
drawmode = VIK_VIEWPORT_DRAWMODE_MERCATOR;
}
else {
}
}
-static void set_draw_scale ( GtkAction *a, VikWindow *vw )
+static void toggle_draw_scale ( GtkAction *a, VikWindow *vw )
{
+ gboolean state = !vik_viewport_get_draw_scale ( vw->viking_vvp );
GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ShowScale" );
- g_assert(check_box);
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box));
+ if ( !check_box )
+ return;
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), state );
vik_viewport_set_draw_scale ( vw->viking_vvp, state );
draw_update ( vw );
}
-static void set_draw_centermark ( GtkAction *a, VikWindow *vw )
+static void toggle_draw_centermark ( GtkAction *a, VikWindow *vw )
{
+ gboolean state = !vik_viewport_get_draw_centermark ( vw->viking_vvp );
GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ShowCenterMark" );
- g_assert(check_box);
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box));
+ if ( !check_box )
+ return;
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), state );
vik_viewport_set_draw_centermark ( vw->viking_vvp, state );
draw_update ( vw );
}
-static void set_draw_highlight ( GtkAction *a, VikWindow *vw )
+static void toggle_draw_highlight ( GtkAction *a, VikWindow *vw )
{
+ gboolean state = !vik_viewport_get_draw_highlight ( vw->viking_vvp );
GtkWidget *check_box = gtk_ui_manager_get_widget ( vw->uim, "/ui/MainMenu/View/SetShow/ShowHighlight" );
- g_assert(check_box);
- gboolean state = gtk_check_menu_item_get_active ( GTK_CHECK_MENU_ITEM(check_box));
- vik_viewport_set_draw_highlight ( vw->viking_vvp, state );
+ if ( !check_box )
+ return;
+ gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM(check_box), state );
+ vik_viewport_set_draw_highlight ( vw->viking_vvp, state );
draw_update ( vw );
}
{
GtkWidget *colorsd = gtk_color_selection_dialog_new ( _("Choose a background color") );
GdkColor *color = vik_viewport_get_background_gdkcolor ( vw->viking_vvp );
- gtk_color_selection_set_previous_color ( GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorsd)->colorsel), color );
- gtk_color_selection_set_current_color ( GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorsd)->colorsel), color );
+ gtk_color_selection_set_previous_color ( GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorsd))), color );
+ gtk_color_selection_set_current_color ( GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorsd))), color );
if ( gtk_dialog_run ( GTK_DIALOG(colorsd) ) == GTK_RESPONSE_OK )
{
- gtk_color_selection_get_current_color ( GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorsd)->colorsel), color );
+ gtk_color_selection_get_current_color ( GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorsd))), color );
vik_viewport_set_background_gdkcolor ( vw->viking_vvp, color );
draw_update ( vw );
}
{
GtkWidget *colorsd = gtk_color_selection_dialog_new ( _("Choose a track highlight color") );
GdkColor *color = vik_viewport_get_highlight_gdkcolor ( vw->viking_vvp );
- gtk_color_selection_set_previous_color ( GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorsd)->colorsel), color );
- gtk_color_selection_set_current_color ( GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorsd)->colorsel), color );
+ gtk_color_selection_set_previous_color ( GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorsd))), color );
+ gtk_color_selection_set_current_color ( GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorsd))), color );
if ( gtk_dialog_run ( GTK_DIALOG(colorsd) ) == GTK_RESPONSE_OK )
{
- gtk_color_selection_get_current_color ( GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(colorsd)->colorsel), color );
+ gtk_color_selection_get_current_color ( GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(colorsd))), color );
vik_viewport_set_highlight_gdkcolor ( vw->viking_vvp, color );
draw_update ( vw );
}
}
-
/***********************************************************************************************
** GUI Creation
***********************************************************************************************/
{ "Open", GTK_STOCK_OPEN, N_("_Open..."), "<control>O", N_("Open a file"), (GCallback)load_file },
{ "OpenRecentFile", NULL, N_("Open _Recent File"), NULL, NULL, (GCallback)NULL },
{ "Append", GTK_STOCK_ADD, N_("Append _File..."), NULL, N_("Append data from a different file"), (GCallback)load_file },
+ { "Export", GTK_STOCK_CONVERT, N_("_Export All"), NULL, N_("Export All TrackWaypoint Layers"), (GCallback)NULL },
+ { "ExportGPX", NULL, N_("_GPX..."), NULL, N_("Export as GPX"), (GCallback)export_to_gpx },
{ "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_DIRECTIONS
- { "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 },
#endif
#ifdef VIK_CONFIG_GEOCACHES
{ "AcquireGC", NULL, N_("Geo_caches..."), NULL, N_("Get Geocaches from geocaching.com"), (GCallback)acquire_from_gc },
#endif
#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 },
- { "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 },
-
-#if GTK_CHECK_VERSION(2,10,0)
- { "Print", GTK_STOCK_PRINT, N_("_Print..."), NULL, N_("Print maps"), (GCallback)print_cb },
+ { "FileProperties", NULL, N_("Properties..."), NULL, N_("File Properties"), (GCallback)file_properties_cb },
+#ifdef HAVE_ZIP_H
+ { "ImportKMZ", GTK_STOCK_CONVERT, N_("Import KMZ _Map File..."), NULL, N_("Import a KMZ file"), (GCallback)import_kmz_file_cb },
+ { "GenKMZ", GTK_STOCK_DND, N_("Generate _KMZ Map File..."), NULL, N_("Generate a KMZ file with an overlay of the current view"), (GCallback)draw_to_kmz_file_cb },
#endif
-
+ { "GenImg", GTK_STOCK_FILE, 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_("Generate _Directory of Images"), (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 },
{ "GotoUTM", GTK_STOCK_JUMP_TO, N_("Go to UTM..."), NULL, N_("Go to arbitrary UTM coordinate"), (GCallback)draw_goto_cb },
- { "SetHLColor",GTK_STOCK_SELECT_COLOR, N_("Set _Highlight Color..."), NULL, NULL, (GCallback)set_highlight_color },
- { "SetBGColor",GTK_STOCK_SELECT_COLOR, N_("Set Bac_kground Color..."), NULL, NULL, (GCallback)set_bg_color },
- { "ZoomIn", GTK_STOCK_ZOOM_IN, N_("Zoom _In"), "<control>plus", NULL, (GCallback)draw_zoom_cb },
- { "ZoomOut", GTK_STOCK_ZOOM_OUT, N_("Zoom _Out"), "<control>minus", NULL, (GCallback)draw_zoom_cb },
- { "ZoomTo", GTK_STOCK_ZOOM_FIT, N_("Zoom _To..."), "<control>Z", NULL, (GCallback)zoom_to_cb },
- { "Zoom0.25", NULL, N_("0.25"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom0.5", NULL, N_("0.5"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom1", NULL, N_("1"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom2", NULL, N_("2"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom4", NULL, N_("4"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom8", NULL, N_("8"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom16", NULL, N_("16"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom32", NULL, N_("32"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom64", NULL, N_("64"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom128", NULL, N_("128"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom256", NULL, N_("256"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom512", NULL, N_("512"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom1024", NULL, N_("1024"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom2048", NULL, N_("2048"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom4096", NULL, N_("4096"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom8192", NULL, N_("8192"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom16384", NULL, N_("16384"), NULL, NULL, (GCallback)draw_zoom_cb },
- { "Zoom32768", NULL, N_("32768"), NULL, NULL, (GCallback)draw_zoom_cb },
+ { "Refresh", GTK_STOCK_REFRESH, N_("_Refresh"), "F5", N_("Refresh any maps displayed"), (GCallback)draw_refresh_cb },
+ { "SetHLColor",GTK_STOCK_SELECT_COLOR, N_("Set _Highlight Color..."), NULL, N_("Set Highlight Color"), (GCallback)set_highlight_color },
+ { "SetBGColor",GTK_STOCK_SELECT_COLOR, N_("Set Bac_kground Color..."), NULL, N_("Set Background Color"), (GCallback)set_bg_color },
+ { "ZoomIn", GTK_STOCK_ZOOM_IN, N_("Zoom _In"), "<control>plus", N_("Zoom In"), (GCallback)draw_zoom_cb },
+ { "ZoomOut", GTK_STOCK_ZOOM_OUT, N_("Zoom _Out"), "<control>minus", N_("Zoom Out"), (GCallback)draw_zoom_cb },
+ { "ZoomTo", GTK_STOCK_ZOOM_FIT, N_("Zoom _To..."), "<control>Z", N_("Zoom To"), (GCallback)zoom_to_cb },
{ "PanNorth", NULL, N_("Pan _North"), "<control>Up", NULL, (GCallback)draw_pan_cb },
{ "PanEast", NULL, N_("Pan _East"), "<control>Right", NULL, (GCallback)draw_pan_cb },
{ "PanSouth", NULL, N_("Pan _South"), "<control>Down", NULL, (GCallback)draw_pan_cb },
{ "PanWest", NULL, N_("Pan _West"), "<control>Left", NULL, (GCallback)draw_pan_cb },
- { "BGJobs", GTK_STOCK_EXECUTE, N_("Background _Jobs"), NULL, NULL, (GCallback)a_background_show_window },
+ { "BGJobs", GTK_STOCK_EXECUTE, N_("Background _Jobs"), NULL, N_("Background Jobs"), (GCallback)a_background_show_window },
- { "Cut", GTK_STOCK_CUT, N_("Cu_t"), NULL, NULL, (GCallback)menu_cut_layer_cb },
- { "Copy", GTK_STOCK_COPY, N_("_Copy"), NULL, NULL, (GCallback)menu_copy_layer_cb },
- { "Paste", GTK_STOCK_PASTE, N_("_Paste"), NULL, NULL, (GCallback)menu_paste_layer_cb },
- { "Delete", GTK_STOCK_DELETE, N_("_Delete"), NULL, NULL, (GCallback)menu_delete_layer_cb },
+ { "Cut", GTK_STOCK_CUT, N_("Cu_t"), NULL, N_("Cut selected layer"), (GCallback)menu_cut_layer_cb },
+ { "Copy", GTK_STOCK_COPY, N_("_Copy"), NULL, N_("Copy selected layer"), (GCallback)menu_copy_layer_cb },
+ { "Paste", GTK_STOCK_PASTE, N_("_Paste"), NULL, N_("Paste layer into selected container layer or otherwise above selected layer"), (GCallback)menu_paste_layer_cb },
+ { "Delete", GTK_STOCK_DELETE, N_("_Delete"), NULL, N_("Remove selected layer"), (GCallback)menu_delete_layer_cb },
{ "DeleteAll", NULL, N_("Delete All"), NULL, NULL, (GCallback)clear_cb },
+ { "CopyCentre",NULL, N_("Copy Centre _Location"), "<control>h", NULL, (GCallback)menu_copy_centre_cb },
{ "MapCacheFlush",NULL, N_("_Flush Map Cache"), NULL, NULL, (GCallback)mapcache_flush_cb },
{ "SetDefaultLocation", GTK_STOCK_GO_FORWARD, N_("_Set the Default Location"), NULL, N_("Set the Default Location to the current position"),(GCallback)default_location_cb },
- { "Preferences",GTK_STOCK_PREFERENCES, N_("_Preferences"), NULL, NULL, (GCallback)preferences_cb },
- { "Properties",GTK_STOCK_PROPERTIES, N_("_Properties"), NULL, NULL, (GCallback)menu_properties_cb },
+ { "Preferences",GTK_STOCK_PREFERENCES, N_("_Preferences"), NULL, N_("Program Preferences"), (GCallback)preferences_cb },
+ { "LayerDefaults",GTK_STOCK_PROPERTIES, N_("_Layer Defaults"), NULL, NULL, NULL },
+ { "Properties",GTK_STOCK_PROPERTIES, N_("_Properties"), NULL, N_("Layer Properties"), (GCallback)menu_properties_cb },
+
+ { "HelpEntry", GTK_STOCK_HELP, N_("_Help"), "F1", N_("Help"), (GCallback)help_help_cb },
+ { "About", GTK_STOCK_ABOUT, N_("_About"), NULL, N_("About"), (GCallback)help_about_cb },
+};
- { "HelpEntry", GTK_STOCK_HELP, N_("_Help"), "F1", NULL, (GCallback)help_help_cb },
- { "About", GTK_STOCK_ABOUT, N_("_About"), NULL, NULL, (GCallback)help_about_cb },
+static GtkActionEntry debug_entries[] = {
+ { "MapCacheInfo", NULL, "_Map Cache Info", NULL, NULL, (GCallback)help_cache_info_cb },
+ { "BackForwardInfo", NULL, "_Back/Forward Info", NULL, NULL, (GCallback)back_forward_info_cb },
+};
+
+static GtkActionEntry entries_gpsbabel[] = {
+ { "ExportKML", NULL, N_("_KML..."), NULL, N_("Export as KML"), (GCallback)export_to_kml },
+ { "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 },
+};
+
+static GtkActionEntry entries_geojson[] = {
+ { "AcquireGeoJSON", NULL, N_("Import Geo_JSON File..."), NULL, N_("Import GeoJSON file"), (GCallback)acquire_from_geojson },
};
/* Radio items */
-/* FIXME use VIEWPORT_DRAWMODE values */
static GtkRadioActionEntry mode_entries[] = {
- { "ModeUTM", NULL, N_("_UTM Mode"), "<control>u", NULL, 0 },
- { "ModeExpedia", NULL, N_("_Expedia Mode"), "<control>e", NULL, 1 },
- { "ModeMercator", NULL, N_("_Mercator Mode"), "<control>m", NULL, 4 },
- { "ModeLatLon", NULL, N_("Lat_/Lon Mode"), "<control>l", NULL, 5 },
+ { "ModeUTM", NULL, N_("_UTM Mode"), "<control>u", NULL, VIK_VIEWPORT_DRAWMODE_UTM },
+ { "ModeExpedia", NULL, N_("_Expedia Mode"), "<control>e", NULL, VIK_VIEWPORT_DRAWMODE_EXPEDIA },
+ { "ModeMercator", NULL, N_("_Mercator Mode"), "<control>m", NULL, VIK_VIEWPORT_DRAWMODE_MERCATOR },
+ { "ModeLatLon", NULL, N_("Lat_/Lon Mode"), "<control>l", NULL, VIK_VIEWPORT_DRAWMODE_LATLON },
};
static GtkToggleActionEntry toggle_entries[] = {
- { "ShowScale", NULL, N_("Show _Scale"), "F5", N_("Show Scale"), (GCallback)set_draw_scale, TRUE },
- { "ShowCenterMark", NULL, N_("Show _Center Mark"), "F6", N_("Show Center Mark"), (GCallback)set_draw_centermark, TRUE },
- { "ShowHighlight", GTK_STOCK_UNDERLINE, N_("Show _Highlight"), "F7", N_("Show Highlight"), (GCallback)set_draw_highlight, TRUE },
+ { "ShowScale", NULL, N_("Show _Scale"), "<shift>F5", N_("Show Scale"), (GCallback)toggle_draw_scale, TRUE },
+ { "ShowCenterMark", NULL, N_("Show _Center Mark"), "F6", N_("Show Center Mark"), (GCallback)toggle_draw_centermark, TRUE },
+ { "ShowHighlight", GTK_STOCK_UNDERLINE, N_("Show _Highlight"), "F7", N_("Show Highlight"), (GCallback)toggle_draw_highlight, TRUE },
{ "FullScreen", GTK_STOCK_FULLSCREEN, N_("_Full Screen"), "F11", N_("Activate full screen mode"), (GCallback)full_screen_cb, FALSE },
{ "ViewSidePanel", GTK_STOCK_INDEX, N_("Show Side _Panel"), "F9", N_("Show Side Panel"), (GCallback)view_side_panel_cb, TRUE },
{ "ViewStatusBar", NULL, N_("Show Status_bar"), "F12", N_("Show Statusbar"), (GCallback)view_statusbar_cb, TRUE },
{ "ViewMainMenu", NULL, N_("Show _Menu"), "F4", N_("Show Menu"), (GCallback)view_main_menu_cb, TRUE },
};
+// This must match the toggle entries order above
+static gpointer toggle_entries_toolbar_cb[] = {
+ (GCallback)tb_set_draw_scale,
+ (GCallback)tb_set_draw_centermark,
+ (GCallback)tb_set_draw_highlight,
+ (GCallback)tb_full_screen_cb,
+ (GCallback)tb_view_side_panel_cb,
+ (GCallback)tb_view_statusbar_cb,
+ (GCallback)tb_view_toolbar_cb,
+ (GCallback)tb_view_main_menu_cb,
+};
+
#include "menu.xml.h"
static void window_create_ui( VikWindow *window )
{
toolbox_add_tool(window->vt, &pan_tool, TOOL_LAYER_TYPE_NONE);
toolbox_add_tool(window->vt, &select_tool, TOOL_LAYER_TYPE_NONE);
+ toolbar_action_tool_entry_register ( window->viking_vtb, &pan_tool.radioActionEntry );
+ toolbar_action_tool_entry_register ( window->viking_vtb, &zoom_tool.radioActionEntry );
+ toolbar_action_tool_entry_register ( window->viking_vtb, &ruler_tool.radioActionEntry );
+ toolbar_action_tool_entry_register ( window->viking_vtb, &select_tool.radioActionEntry );
+
error = NULL;
if (!(mid = gtk_ui_manager_add_ui_from_string (uim, menu_xml, -1, &error))) {
g_error_free (error);
gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries), window);
gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), window);
gtk_action_group_add_radio_actions (action_group, mode_entries, G_N_ELEMENTS (mode_entries), 4, (GCallback)window_change_coord_mode_cb, window);
+ if ( vik_debug ) {
+ if ( gtk_ui_manager_add_ui_from_string ( uim,
+ "<ui><menubar name='MainMenu'><menu action='Help'>"
+ "<menuitem action='MapCacheInfo'/>"
+ "<menuitem action='BackForwardInfo'/>"
+ "</menu></menubar></ui>",
+ -1, NULL ) ) {
+ gtk_action_group_add_actions (action_group, debug_entries, G_N_ELEMENTS (debug_entries), window);
+ }
+ }
+
+ for ( i=0; i < G_N_ELEMENTS (entries); i++ ) {
+ if ( entries[i].callback )
+ toolbar_action_entry_register ( window->viking_vtb, &entries[i] );
+ }
+
+ if ( G_N_ELEMENTS (toggle_entries) != G_N_ELEMENTS (toggle_entries_toolbar_cb) ) {
+ g_print ( "Broken entries definitions\n" );
+ exit (1);
+ }
+ for ( i=0; i < G_N_ELEMENTS (toggle_entries); i++ ) {
+ if ( toggle_entries_toolbar_cb[i] )
+ toolbar_action_toggle_entry_register ( window->viking_vtb, &toggle_entries[i], toggle_entries_toolbar_cb[i] );
+ }
+
+ for ( i=0; i < G_N_ELEMENTS (mode_entries); i++ ) {
+ toolbar_action_mode_entry_register ( window->viking_vtb, &mode_entries[i] );
+ }
+
+ // Use this to see if GPSBabel is available:
+ 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>" \
+ "<menu action='File'><menu action='Acquire'><menuitem action='AcquireGPS'/></menu></menu>" \
+ "<menu action='File'><menu action='Acquire'><menuitem action='AcquireGPSBabel'/></menu></menu>" \
+ "</menubar>" \
+ "</ui>",
+ -1, &error ) )
+ gtk_action_group_add_actions ( action_group, entries_gpsbabel, G_N_ELEMENTS (entries_gpsbabel), window );
+ }
+
+ // GeoJSON import capability
+ if ( g_find_program_in_path ( a_geojson_program_import() ) ) {
+ if ( gtk_ui_manager_add_ui_from_string ( uim,
+ "<ui><menubar name='MainMenu'><menu action='File'><menu action='Acquire'><menuitem action='AcquireGeoJSON'/></menu></menu></menubar></ui>",
+ -1, &error ) )
+ gtk_action_group_add_actions ( action_group, entries_geojson, G_N_ELEMENTS (entries_geojson), window );
+ }
icon_factory = gtk_icon_factory_new ();
gtk_icon_factory_add_default (icon_factory);
action.name = vik_layer_get_interface(i)->name;
action.stock_id = vik_layer_get_interface(i)->name;
- action.label = g_strdup_printf( _("New _%s Layer"), vik_layer_get_interface(i)->name);
+ action.label = g_strdup_printf( _("New _%s Layer"), _(vik_layer_get_interface(i)->name));
action.accelerator = vik_layer_get_interface(i)->accelerator;
action.tooltip = NULL;
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);
}
// Further tool copying for to apply to the UI, also apply menu UI setup
vik_layer_get_interface(i)->tools[j].radioActionEntry.label,
vik_layer_get_interface(i)->tools[j].radioActionEntry.name,
GTK_UI_MANAGER_MENUITEM, FALSE);
- gtk_ui_manager_add_ui(uim, mid, "/ui/MainToolbar/ToolItems",
- vik_layer_get_interface(i)->tools[j].radioActionEntry.label,
- vik_layer_get_interface(i)->tools[j].radioActionEntry.name,
- GTK_UI_MANAGER_TOOLITEM, FALSE);
toolbox_add_tool(window->vt, &(vik_layer_get_interface(i)->tools[j]), i);
+ toolbar_action_tool_entry_register ( window->viking_vtb, &(vik_layer_get_interface(i)->tools[j].radioActionEntry) );
*radio = vik_layer_get_interface(i)->tools[j].radioActionEntry;
// Overwrite with actual number to use
radio->value = ntools;
}
+
+ 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,
+ 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.name = g_strconcat("Layer", vik_layer_get_interface(i)->fixed_layer_name, NULL);
+ action_dl.stock_id = NULL;
+ action_dl.label = g_strconcat(_(vik_layer_get_interface(i)->name), _("..."), NULL);
+ action_dl.accelerator = NULL;
+ 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);
- gtk_action_group_add_radio_actions(action_group, tools, ntools, 0, (GCallback)menu_tool_cb, window);
+ gtk_action_group_add_radio_actions(action_group, tools, ntools, 0, (GCallback)menu_cb, window);
g_free(tools);
gtk_ui_manager_insert_action_group (uim, action_group, 0);
g_object_set(action, "sensitive", FALSE, NULL);
}
}
+
+ // This is done last so we don't need to track the value of mid anymore
+ vik_ext_tools_add_action_items ( window, window->uim, action_group, mid );
+
window->action_group = action_group;
accel_group = gtk_ui_manager_get_accel_group (uim);
gtk_ui_manager_ensure_update (uim);
setup_recent_files(window);
+
+ if ( vik_routing_number_of_engines(VIK_ROUTING_METHOD_DIRECTIONS) == 0 ) {
+ GtkWidget *widget = gtk_ui_manager_get_widget ( uim, "/ui/MainMenu/File/Acquire/AcquireRouting" );
+ if ( widget ) {
+ g_object_set ( widget, "sensitive", FALSE, NULL );
+ }
+ g_warning ( "No direction routing engines available" );
+ }
}
{ &zoom_18_pixbuf, "vik-icon-zoom" },
{ &ruler_18_pixbuf, "vik-icon-ruler" },
{ &select_18_pixbuf, "vik-icon-select" },
- { &begintr_18_pixbuf, "vik-icon-Begin Track" },
+ { &vik_new_route_18_pixbuf, "vik-icon-Create Route" },
{ &route_finder_18_pixbuf, "vik-icon-Route Finder" },
{ &demdl_18_pixbuf, "vik-icon-DEM Download" },
{ &showpic_18_pixbuf, "vik-icon-Show Picture" },
vik_viewport_set_highlight_thickness ( vw->viking_vvp, vik_trw_layer_get_property_tracks_line_thickness (vw->containing_vtl) );
}
-gpointer vik_window_get_selected_tracks ( VikWindow *vw )
+GHashTable *vik_window_get_selected_tracks ( VikWindow *vw )
{
return vw->selected_tracks;
}
-void vik_window_set_selected_tracks ( VikWindow *vw, gpointer gl, gpointer vtl )
+void vik_window_set_selected_tracks ( VikWindow *vw, GHashTable *ght, gpointer vtl )
{
- vw->selected_tracks = gl;
+ vw->selected_tracks = ght;
vw->containing_vtl = vtl;
/* Clear others */
vw->selected_vtl = NULL;
return vw->selected_track;
}
-void vik_window_set_selected_track ( VikWindow *vw, gpointer *vt, gpointer vtl, gpointer name )
+void vik_window_set_selected_track ( VikWindow *vw, gpointer *vt, gpointer vtl )
{
vw->selected_track = vt;
vw->containing_vtl = vtl;
vik_viewport_set_highlight_thickness ( vw->viking_vvp, vik_trw_layer_get_property_tracks_line_thickness (vw->containing_vtl) );
}
-gpointer vik_window_get_selected_waypoints ( VikWindow *vw )
+GHashTable *vik_window_get_selected_waypoints ( VikWindow *vw )
{
return vw->selected_waypoints;
}
-void vik_window_set_selected_waypoints ( VikWindow *vw, gpointer gl, gpointer vtl )
+void vik_window_set_selected_waypoints ( VikWindow *vw, GHashTable *ght, gpointer vtl )
{
- vw->selected_waypoints = gl;
+ vw->selected_waypoints = ght;
vw->containing_vtl = vtl;
/* Clear others */
vw->selected_vtl = NULL;
return vw->selected_waypoint;
}
-void vik_window_set_selected_waypoint ( VikWindow *vw, gpointer *vwp, gpointer vtl, gpointer name )
+void vik_window_set_selected_waypoint ( VikWindow *vw, gpointer *vwp, gpointer vtl )
{
vw->selected_waypoint = vwp;
vw->containing_vtl = vtl;
gboolean vik_window_clear_highlight ( VikWindow *vw )
{
gboolean need_redraw = FALSE;
+ vw->containing_vtl = NULL;
if ( vw->selected_vtl != NULL ) {
vw->selected_vtl = NULL;
need_redraw = TRUE;
}
return need_redraw;
}
+
+/**
+ * May return NULL if the window no longer exists
+ */
+GThread *vik_window_get_thread ( VikWindow *vw )
+{
+ if ( vw )
+ return vw->thread;
+ return NULL;
+}
projects / andy / viking.git / blobdiff