X-Git-Url: https://git.street.me.uk/andy/viking.git/blobdiff_plain/165d30aada5fcb1a190d25b8998a8187bb86ea36..ad6bd06af280e3fd53c18861c7a40a0921967f83:/src/vikviewport.c diff --git a/src/vikviewport.c b/src/vikviewport.c index 493db74a..cfbbd87c 100644 --- a/src/vikviewport.c +++ b/src/vikviewport.c @@ -1,7 +1,8 @@ /* * viking -- GPS Data and Topo Analyzer, Explorer, and Manager * - * Copyright (C) 2003-2005, Evan Battaglia + * Copyright (C) 2003-2007, Evan Battaglia + * Copyright (C) 2013, Rob Norris * * Lat/Lon plotting functions calcxy* are from GPSDrive * GPSDrive Copyright (C) 2001-2004 Fritz Ganter @@ -23,31 +24,43 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif #define DEFAULT_BACKGROUND_COLOR "#CCCCCC" +#define DEFAULT_HIGHLIGHT_COLOR "#EEA500" +/* Default highlight in orange */ #include +#ifdef HAVE_MATH_H #include -#include +#endif +#ifdef HAVE_STRING_H +#include +#endif #include "coords.h" #include "vikcoord.h" #include "vikwindow.h" #include "vikviewport.h" - #include "mapcoord.h" /* for ALTI_TO_MPP */ #include "globals.h" -#include "googlemaps.h" -#include "khmaps.h" +#include "settings.h" +#include "dialog.h" + +#define MERCATOR_FACTOR(x) ( (65536.0 / 180 / (x)) * 256.0 ) static gdouble EASTING_OFFSET = 500000.0; -static void viewport_class_init ( VikViewportClass *klass ); -static void viewport_init ( VikViewport *vvp ); +static gint PAD = 10; + static void viewport_finalize ( GObject *gob ); static void viewport_utm_zone_check ( VikViewport *vvp ); +static void update_centers ( VikViewport *vvp ); +static void free_centers ( VikViewport *vvp, guint start ); static gboolean calcxy(double *x, double *y, double lg, double lt, double zero_long, double zero_lat, double pixelfact_x, double pixelfact_y, gint mapSizeX2, gint mapSizeY2 ); static gboolean calcxy_rev(double *lg, double *lt, gint x, gint y, double zero_long, double zero_lat, double pixelfact_x, double pixelfact_y, gint mapSizeX2, gint mapSizeY2 ); @@ -58,16 +71,19 @@ static void viewport_init_ra(); static GObjectClass *parent_class; -static void viewport_google_rezoom ( VikViewport *vvp ); - - struct _VikViewport { GtkDrawingArea drawing_area; GdkPixmap *scr_buffer; gint width, height; + gint width_2, height_2; // Half of the normal width and height VikCoord center; VikCoordMode coord_mode; gdouble xmpp, ympp; + gdouble xmfactor, ymfactor; + GList *centers; // The history of requested positions (of VikCoord type) + guint centers_index; // current position within the history list + guint centers_max; // configurable maximum size of the history list + guint centers_radius; // Metres GdkPixbuf *alpha_pixbuf; guint8 alpha_pixbuf_width; @@ -79,18 +95,20 @@ struct _VikViewport { GdkGC *background_gc; GdkColor background_color; GdkGC *scale_bg_gc; + + GSList *copyrights; + GSList *logos; + + /* Wether or not display OSD info */ gboolean draw_scale; gboolean draw_centermark; + gboolean draw_highlight; + GdkGC *highlight_gc; + GdkColor highlight_color; /* subset of coord types. lat lon can be plotted in 2 ways, google or exp. */ VikViewportDrawMode drawmode; - /* handy conversion factors which make google plotting extremely fast */ - gdouble google_calcx_fact; - gdouble google_calcy_fact; - gdouble google_calcx_rev_fact; - gdouble google_calcy_rev_fact; - /* trigger stuff */ gpointer trigger; GdkPixmap *snapshot_buffer; @@ -116,31 +134,16 @@ viewport_utm_zone_width ( VikViewport *vvp ) return 0.0; } +enum { + VW_UPDATED_CENTER_SIGNAL = 0, + VW_LAST_SIGNAL, +}; +static guint viewport_signals[VW_LAST_SIGNAL] = { 0 }; -GType vik_viewport_get_type (void) -{ - static GType vvp_type = 0; +G_DEFINE_TYPE (VikViewport, vik_viewport, GTK_TYPE_DRAWING_AREA) - if (!vvp_type) - { - static const GTypeInfo vvp_info = - { - sizeof (VikViewportClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) viewport_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (VikViewport), - 0, - (GInstanceInitFunc) viewport_init, - }; - vvp_type = g_type_register_static ( GTK_TYPE_DRAWING_AREA, "VikViewport", &vvp_info, 0 ); - } - return vvp_type; -} - -static void viewport_class_init ( VikViewportClass *klass ) +static void +vik_viewport_class_init ( VikViewportClass *klass ) { /* Destructor */ GObjectClass *object_class; @@ -150,6 +153,10 @@ static void viewport_class_init ( VikViewportClass *klass ) object_class->finalize = viewport_finalize; parent_class = g_type_class_peek_parent (klass); + + viewport_signals[VW_UPDATED_CENTER_SIGNAL] = g_signal_new ( "updated_center", G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (VikViewportClass, updated_center), NULL, NULL, + g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); } VikViewport *vik_viewport_new () @@ -158,36 +165,87 @@ VikViewport *vik_viewport_new () return vv; } -static void viewport_init ( VikViewport *vvp ) +#define VIK_SETTINGS_VIEW_LAST_LATITUDE "viewport_last_latitude" +#define VIK_SETTINGS_VIEW_LAST_LONGITUDE "viewport_last_longitude" +#define VIK_SETTINGS_VIEW_LAST_ZOOM_X "viewport_last_zoom_xpp" +#define VIK_SETTINGS_VIEW_LAST_ZOOM_Y "viewport_last_zoom_ypp" +#define VIK_SETTINGS_VIEW_HISTORY_SIZE "viewport_history_size" +#define VIK_SETTINGS_VIEW_HISTORY_DIFF_DIST "viewport_history_diff_dist" + +static void +vik_viewport_init ( VikViewport *vvp ) { viewport_init_ra(); - /* TODO: not static */ - vvp->xmpp = 4.0; - vvp->ympp = 4.0; + struct UTM utm; + struct LatLon ll; + ll.lat = a_vik_get_default_lat(); + ll.lon = a_vik_get_default_long(); + gdouble zoom_x = 4.0; + gdouble zoom_y = 4.0; + + if ( a_vik_get_startup_method ( ) == VIK_STARTUP_METHOD_LAST_LOCATION ) { + gdouble lat, lon, dzoom; + if ( a_settings_get_double ( VIK_SETTINGS_VIEW_LAST_LATITUDE, &lat ) ) + ll.lat = lat; + if ( a_settings_get_double ( VIK_SETTINGS_VIEW_LAST_LONGITUDE, &lon ) ) + ll.lon = lon; + if ( a_settings_get_double ( VIK_SETTINGS_VIEW_LAST_ZOOM_X, &dzoom ) ) + zoom_x = dzoom; + if ( a_settings_get_double ( VIK_SETTINGS_VIEW_LAST_ZOOM_Y, &dzoom ) ) + zoom_y = dzoom; + } + + a_coords_latlon_to_utm ( &ll, &utm ); + + vvp->xmpp = zoom_x; + vvp->ympp = zoom_y; + vvp->xmfactor = MERCATOR_FACTOR (vvp->xmpp); + vvp->ymfactor = MERCATOR_FACTOR (vvp->ympp); vvp->coord_mode = VIK_COORD_LATLON; vvp->drawmode = VIK_VIEWPORT_DRAWMODE_MERCATOR; vvp->center.mode = VIK_COORD_LATLON; - vvp->center.north_south = 40.714490; - vvp->center.east_west = -74.007130; - vvp->center.utm_zone = 31; - vvp->center.utm_letter = 'N'; + vvp->center.north_south = ll.lat; + vvp->center.east_west = ll.lon; + vvp->center.utm_zone = (int)utm.zone; + vvp->center.utm_letter = utm.letter; vvp->scr_buffer = NULL; vvp->alpha_pixbuf = NULL; vvp->alpha_pixbuf_width = vvp->alpha_pixbuf_height = 0; vvp->utm_zone_width = 0.0; vvp->background_gc = NULL; + vvp->highlight_gc = NULL; vvp->scale_bg_gc = NULL; + + vvp->copyrights = NULL; + vvp->centers = NULL; + vvp->centers_index = 0; + vvp->centers_max = 20; + gint tmp = vvp->centers_max; + if ( a_settings_get_integer ( VIK_SETTINGS_VIEW_HISTORY_SIZE, &tmp ) ) + vvp->centers_max = tmp; + vvp->centers_radius = 500; + if ( a_settings_get_integer ( VIK_SETTINGS_VIEW_HISTORY_DIFF_DIST, &tmp ) ) + vvp->centers_radius = tmp; + vvp->draw_scale = TRUE; vvp->draw_centermark = TRUE; + vvp->draw_highlight = TRUE; vvp->trigger = NULL; vvp->snapshot_buffer = NULL; vvp->half_drawn = FALSE; + // Initiate center history + update_centers ( vvp ); + g_signal_connect (G_OBJECT(vvp), "configure_event", G_CALLBACK(vik_viewport_configure), NULL); +#if GTK_CHECK_VERSION (2,18,0) + gtk_widget_set_can_focus ( GTK_WIDGET(vvp), TRUE ); +#else GTK_WIDGET_SET_FLAGS(vvp, GTK_CAN_FOCUS); /* allow VVP to have focus -- enabling key events, etc */ +#endif } GdkColor *vik_viewport_get_background_gdkcolor ( VikViewport *vvp ) @@ -207,27 +265,70 @@ const gchar *vik_viewport_get_background_color ( VikViewport *vvp ) void vik_viewport_set_background_color ( VikViewport *vvp, const gchar *colorname ) { - g_assert ( vvp->background_gc ); - gdk_color_parse ( colorname, &(vvp->background_color) ); - gdk_gc_set_rgb_fg_color ( vvp->background_gc, &(vvp->background_color) ); + g_assert ( vvp && vvp->background_gc ); + if ( gdk_color_parse ( colorname, &(vvp->background_color) ) ) + gdk_gc_set_rgb_fg_color ( vvp->background_gc, &(vvp->background_color) ); + else + g_warning("%s: Failed to parse color '%s'", __FUNCTION__, colorname); } void vik_viewport_set_background_gdkcolor ( VikViewport *vvp, GdkColor *color ) { - g_assert ( vvp->background_gc ); + g_assert ( vvp && vvp->background_gc ); vvp->background_color = *color; gdk_gc_set_rgb_fg_color ( vvp->background_gc, color ); } +GdkColor *vik_viewport_get_highlight_gdkcolor ( VikViewport *vvp ) +{ + GdkColor *rv = g_malloc ( sizeof ( GdkColor ) ); + *rv = vvp->highlight_color; + return rv; +} + +/* returns pointer to internal static storage, changes next time function called, use quickly */ +const gchar *vik_viewport_get_highlight_color ( VikViewport *vvp ) +{ + static gchar color[8]; + g_snprintf(color, sizeof(color), "#%.2x%.2x%.2x", (int)(vvp->highlight_color.red/256),(int)(vvp->highlight_color.green/256),(int)(vvp->highlight_color.blue/256)); + return color; +} + +void vik_viewport_set_highlight_color ( VikViewport *vvp, const gchar *colorname ) +{ + g_assert ( vvp->highlight_gc ); + gdk_color_parse ( colorname, &(vvp->highlight_color) ); + gdk_gc_set_rgb_fg_color ( vvp->highlight_gc, &(vvp->highlight_color) ); +} + +void vik_viewport_set_highlight_gdkcolor ( VikViewport *vvp, GdkColor *color ) +{ + g_assert ( vvp->highlight_gc ); + vvp->highlight_color = *color; + gdk_gc_set_rgb_fg_color ( vvp->highlight_gc, color ); +} + +GdkGC *vik_viewport_get_gc_highlight ( VikViewport *vvp ) +{ + return vvp->highlight_gc; +} + +void vik_viewport_set_highlight_thickness ( VikViewport *vvp, gint thickness ) +{ + // Otherwise same GDK_* attributes as in vik_viewport_new_gc + gdk_gc_set_line_attributes ( vvp->highlight_gc, thickness, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND ); +} GdkGC *vik_viewport_new_gc ( VikViewport *vvp, const gchar *colorname, gint thickness ) { - GdkGC *rv; + GdkGC *rv = NULL; GdkColor color; - rv = gdk_gc_new ( GTK_WIDGET(vvp)->window ); - gdk_color_parse ( colorname, &color ); - gdk_gc_set_rgb_fg_color ( rv, &color ); + rv = gdk_gc_new ( gtk_widget_get_window(GTK_WIDGET(vvp)) ); + if ( gdk_color_parse ( colorname, &color ) ) + gdk_gc_set_rgb_fg_color ( rv, &color ); + else + g_warning("%s: Failed to parse color '%s'", __FUNCTION__, colorname); gdk_gc_set_line_attributes ( rv, thickness, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND ); return rv; } @@ -236,7 +337,7 @@ GdkGC *vik_viewport_new_gc_from_color ( VikViewport *vvp, GdkColor *color, gint { GdkGC *rv; - rv = gdk_gc_new ( GTK_WIDGET(vvp)->window ); + rv = gdk_gc_new ( gtk_widget_get_window(GTK_WIDGET(vvp)) ); gdk_gc_set_rgb_fg_color ( rv, color ); gdk_gc_set_line_attributes ( rv, thickness, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND ); return rv; @@ -246,14 +347,18 @@ void vik_viewport_configure_manually ( VikViewport *vvp, gint width, guint heigh { vvp->width = width; vvp->height = height; + + vvp->width_2 = vvp->width/2; + vvp->height_2 = vvp->height/2; + if ( vvp->scr_buffer ) g_object_unref ( G_OBJECT ( vvp->scr_buffer ) ); - vvp->scr_buffer = gdk_pixmap_new ( GTK_WIDGET(vvp)->window, vvp->width, vvp->height, -1 ); + vvp->scr_buffer = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), vvp->width, vvp->height, -1 ); /* TODO trigger: only if this is enabled !!! */ if ( vvp->snapshot_buffer ) g_object_unref ( G_OBJECT ( vvp->snapshot_buffer ) ); - vvp->snapshot_buffer = gdk_pixmap_new ( GTK_WIDGET(vvp)->window, vvp->width, vvp->height, -1 ); + vvp->snapshot_buffer = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), vvp->width, vvp->height, -1 ); } @@ -266,26 +371,36 @@ gboolean vik_viewport_configure ( VikViewport *vvp ) { g_return_val_if_fail ( vvp != NULL, TRUE ); - vvp->width = GTK_WIDGET(vvp)->allocation.width; - vvp->height = GTK_WIDGET(vvp)->allocation.height; + GtkAllocation allocation; + gtk_widget_get_allocation ( GTK_WIDGET(vvp), &allocation ); + vvp->width = allocation.width; + vvp->height = allocation.height; + + vvp->width_2 = vvp->width/2; + vvp->height_2 = vvp->height/2; if ( vvp->scr_buffer ) g_object_unref ( G_OBJECT ( vvp->scr_buffer ) ); - vvp->scr_buffer = gdk_pixmap_new ( GTK_WIDGET(vvp)->window, vvp->width, vvp->height, -1 ); + vvp->scr_buffer = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), vvp->width, vvp->height, -1 ); /* TODO trigger: only if enabled! */ if ( vvp->snapshot_buffer ) g_object_unref ( G_OBJECT ( vvp->snapshot_buffer ) ); - vvp->snapshot_buffer = gdk_pixmap_new ( GTK_WIDGET(vvp)->window, vvp->width, vvp->height, -1 ); + vvp->snapshot_buffer = gdk_pixmap_new ( gtk_widget_get_window(GTK_WIDGET(vvp)), vvp->width, vvp->height, -1 ); /* TODO trigger */ /* this is down here so it can get a GC (necessary?) */ - if ( ! vvp->background_gc ) + if ( !vvp->background_gc ) { - vvp->background_gc = vik_viewport_new_gc ( vvp, "", 1 ); - vik_viewport_set_background_color ( vvp, DEFAULT_BACKGROUND_COLOR ); /* set to "backup" color in vvp->background_color */ + vvp->background_gc = vik_viewport_new_gc ( vvp, DEFAULT_BACKGROUND_COLOR, 1 ); + vik_viewport_set_background_color ( vvp, DEFAULT_BACKGROUND_COLOR ); + } + if ( ! vvp->highlight_gc ) + { + vvp->highlight_gc = vik_viewport_new_gc ( vvp, DEFAULT_HIGHLIGHT_COLOR, 1 ); + vik_viewport_set_highlight_color ( vvp, DEFAULT_HIGHLIGHT_COLOR ); } if ( !vvp->scale_bg_gc) { vvp->scale_bg_gc = vik_viewport_new_gc(vvp, "grey", 3); @@ -300,6 +415,18 @@ static void viewport_finalize ( GObject *gob ) g_return_if_fail ( vvp != NULL ); + if ( a_vik_get_startup_method ( ) == VIK_STARTUP_METHOD_LAST_LOCATION ) { + struct LatLon ll; + vik_coord_to_latlon ( &(vvp->center), &ll ); + a_settings_set_double ( VIK_SETTINGS_VIEW_LAST_LATITUDE, ll.lat ); + a_settings_set_double ( VIK_SETTINGS_VIEW_LAST_LONGITUDE, ll.lon ); + a_settings_set_double ( VIK_SETTINGS_VIEW_LAST_ZOOM_X, vvp->xmpp ); + a_settings_set_double ( VIK_SETTINGS_VIEW_LAST_ZOOM_Y, vvp->ympp ); + } + + if ( vvp->centers ) + free_centers ( vvp, 0 ); + if ( vvp->scr_buffer ) g_object_unref ( G_OBJECT ( vvp->scr_buffer ) ); @@ -312,6 +439,9 @@ static void viewport_finalize ( GObject *gob ) if ( vvp->background_gc ) g_object_unref ( G_OBJECT ( vvp->background_gc ) ); + if ( vvp->highlight_gc ) + g_object_unref ( G_OBJECT ( vvp->highlight_gc ) ); + if ( vvp->scale_bg_gc ) { g_object_unref ( G_OBJECT ( vvp->scale_bg_gc ) ); vvp->scale_bg_gc = NULL; @@ -320,12 +450,27 @@ static void viewport_finalize ( GObject *gob ) G_OBJECT_CLASS(parent_class)->finalize(gob); } +/** + * vik_viewport_clear: + * @vvp: self object + * + * Clear the whole viewport. + */ void vik_viewport_clear ( VikViewport *vvp ) { g_return_if_fail ( vvp != NULL ); gdk_draw_rectangle(GDK_DRAWABLE(vvp->scr_buffer), vvp->background_gc, TRUE, 0, 0, vvp->width, vvp->height); + vik_viewport_reset_copyrights ( vvp ); + vik_viewport_reset_logos ( vvp ); } +/** + * vik_viewport_set_draw_scale: + * @vvp: self + * @draw_scale: new value + * + * Enable/Disable display of scale. + */ void vik_viewport_set_draw_scale ( VikViewport *vvp, gboolean draw_scale ) { vvp->draw_scale = draw_scale; @@ -338,20 +483,35 @@ gboolean vik_viewport_get_draw_scale ( VikViewport *vvp ) void vik_viewport_draw_scale ( VikViewport *vvp ) { + g_return_if_fail ( vvp != NULL ); + if ( vvp->draw_scale ) { VikCoord left, right; gdouble unit, base, diff, old_unit, old_diff, ratio; - gint odd, len, PAD = 10, SCSIZE = 5, HEIGHT=10; - PangoFontDescription *pfd; + gint odd, len, SCSIZE = 5, HEIGHT=10; PangoLayout *pl; gchar s[128]; - g_return_if_fail ( vvp != NULL ); - - vik_viewport_screen_to_coord ( vvp, 0, vvp->height, &left ); - vik_viewport_screen_to_coord ( vvp, vvp->width/SCSIZE, vvp->height, &right ); - - base = vik_coord_diff ( &left, &right ); // in meters + vik_viewport_screen_to_coord ( vvp, 0, vvp->height/2, &left ); + vik_viewport_screen_to_coord ( vvp, vvp->width/SCSIZE, vvp->height/2, &right ); + + vik_units_distance_t dist_units = a_vik_get_units_distance (); + switch (dist_units) { + case VIK_UNITS_DISTANCE_KILOMETRES: + base = vik_coord_diff ( &left, &right ); // in meters + break; + case VIK_UNITS_DISTANCE_MILES: + // in 0.1 miles (copes better when zoomed in as 1 mile can be too big) + base = VIK_METERS_TO_MILES(vik_coord_diff ( &left, &right )) * 10.0; + break; + case VIK_UNITS_DISTANCE_NAUTICAL_MILES: + // in 0.1 NM (copes better when zoomed in as 1 NM can be too big) + base = VIK_METERS_TO_NAUTICAL_MILES(vik_coord_diff ( &left, &right )) * 10.0; + break; + default: + base = 1; // Keep the compiler happy + g_critical("Houston, we've had a problem. distance=%d", dist_units); + } ratio = (vvp->width/SCSIZE)/base; unit = 1; @@ -377,45 +537,133 @@ void vik_viewport_draw_scale ( VikViewport *vvp ) vik_viewport_draw_line(vvp, vvp->scale_bg_gc, PAD + len, vvp->height-PAD, PAD + len, vvp->height-PAD-HEIGHT); /* black scale */ - vik_viewport_draw_line(vvp, GTK_WIDGET(&vvp->drawing_area)->style->black_gc, + vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD, vvp->height-PAD, PAD + len, vvp->height-PAD); - vik_viewport_draw_line(vvp, GTK_WIDGET(&vvp->drawing_area)->style->black_gc, + vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD, vvp->height-PAD, PAD, vvp->height-PAD-HEIGHT); - vik_viewport_draw_line(vvp, GTK_WIDGET(&vvp->drawing_area)->style->black_gc, + vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD + len, vvp->height-PAD, PAD + len, vvp->height-PAD-HEIGHT); if (odd%2) { int i; for (i=1; i<5; i++) { vik_viewport_draw_line(vvp, vvp->scale_bg_gc, - PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); - vik_viewport_draw_line(vvp, GTK_WIDGET(&vvp->drawing_area)->style->black_gc, - PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); + PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-(HEIGHT/2)); + vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, + PAD+i*len/5, vvp->height-PAD, PAD+i*len/5, vvp->height-PAD-(HEIGHT/2)); } } else { int i; for (i=1; i<10; i++) { vik_viewport_draw_line(vvp, vvp->scale_bg_gc, PAD+i*len/10, vvp->height-PAD, PAD+i*len/10, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); - vik_viewport_draw_line(vvp, GTK_WIDGET(&vvp->drawing_area)->style->black_gc, + vik_viewport_draw_line(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD+i*len/10, vvp->height-PAD, PAD+i*len/10, vvp->height-PAD-((i==5)?(2*HEIGHT/3):(HEIGHT/2))); } } pl = gtk_widget_create_pango_layout (GTK_WIDGET(&vvp->drawing_area), 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); - - if (unit >= 1000) { - sprintf(s, "%d km", (int)unit/1000); - } else { - sprintf(s, "%d m", (int)unit); + pango_layout_set_font_description (pl, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->font_desc); + + switch (dist_units) { + case VIK_UNITS_DISTANCE_KILOMETRES: + if (unit >= 1000) { + sprintf(s, "%d km", (int)unit/1000); + } else { + sprintf(s, "%d m", (int)unit); + } + break; + case VIK_UNITS_DISTANCE_MILES: + // Handle units in 0.1 miles + if (unit < 10.0) { + sprintf(s, "%0.1f miles", unit/10.0); + } + else if ((int)unit == 10.0) { + sprintf(s, "1 mile"); + } + else { + sprintf(s, "%d miles", (int)(unit/10.0)); + } + break; + case VIK_UNITS_DISTANCE_NAUTICAL_MILES: + // Handle units in 0.1 NM + if (unit < 10.0) { + sprintf(s, "%0.1f NM", unit/10.0); + } + else if ((int)unit == 10.0) { + sprintf(s, "1 NM"); + } + else { + sprintf(s, "%d NMs", (int)(unit/10.0)); + } + break; + default: + g_critical("Houston, we've had a problem. distance=%d", dist_units); } pango_layout_set_text(pl, s, -1); - vik_viewport_draw_layout(vvp, GTK_WIDGET(&vvp->drawing_area)->style->black_gc, + vik_viewport_draw_layout(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, PAD + len + PAD, vvp->height - PAD - 10, pl); + g_object_unref(pl); + pl = NULL; + } +} + +void vik_viewport_draw_copyright ( VikViewport *vvp ) +{ + g_return_if_fail ( vvp != NULL ); + + PangoLayout *pl; + PangoRectangle ink_rect, logical_rect; + gchar s[128] = ""; + + /* compute copyrights string */ + guint len = g_slist_length ( vvp->copyrights ); + + int i; + for (i = 0 ; i < len ; i++) + { + // Stop when buffer is full + int slen = strlen ( s ); + if ( slen >= 127 ) + break; + + gchar *copyright = g_slist_nth_data ( vvp->copyrights, i ); + + // Only use part of this copyright that fits in the available space left + // remembering 1 character is left available for the appended space + int clen = strlen ( copyright ); + if ( slen + clen > 126 ) { + clen = 126 - slen; + } + + strncat ( s, copyright, clen ); + strcat ( s, " " ); } + + /* create pango layout */ + pl = gtk_widget_create_pango_layout (GTK_WIDGET(&vvp->drawing_area), NULL); + pango_layout_set_font_description (pl, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->font_desc); + pango_layout_set_alignment ( pl, PANGO_ALIGN_RIGHT ); + + /* Set the text */ + pango_layout_set_text(pl, s, -1); + + /* Use maximum of half the viewport width */ + pango_layout_set_width ( pl, ( vvp->width / 2 ) * PANGO_SCALE ); + pango_layout_get_pixel_extents(pl, &ink_rect, &logical_rect); + vik_viewport_draw_layout(vvp, gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc, + vvp->width / 2, vvp->height - logical_rect.height, pl); + + /* Free memory */ + g_object_unref(pl); + pl = NULL; } +/** + * vik_viewport_set_draw_centermark: + * @vvp: self object + * @draw_centermark: new value + * + * Enable/Disable display of center mark. + */ void vik_viewport_set_draw_centermark ( VikViewport *vvp, gboolean draw_centermark ) { vvp->draw_centermark = draw_centermark; @@ -428,6 +676,8 @@ gboolean vik_viewport_get_draw_centermark ( VikViewport *vvp ) void vik_viewport_draw_centermark ( VikViewport *vvp ) { + g_return_if_fail ( vvp != NULL ); + if ( !vvp->draw_centermark ) return; @@ -435,7 +685,7 @@ void vik_viewport_draw_centermark ( VikViewport *vvp ) const int gap = 4; int center_x = vvp->width/2; int center_y = vvp->height/2; - GdkGC * black_gc = GTK_WIDGET(&vvp->drawing_area)->style->black_gc; + GdkGC * black_gc = gtk_widget_get_style(GTK_WIDGET(&vvp->drawing_area))->black_gc; /* white back ground */ vik_viewport_draw_line(vvp, vvp->scale_bg_gc, center_x - len, center_y, center_x - gap, center_y); @@ -450,10 +700,38 @@ void vik_viewport_draw_centermark ( VikViewport *vvp ) } +void vik_viewport_draw_logo ( VikViewport *vvp ) +{ + g_return_if_fail ( vvp != NULL ); + + guint len = g_slist_length ( vvp->logos ); + gint x = vvp->width - PAD; + gint y = PAD; + int i; + for (i = 0 ; i < len ; i++) + { + GdkPixbuf *logo = g_slist_nth_data ( vvp->logos, i ); + gint width = gdk_pixbuf_get_width ( logo ); + gint height = gdk_pixbuf_get_height ( logo ); + vik_viewport_draw_pixbuf ( vvp, logo, 0, 0, x - width, y, width, height ); + x = x - width - PAD; + } +} + +void vik_viewport_set_draw_highlight ( VikViewport *vvp, gboolean draw_highlight ) +{ + vvp->draw_highlight = draw_highlight; +} + +gboolean vik_viewport_get_draw_highlight ( VikViewport *vvp ) +{ + return vvp->draw_highlight; +} + void vik_viewport_sync ( VikViewport *vvp ) { g_return_if_fail ( vvp != NULL ); - gdk_draw_drawable(GTK_WIDGET(vvp)->window, GTK_WIDGET(vvp)->style->bg_gc[0], GDK_DRAWABLE(vvp->scr_buffer), 0, 0, 0, 0, vvp->width, vvp->height); + gdk_draw_drawable(gtk_widget_get_window(GTK_WIDGET(vvp)), gtk_widget_get_style(GTK_WIDGET(vvp))->bg_gc[0], GDK_DRAWABLE(vvp->scr_buffer), 0, 0, 0, 0, vvp->width, vvp->height); } void vik_viewport_pan_sync ( VikViewport *vvp, gint x_off, gint y_off ) @@ -461,7 +739,7 @@ void vik_viewport_pan_sync ( VikViewport *vvp, gint x_off, gint y_off ) gint x, y, wid, hei; g_return_if_fail ( vvp != NULL ); - gdk_draw_drawable(GTK_WIDGET(vvp)->window, GTK_WIDGET(vvp)->style->bg_gc[0], GDK_DRAWABLE(vvp->scr_buffer), 0, 0, x_off, y_off, vvp->width, vvp->height); + gdk_draw_drawable(gtk_widget_get_window(GTK_WIDGET(vvp)), gtk_widget_get_style(GTK_WIDGET(vvp))->bg_gc[0], GDK_DRAWABLE(vvp->scr_buffer), 0, 0, x_off, y_off, vvp->width, vvp->height); if (x_off >= 0) { x = 0; @@ -484,13 +762,14 @@ void vik_viewport_pan_sync ( VikViewport *vvp, gint x_off, gint y_off ) void vik_viewport_set_zoom ( VikViewport *vvp, gdouble xympp ) { g_return_if_fail ( vvp != NULL ); - if ( xympp >= VIK_VIEWPORT_MIN_ZOOM && xympp <= VIK_VIEWPORT_MAX_ZOOM ) + if ( xympp >= VIK_VIEWPORT_MIN_ZOOM && xympp <= VIK_VIEWPORT_MAX_ZOOM ) { vvp->xmpp = vvp->ympp = xympp; + // Since xmpp & ympp are the same it doesn't matter which one is used here + vvp->xmfactor = vvp->ymfactor = MERCATOR_FACTOR(vvp->xmpp); + } if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_UTM ) viewport_utm_zone_check(vvp); - else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) - viewport_google_rezoom ( vvp ); } /* or could do factor */ @@ -502,8 +781,8 @@ void vik_viewport_zoom_in ( VikViewport *vvp ) vvp->xmpp /= 2; vvp->ympp /= 2; - if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) - viewport_google_rezoom ( vvp ); + vvp->xmfactor = MERCATOR_FACTOR(vvp->xmpp); + vvp->ymfactor = MERCATOR_FACTOR(vvp->ympp); viewport_utm_zone_check(vvp); } @@ -517,8 +796,8 @@ void vik_viewport_zoom_out ( VikViewport *vvp ) vvp->xmpp *= 2; vvp->ympp *= 2; - if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) - viewport_google_rezoom ( vvp ); + vvp->xmfactor = MERCATOR_FACTOR(vvp->xmpp); + vvp->ymfactor = MERCATOR_FACTOR(vvp->ympp); viewport_utm_zone_check(vvp); } @@ -545,10 +824,9 @@ void vik_viewport_set_xmpp ( VikViewport *vvp, gdouble xmpp ) { if ( xmpp >= VIK_VIEWPORT_MIN_ZOOM && xmpp <= VIK_VIEWPORT_MAX_ZOOM ) { vvp->xmpp = xmpp; + vvp->ymfactor = MERCATOR_FACTOR(vvp->ympp); if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_UTM ) viewport_utm_zone_check(vvp); - if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) - viewport_google_rezoom ( vvp ); } } @@ -556,10 +834,9 @@ void vik_viewport_set_ympp ( VikViewport *vvp, gdouble ympp ) { if ( ympp >= VIK_VIEWPORT_MIN_ZOOM && ympp <= VIK_VIEWPORT_MAX_ZOOM ) { vvp->ympp = ympp; + vvp->ymfactor = MERCATOR_FACTOR(vvp->ympp); if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_UTM ) viewport_utm_zone_check(vvp); - if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) - viewport_google_rezoom ( vvp ); } } @@ -588,23 +865,241 @@ static void viewport_utm_zone_check ( VikViewport *vvp ) } } -void vik_viewport_set_center_latlon ( VikViewport *vvp, const struct LatLon *ll ) +/** + * Free an individual center position in the history list + */ +static void free_center ( VikViewport *vvp, guint index ) +{ + VikCoord *coord = g_list_nth_data ( vvp->centers, index ); + if ( coord ) + g_free ( coord ); + GList *gl = g_list_nth ( vvp->centers, index ); + if ( gl ) + vvp->centers = g_list_delete_link ( vvp->centers, gl ); +} + +/** + * Free a set of center positions in the history list, + * from the indicated start index to the end of the list + */ +static void free_centers ( VikViewport *vvp, guint start ) +{ + // Have to work backward since we delete items referenced by the '_nth()' values, + // otherwise if processed forward - removing the lower nth index entries would change the subsequent indexing + for ( guint i = g_list_length(vvp->centers)-1; i > start; i-- ) + free_center ( vvp, i ); +} + +/** + * Store the current center position into the history list + * and emit a signal to notify clients the list has been updated + */ +static void update_centers ( VikViewport *vvp ) +{ + VikCoord *new_center = g_malloc(sizeof (VikCoord)); + *new_center = vvp->center; + + if ( vvp->centers_index ) { + + if ( vvp->centers_index == vvp->centers_max-1 ) { + // List is full, so drop the oldest value to make room for the new one + free_center ( vvp, 0 ); + vvp->centers_index--; + } + else { + // Reset the now unused section of the list + // Free from the index to the end + free_centers ( vvp, vvp->centers_index+1 ); + } + + } + + // Store new position + // NB ATM this can be the same location as the last one in the list + vvp->centers = g_list_append ( vvp->centers, new_center ); + + // Reset to the end (NB should be same as centers_index++) + vvp->centers_index = g_list_length ( vvp->centers ) - 1; + + // Inform interested subscribers that this change has occurred + g_signal_emit ( G_OBJECT(vvp), viewport_signals[VW_UPDATED_CENTER_SIGNAL], 0 ); +} + +/** + * Show the list of forward/backward positions + * ATM only for debug usage + */ +void vik_viewport_show_centers ( VikViewport *vvp, GtkWindow *parent ) +{ + GList* node = NULL; + GList* texts = NULL; + gint index = 0; + for (node = vvp->centers; node != NULL; node = g_list_next(node)) { + gchar *lat = NULL, *lon = NULL; + struct LatLon ll; + vik_coord_to_latlon (node->data, &ll); + a_coords_latlon_to_string ( &ll, &lat, &lon ); + gchar *extra = NULL; + if ( index == vvp->centers_index-1 ) + extra = g_strdup ( " [Back]" ); + else if ( index == vvp->centers_index+1 ) + extra = g_strdup ( " [Forward]" ); + else + extra = g_strdup ( "" ); + texts = g_list_prepend ( texts , g_strdup_printf ( "%s %s%s", lat, lon, extra ) ); + g_free ( lat ); + g_free ( lon ); + g_free ( extra ); + index++; + } + + // NB: No i18n as this is just for debug + // Using this function the dialog allows sorting of the list which isn't appropriate here + // but this doesn't matter much for debug purposes of showing stuff... + GList *ans = a_dialog_select_from_list(parent, + texts, + FALSE, + "Back/Forward Locations", + "Back/Forward Locations"); + for (node = ans; node != NULL; node = g_list_next(node)) + g_free(node->data); + g_list_free(ans); + for (node = texts; node != NULL; node = g_list_next(node)) + g_free(node->data); + g_list_free(texts); +} + +/** + * vik_viewport_go_back: + * + * Move back in the position history + * + * Returns: %TRUE one success + */ +gboolean vik_viewport_go_back ( VikViewport *vvp ) +{ + // see if the current position is different from the last saved center position within a certain radius + VikCoord *center = g_list_nth_data ( vvp->centers, vvp->centers_index ); + if ( center ) { + // Consider an exclusion size (should it zoom level dependent, rather than a fixed value?) + // When still near to the last saved position we'll jump over it to the one before + if ( vik_coord_diff ( center, &vvp->center ) > vvp->centers_radius ) { + + if ( vvp->centers_index == g_list_length(vvp->centers)-1 ) { + // Only when we haven't already moved back in the list + // Remember where this request came from + // (alternatively we could insert in the list on every back attempt) + update_centers ( vvp ); + } + + } + // 'Go back' if possible + // NB if we inserted a position above, then this will then move to the last saved position + // otherwise this will skip to the previous saved position, as it's probably somewhere else. + if ( vvp->centers_index > 0 ) + vvp->centers_index--; + } + else { + return FALSE; + } + + VikCoord *new_center = g_list_nth_data ( vvp->centers, vvp->centers_index ); + if ( new_center ) { + vik_viewport_set_center_coord ( vvp, new_center, FALSE ); + return TRUE; + } + return FALSE; +} + +/** + * vik_viewport_go_forward: + * + * Move forward in the position history + * + * Returns: %TRUE one success + */ +gboolean vik_viewport_go_forward ( VikViewport *vvp ) +{ + if ( vvp->centers_index == vvp->centers_max-1 ) + return FALSE; + + vvp->centers_index++; + VikCoord *new_center = g_list_nth_data ( vvp->centers, vvp->centers_index ); + if ( new_center ) { + vik_viewport_set_center_coord ( vvp, new_center, FALSE ); + return TRUE; + } + else + // Set to end of list + vvp->centers_index = g_list_length(vvp->centers) - 1; + + return FALSE; +} + +/** + * vik_viewport_back_available: + * + * Returns: %TRUE when a previous position in the history is available + */ +gboolean vik_viewport_back_available ( const VikViewport *vvp ) +{ + return ( vvp->centers_index > 0 ); +} + +/** + * vik_viewport_forward_available: + * + * Returns: %TRUE when a next position in the history is available + */ +gboolean vik_viewport_forward_available ( const VikViewport *vvp ) +{ + return ( vvp->centers_index < g_list_length(vvp->centers)-1 ); +} + +/** + * vik_viewport_set_center_latlon: + * @vvp: The viewport to reposition. + * @ll: The new center position in Lat/Lon format + * @save_position: Whether this new position should be saved into the history of positions + * Normally only specific user requests should be saved (i.e. to not include Pan and Zoom repositions) + */ +void vik_viewport_set_center_latlon ( VikViewport *vvp, const struct LatLon *ll, gboolean save_position ) { vik_coord_load_from_latlon ( &(vvp->center), vvp->coord_mode, ll ); + if ( save_position ) + update_centers ( vvp ); if ( vvp->coord_mode == VIK_COORD_UTM ) viewport_utm_zone_check ( vvp ); } -void vik_viewport_set_center_utm ( VikViewport *vvp, const struct UTM *utm ) +/** + * vik_viewport_set_center_utm: + * @vvp: The viewport to reposition. + * @utm: The new center position in UTM format + * @save_position: Whether this new position should be saved into the history of positions + * Normally only specific user requests should be saved (i.e. to not include Pan and Zoom repositions) + */ +void vik_viewport_set_center_utm ( VikViewport *vvp, const struct UTM *utm, gboolean save_position ) { vik_coord_load_from_utm ( &(vvp->center), vvp->coord_mode, utm ); + if ( save_position ) + update_centers ( vvp ); if ( vvp->coord_mode == VIK_COORD_UTM ) viewport_utm_zone_check ( vvp ); } -void vik_viewport_set_center_coord ( VikViewport *vvp, const VikCoord *coord ) +/** + * vik_viewport_set_center_coord: + * @vvp: The viewport to reposition. + * @coord: The new center position in a VikCoord type + * @save_position: Whether this new position should be saved into the history of positions + * Normally only specific user requests should be saved (i.e. to not include Pan and Zoom repositions) + */ +void vik_viewport_set_center_coord ( VikViewport *vvp, const VikCoord *coord, gboolean save_position ) { vvp->center = *coord; + if ( save_position ) + update_centers ( vvp ); if ( vvp->coord_mode == VIK_COORD_UTM ) viewport_utm_zone_check ( vvp ); } @@ -667,7 +1162,7 @@ void vik_viewport_set_center_screen ( VikViewport *vvp, int x, int y ) } else { VikCoord tmp; vik_viewport_screen_to_coord ( vvp, x, y, &tmp ); - vik_viewport_set_center_coord ( vvp, &tmp ); + vik_viewport_set_center_coord ( vvp, &tmp, FALSE ); } } @@ -685,47 +1180,41 @@ gint vik_viewport_get_height( VikViewport *vvp ) void vik_viewport_screen_to_coord ( VikViewport *vvp, int x, int y, VikCoord *coord ) { + g_return_if_fail ( vvp != NULL ); + if ( vvp->coord_mode == VIK_COORD_UTM ) { int zone_delta; struct UTM *utm = (struct UTM *) coord; coord->mode = VIK_COORD_UTM; - g_return_if_fail ( vvp != NULL ); - utm->zone = vvp->center.utm_zone; utm->letter = vvp->center.utm_letter; - utm->easting = ( ( x - ( vvp->width / 2) ) * vvp->xmpp ) + vvp->center.east_west; + utm->easting = ( ( x - ( vvp->width_2) ) * vvp->xmpp ) + vvp->center.east_west; zone_delta = floor( (utm->easting - EASTING_OFFSET ) / vvp->utm_zone_width + 0.5 ); utm->zone += zone_delta; utm->easting -= zone_delta * vvp->utm_zone_width; - utm->northing = ( ( ( vvp->height / 2) - y ) * vvp->ympp ) + vvp->center.north_south; + utm->northing = ( ( ( vvp->height_2) - y ) * vvp->ympp ) + vvp->center.north_south; } else if ( vvp->coord_mode == VIK_COORD_LATLON ) { coord->mode = VIK_COORD_LATLON; - if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_EXPEDIA ) - calcxy_rev(&(coord->east_west), &(coord->north_south), x, y, vvp->center.east_west, vvp->center.north_south, vvp->xmpp * ALTI_TO_MPP, vvp->ympp * ALTI_TO_MPP, vvp->width/2, vvp->height/2); - else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) { - /* google */ - coord->east_west = (x - (vvp->width/2)) * vvp->google_calcx_rev_fact + vvp->center.east_west; - coord->north_south = ((vvp->height/2) - y) * vvp->google_calcy_rev_fact + vvp->center.north_south; - } else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_KH ) { - coord->east_west = vvp->center.east_west + (180.0 * vvp->xmpp / 65536 / 256 * (x - vvp->width/2)); - coord->north_south = vvp->center.north_south + (180.0 * vvp->ympp / 65536 / 256 * (vvp->height/2 - y)); - } else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_MERCATOR ) { - /* FIXMERCATOR */ - coord->east_west = vvp->center.east_west + (180.0 * vvp->xmpp / 65536 / 256 * (x - vvp->width/2)); - coord->north_south = DEMERCLAT ( MERCLAT(vvp->center.north_south) + (180.0 * vvp->ympp / 65536 / 256 * (vvp->height/2 - y)) ); - -#if 0 ---> THIS IS JUNK HERE. - *y = vvp->height/2 + (65536.0 / 180 / vvp->ympp * (MERCLAT(center->lat) - MERCLAT(ll->lat)))*256.0; - - (*y - vvp->height/2) / 256 / 65536 * 180 * vvp->ympp = (MERCLAT(center->lat) - MERCLAT(ll->lat); - DML((180.0 * vvp->ympp / 65536 / 256 * (vvp->height/2 - y)) + ML(cl)) = ll -#endif + if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_LATLON ) { + coord->east_west = vvp->center.east_west + (180.0 * vvp->xmpp / 65536 / 256 * (x - vvp->width_2)); + coord->north_south = vvp->center.north_south + (180.0 * vvp->ympp / 65536 / 256 * (vvp->height_2 - y)); + } else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_EXPEDIA ) + calcxy_rev(&(coord->east_west), &(coord->north_south), x, y, vvp->center.east_west, vvp->center.north_south, vvp->xmpp * ALTI_TO_MPP, vvp->ympp * ALTI_TO_MPP, vvp->width_2, vvp->height_2); + else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_MERCATOR ) { + /* This isn't called with a high frequently so less need to optimize */ + coord->east_west = vvp->center.east_west + (180.0 * vvp->xmpp / 65536 / 256 * (x - vvp->width_2)); + coord->north_south = DEMERCLAT ( MERCLAT(vvp->center.north_south) + (180.0 * vvp->ympp / 65536 / 256 * (vvp->height_2 - y)) ); } } } +/* + * Since this function is used for every drawn trackpoint - it can get called alot + * Thus x & y position factors are calculated once on zoom changes, + * avoiding the need to do it here all the time. + * For good measure the half width and height values are also pre calculated too. + */ void vik_viewport_coord_to_screen ( VikViewport *vvp, const VikCoord *coord, int *x, int *y ) { static VikCoord tmp; @@ -747,54 +1236,76 @@ void vik_viewport_coord_to_screen ( VikViewport *vvp, const VikCoord *coord, int return; } - *x = ( (utm->easting - center->easting) / vvp->xmpp ) + (vvp->width / 2) - + *x = ( (utm->easting - center->easting) / vvp->xmpp ) + (vvp->width_2) - (center->zone - utm->zone ) * vvp->utm_zone_width / vvp->xmpp; - *y = (vvp->height / 2) - ( (utm->northing - center->northing) / vvp->ympp ); + *y = (vvp->height_2) - ( (utm->northing - center->northing) / vvp->ympp ); } else if ( vvp->coord_mode == VIK_COORD_LATLON ) { struct LatLon *center = (struct LatLon *) &(vvp->center); struct LatLon *ll = (struct LatLon *) coord; double xx,yy; - if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_EXPEDIA ) { - calcxy ( &xx, &yy, center->lon, center->lat, ll->lon, ll->lat, vvp->xmpp * ALTI_TO_MPP, vvp->ympp * ALTI_TO_MPP, vvp->width / 2, vvp->height / 2 ); + if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_LATLON ) { + *x = vvp->width_2 + ( MERCATOR_FACTOR(vvp->xmpp) * (ll->lon - center->lon) ); + *y = vvp->height_2 + ( MERCATOR_FACTOR(vvp->ympp) * (center->lat - ll->lat) ); + } else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_EXPEDIA ) { + calcxy ( &xx, &yy, center->lon, center->lat, ll->lon, ll->lat, vvp->xmpp * ALTI_TO_MPP, vvp->ympp * ALTI_TO_MPP, vvp->width_2, vvp->height_2 ); *x = xx; *y = yy; - } else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) { - /* google */ - *x = vvp->google_calcx_fact * (ll->lon - center->lon) + (vvp->width/2); - *y = vvp->google_calcy_fact * (center->lat - ll->lat) + (vvp->height/2); - } else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_KH ) { - /* subtract, convert to KH coords; blow it up by 256 */ - *x = vvp->width/2 + (65536.0 / 180 / vvp->xmpp * (ll->lon - center->lon))*256.0; - *y = vvp->height/2 + (65536.0 / 180 / vvp->ympp * (center->lat - ll->lat))*256.0; } else if ( vvp->drawmode == VIK_VIEWPORT_DRAWMODE_MERCATOR ) { - /* FIXMERCATOR: Optimize */ - *x = vvp->width/2 + (65536.0 / 180 / vvp->xmpp * (ll->lon - center->lon))*256.0; - *y = vvp->height/2 + (65536.0 / 180 / vvp->ympp * (MERCLAT(center->lat) - MERCLAT(ll->lat)))*256.0; + *x = vvp->width_2 + ( MERCATOR_FACTOR(vvp->xmpp) * (ll->lon - center->lon) ); + *y = vvp->height_2 + ( MERCATOR_FACTOR(vvp->ympp) * ( MERCLAT(center->lat) - MERCLAT(ll->lat) ) ); } } } -void a_viewport_clip_line ( gint *x1, gint *y1, gint *x2, gint *y2 ) +// Clip functions continually reduce the value by a factor until it is in the acceptable range +// whilst also scaling the other coordinate value. +static void clip_x ( gint *x1, gint *y1, gint *x2, gint *y2 ) +{ + while ( ABS(*x1) > 32768 ) { + *x1 = *x2 + (0.5 * (*x1-*x2)); + *y1 = *y2 + (0.5 * (*y1-*y2)); + } +} + +static void clip_y ( gint *x1, gint *y1, gint *x2, gint *y2 ) { - if ( *x1 > 20000 || *x1 < -20000 ) { - gdouble shrinkfactor = ABS(20000.0 / *x1); - *x1 = *x2 + (shrinkfactor * (*x1-*x2)); - *y1 = *y2 + (shrinkfactor * (*y1-*y2)); - } else if ( *y1 > 20000 || *y1 < -20000 ) { - gdouble shrinkfactor = ABS(20000.0 / *x1); - *x1 = *x2 + (shrinkfactor * (*x1-*x2)); - *y1 = *y2 + (shrinkfactor * (*y1-*y2)); - } else if ( *x2 > 20000 || *x2 < -20000 ) { - gdouble shrinkfactor = ABS(20000.0 / (gdouble)*x2); - *x2 = *x1 + (shrinkfactor * (*x2-*x1)); - *y2 = *y1 + (shrinkfactor * (*y2-*y1)); - g_print("%f, %d, %d\n", shrinkfactor, *x2, *y2); - } else if ( *y2 > 20000 || *y2 < -20000 ) { - gdouble shrinkfactor = ABS(20000.0 / (gdouble)*x2); - *x2 = *x1 + (shrinkfactor * (*x2-*x1)); - *y2 = *y1 + (shrinkfactor * (*y2-*y1)); + while ( ABS(*y1) > 32767 ) { + *x1 = *x2 + (0.5 * (*x1-*x2)); + *y1 = *y2 + (0.5 * (*y1-*y2)); } } +/** + * a_viewport_clip_line: + * @x1: screen coord + * @y1: screen coord + * @x2: screen coord + * @y2: screen coord + * + * Due to the seemingly undocumented behaviour of gdk_draw_line(), we need to restrict the range of values passed in. + * So despite it accepting gints, the effective range seems to be the actually the minimum C int range (2^16). + * This seems to be limitations coming from the X Window System. + * + * See http://www.rahul.net/kenton/40errs.html + * ERROR 7. Boundary conditions. + * "The X coordinate space is not infinite. + * Most drawing functions limit position, width, and height to 16 bit integers (sometimes signed, sometimes unsigned) of accuracy. + * Because most C compilers use 32 bit integers, Xlib will not complain if you exceed the 16 bit limit, but your results will usually not be what you expected. + * You should be especially careful of this if you are implementing higher level scalable graphics packages." + * + * This function should be called before calling gdk_draw_line(). + */ +void a_viewport_clip_line ( gint *x1, gint *y1, gint *x2, gint *y2 ) +{ + if ( *x1 > 32768 || *x1 < -32767 ) + clip_x ( x1, y1, x2, y2 ); + if ( *y1 > 32768 || *y1 < -32767 ) + clip_y ( x1, y1, x2, y2 ); + if ( *x2 > 32768 || *x2 < -32767 ) + clip_x ( x2, y2, x1, y1 ); + if ( *y2 > 32768 || *y2 < -32767 ) + clip_y ( x2, y2, x1, y1 ); +} + void vik_viewport_draw_line ( VikViewport *vvp, GdkGC *gc, gint x1, gint y1, gint x2, gint y2 ) { if ( ! ( ( x1 < 0 && x2 < 0 ) || ( y1 < 0 && y2 < 0 ) || @@ -807,7 +1318,8 @@ void vik_viewport_draw_line ( VikViewport *vvp, GdkGC *gc, gint x1, gint y1, gin void vik_viewport_draw_rectangle ( VikViewport *vvp, GdkGC *gc, gboolean filled, gint x1, gint y1, gint x2, gint y2 ) { - if ( x1 > -10 && x1 < vvp->width + 10 && y1 > -10 && y1 < vvp->height + 10 ) + // Using 32 as half the default waypoint image size, so this draws ensures the highlight gets done + if ( x1 > -32 && x1 < vvp->width + 32 && y1 > -32 && y1 < vvp->height + 32 ) gdk_draw_rectangle ( vvp->scr_buffer, gc, filled, x1, y1, x2, y2); } @@ -859,9 +1371,8 @@ void vik_viewport_draw_pixbuf ( VikViewport *vvp, GdkPixbuf *pixbuf, gint src_x, gint dest_x, gint dest_y, gint w, gint h ) { gdk_draw_pixbuf ( vvp->scr_buffer, -// GTK_WIDGET(vvp)->style->black_gc, -NULL, - pixbuf, + NULL, + pixbuf, src_x, src_y, dest_x, dest_y, w, h, GDK_RGB_DITHER_NONE, 0, 0 ); } @@ -900,19 +1411,18 @@ static gboolean calcxy_rev(double *lg, double *lt, gint x, gint y, double zero_l px = (mapSizeX2 - x) * pixelfact_x; py = (-mapSizeY2 + y) * pixelfact_y; - lat = zero_lat - py / Ra; lat = zero_lat - py / Ra; lon = zero_long - px / (Ra * - cos (lat * DEG2RAD)); + cos (DEG2RAD(lat))); - dif = lat * (1 - (cos ((fabs (lon - zero_long)) * DEG2RAD))); + dif = lat * (1 - (cos (DEG2RAD(fabs (lon - zero_long))))); lat = lat - dif / 1.5; lon = zero_long - px / (Ra * - cos (lat * DEG2RAD)); + cos (DEG2RAD(lat))); *lt = lat; *lg = lon; @@ -932,9 +1442,9 @@ static gboolean calcxy(double *x, double *y, double lg, double lt, double zero_l // lt *= rad2deg; Ra = Radius[90+(gint)lt]; *x = Ra * - cos (lt*DEG2RAD) * (lg - zero_long); + cos (DEG2RAD(lt)) * (lg - zero_long); *y = Ra * (lt - zero_lat); - dif = Ra * RAD2DEG * (1 - (cos ((DEG2RAD * (lg - zero_long))))); + dif = Ra * RAD2DEG(1 - (cos ((DEG2RAD(lg - zero_long))))); *y = *y + dif / 1.85; *x = *x / pixelfact_x; *y = *y / pixelfact_y; @@ -952,7 +1462,7 @@ static void viewport_init_ra() { gint i; for ( i = -90; i <= 90; i++) - Radius[i+90] = calcR ( (double)i ) * DEG2RAD; + Radius[i+90] = calcR ( DEG2RAD((double)i) ); done_before = TRUE; } } @@ -976,7 +1486,7 @@ double calcR (double lat) * = 0.081082 Eccentricity */ - lat = lat * DEG2RAD; + lat = DEG2RAD(lat); sc = sin (lat); x = a * (1.0 - e2); z = 1.0 - e2 * sc * sc; @@ -1018,8 +1528,6 @@ void vik_viewport_set_drawmode ( VikViewport *vvp, VikViewportDrawMode drawmode viewport_set_coord_mode ( vvp, VIK_COORD_UTM ); else { viewport_set_coord_mode ( vvp, VIK_COORD_LATLON ); - if ( drawmode == VIK_VIEWPORT_DRAWMODE_GOOGLE ) - viewport_google_rezoom ( vvp ); } } @@ -1028,14 +1536,6 @@ VikViewportDrawMode vik_viewport_get_drawmode ( VikViewport *vvp ) return vvp->drawmode; } -static void viewport_google_rezoom ( VikViewport *vvp ) -{ - vvp->google_calcx_fact = (GOOGLEMAPS_ZOOM_ONE_MPP * 65536.0 * 0.7716245833877 / vvp->xmpp); - vvp->google_calcy_fact = (GOOGLEMAPS_ZOOM_ONE_MPP * 65536.0 / vvp->ympp); - vvp->google_calcx_rev_fact = 1 / vvp->google_calcx_fact; - vvp->google_calcy_rev_fact = 1 / vvp->google_calcy_fact; -} - /******** triggering *******/ void vik_viewport_set_trigger ( VikViewport *vp, gpointer trigger ) { @@ -1104,3 +1604,96 @@ void vik_viewport_get_min_max_lat_lon ( VikViewport *vp, gdouble *min_lat, gdoub *max_lon = MAX(tright.east_west, bright.east_west); *min_lon = MIN(tleft.east_west, bleft.east_west); } + +void vik_viewport_reset_copyrights ( VikViewport *vp ) +{ + g_return_if_fail ( vp != NULL ); + g_slist_foreach ( vp->copyrights, (GFunc)g_free, NULL ); + g_slist_free ( vp->copyrights ); + vp->copyrights = NULL; +} + +/** + * vik_viewport_add_copyright: + * @vp: self object + * @copyright: new copyright to display + * + * Add a copyright to display on viewport. + */ +void vik_viewport_add_copyright ( VikViewport *vp, const gchar *copyright ) +{ + g_return_if_fail ( vp != NULL ); + if ( copyright ) + { + GSList *found = g_slist_find_custom ( vp->copyrights, copyright, (GCompareFunc)strcmp ); + if ( found == NULL ) + { + gchar *duple = g_strdup ( copyright ); + vp->copyrights = g_slist_prepend ( vp->copyrights, duple ); + } + } +} + +void vik_viewport_reset_logos ( VikViewport *vp ) +{ + g_return_if_fail ( vp != NULL ); + /* do not free elem */ + g_slist_free ( vp->logos ); + vp->logos = NULL; +} + +void vik_viewport_add_logo ( VikViewport *vp, const GdkPixbuf *logo ) +{ + g_return_if_fail ( vp != NULL ); + if ( logo ) + { + GdkPixbuf *found = NULL; /* FIXME (GdkPixbuf*)g_slist_find_custom ( vp->logos, logo, (GCompareFunc)== ); */ + if ( found == NULL ) + { + vp->logos = g_slist_prepend ( vp->logos, (gpointer)logo ); + } + } +} + +/** + * vik_viewport_compute_bearing: + * @vp: self object + * @x1: screen coord + * @y1: screen coord + * @x2: screen coord + * @y2: screen coord + * @angle: bearing in Radian (output) + * @baseangle: UTM base angle in Radian (output) + * + * Compute bearing. + */ +void vik_viewport_compute_bearing ( VikViewport *vp, gint x1, gint y1, gint x2, gint y2, gdouble *angle, gdouble *baseangle ) +{ + gdouble len = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)); + gdouble dx = (x2-x1)/len*10; + gdouble dy = (y2-y1)/len*10; + + *angle = atan2(dy, dx) + M_PI_2; + + if ( vik_viewport_get_drawmode ( vp ) == VIK_VIEWPORT_DRAWMODE_UTM) { + VikCoord test; + struct LatLon ll; + struct UTM u; + gint tx, ty; + + vik_viewport_screen_to_coord ( vp, x1, y1, &test ); + vik_coord_to_latlon ( &test, &ll ); + ll.lat += vik_viewport_get_ympp ( vp ) * vik_viewport_get_height ( vp ) / 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 ( vp, &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; +}