static VikGeorefLayer *georef_layer_new ( VikViewport *vvp )
{
VikGeorefLayer *vgl = VIK_GEOREF_LAYER ( g_object_new ( VIK_GEOREF_LAYER_TYPE, NULL ) );
vik_layer_set_type ( VIK_LAYER(vgl), VIK_LAYER_GEOREF );
// Since GeoRef layer doesn't use uibuilder
// initializing this way won't do anything yet..
vik_layer_set_defaults ( VIK_LAYER(vgl), vvp );
// Make these defaults based on the current view
vgl->mpp_northing = vik_viewport_get_ympp ( vvp );
vgl->mpp_easting = vik_viewport_get_xmpp ( vvp );
vik_coord_to_utm ( vik_viewport_get_center ( vvp ), &(vgl->corner) );
vgl->image = NULL;
vgl->pixbuf = NULL;
vgl->click_x = -1;
vgl->click_y = -1;
vgl->scaled = NULL;
vgl->scaled_width = 0;
vgl->scaled_height = 0;
vgl->ll_br.lat = 0.0;
vgl->ll_br.lon = 0.0;
vgl->alpha = 255;
return vgl;
}
void vik_viewport_center_for_zonen ( VikViewport *vvp, struct UTM *center, int zone)
{
if ( vvp->coord_mode == VIK_COORD_UTM ) {
*center = *((struct UTM *)(vik_viewport_get_center ( vvp )));
center->easting -= ( zone - center->zone ) * vvp->utm_zone_width;
center->zone = zone;
}
}
static void georef_layer_draw ( VikGeorefLayer *vgl, VikViewport *vp )
{
if ( vik_viewport_get_drawmode(vp) != VIK_VIEWPORT_DRAWMODE_UTM )
return;
if ( vgl->pixbuf )
{
struct UTM utm_middle;
gdouble xmpp = vik_viewport_get_xmpp(vp), ympp = vik_viewport_get_ympp(vp);
GdkPixbuf *pixbuf = vgl->pixbuf;
guint layer_width = vgl->width;
guint layer_height = vgl->height;
vik_coord_to_utm ( vik_viewport_get_center ( vp ), &utm_middle );
/* scale the pixbuf if it doesn't match our dimensions */
if ( xmpp != vgl->mpp_easting || ympp != vgl->mpp_northing )
{
layer_width = round(vgl->width * vgl->mpp_easting / xmpp);
layer_height = round(vgl->height * vgl->mpp_northing / ympp);
/* rescale if necessary */
if (layer_width == vgl->scaled_width && layer_height == vgl->scaled_height && vgl->scaled != NULL)
pixbuf = vgl->scaled;
else
{
pixbuf = gdk_pixbuf_scale_simple(
vgl->pixbuf,
layer_width,
layer_height,
GDK_INTERP_BILINEAR
);
if (vgl->scaled != NULL)
g_object_unref(vgl->scaled);
vgl->scaled = pixbuf;
vgl->scaled_width = layer_width;
vgl->scaled_height = layer_height;
}
}
guint width = vik_viewport_get_width(vp), height = vik_viewport_get_height(vp);
gint32 x, y;
vgl->corner.zone = utm_middle.zone;
vgl->corner.letter = utm_middle.letter;
VikCoord corner_coord;
vik_coord_load_from_utm ( &corner_coord, vik_viewport_get_coord_mode(vp), &(vgl->corner) );
vik_viewport_coord_to_screen ( vp, &corner_coord, &x, &y );
if ( (x < 0 || x < width) && (y < 0 || y < height) && x+layer_width > 0 && y+layer_height > 0 )
vik_viewport_draw_pixbuf ( vp, pixbuf, 0, 0, x, y, layer_width, layer_height ); /* todo: draw only what we need to. */
}
}
gchar * a_vik_goto_get_search_string_for_this_place(VikWindow *vw)
{
if (!last_coord)
return NULL;
VikViewport *vvp = vik_window_viewport(vw);
const VikCoord *cur_center = vik_viewport_get_center(vvp);
if (vik_coord_equals(cur_center, last_coord)) {
return(last_successful_goto_str);
}
else
return NULL;
}
/**
* Load a single JPG into a Trackwaypoint Layer as a waypoint
*
* @top: The Aggregate layer that a new TRW layer may be created in
* @filename: The JPG filename
* @vvp: The viewport
*
* Returns: Whether the loading was a success or not
*
* If the JPG has geotag information then the waypoint will be created with the appropriate position.
* Otherwise the waypoint will be positioned at the current screen center.
* If a TRW layer is already selected the waypoint will be created in that layer.
*/
gboolean a_jpg_load_file ( VikAggregateLayer *top, const gchar *filename, VikViewport *vvp )
{
gboolean auto_zoom = TRUE;
VikWindow *vw = (VikWindow *)(VIK_GTK_WINDOW_FROM_LAYER(VIK_LAYER(top)));
VikLayersPanel *vlp = vik_window_layers_panel ( vw );
// Auto load into TrackWaypoint layer if one is selected
VikLayer *vtl = vik_layers_panel_get_selected ( vlp );
gboolean create_layer = FALSE;
if ( vtl == NULL || vtl->type != VIK_LAYER_TRW ) {
// Create layer if necessary
vtl = vik_layer_create ( VIK_LAYER_TRW, vvp, FALSE );
vik_layer_rename ( vtl, a_file_basename ( filename ) );
create_layer = TRUE;
}
gchar *name = NULL;
VikWaypoint *wp = NULL;
#ifdef VIK_CONFIG_GEOTAG
wp = a_geotag_create_waypoint_from_file ( filename, vik_viewport_get_coord_mode (vvp), &name );
#endif
if ( wp ) {
// Create name if geotag method didn't return one
if ( !name )
name = g_strdup ( a_file_basename ( filename ) );
vik_trw_layer_filein_add_waypoint ( VIK_TRW_LAYER(vtl), name, wp );
g_free ( name );
}
else {
wp = vik_waypoint_new ();
wp->visible = TRUE;
vik_trw_layer_filein_add_waypoint ( VIK_TRW_LAYER(vtl), (gchar*) a_file_basename(filename), wp );
vik_waypoint_set_image ( wp, filename );
// Simply set position to the current center
wp->coord = *( vik_viewport_get_center ( vvp ) );
auto_zoom = FALSE;
}
// Complete the setup
vik_layer_post_read ( vtl, vvp, TRUE );
if ( create_layer )
vik_aggregate_layer_add_layer ( top, vtl, FALSE );
if ( auto_zoom )
vik_trw_layer_auto_set_view ( VIK_TRW_LAYER(vtl), vvp );
// ATM This routine can't fail
return TRUE;
}
static void georef_layer_goto_center ( gpointer vgl_vlp[2] )
{
VikGeorefLayer *vgl = VIK_GEOREF_LAYER ( vgl_vlp[0] );
VikViewport *vp = vik_layers_panel_get_viewport(VIK_LAYERS_PANEL(vgl_vlp[1]));
struct UTM utm;
VikCoord coord;
vik_coord_to_utm ( vik_viewport_get_center ( vp ), &utm );
utm.easting = vgl->corner.easting + (vgl->width * vgl->mpp_easting / 2); /* only an approximation */
utm.northing = vgl->corner.northing - (vgl->height * vgl->mpp_northing / 2);
vik_coord_load_from_utm ( &coord, vik_viewport_get_coord_mode ( vp ), &utm );
vik_viewport_set_center_coord ( vp, &coord );
vik_layers_panel_emit_update ( VIK_LAYERS_PANEL(vgl_vlp[1]) );
}
static gdouble
viewport_utm_zone_width ( VikViewport *vvp )
{
if ( vvp->coord_mode == VIK_COORD_UTM ) {
struct LatLon ll;
/* get latitude of screen bottom */
struct UTM utm = *((struct UTM *)(vik_viewport_get_center ( vvp )));
utm.northing -= vvp -> height * vvp -> ympp / 2;
a_coords_utm_to_latlon ( &utm, &ll );
/* boundary */
ll.lon = (utm.zone - 1) * 6 - 180 ;
a_coords_latlon_to_utm ( &ll, &utm);
return fabs ( utm.easting - EASTING_OFFSET ) * 2;
} else
return 0.0;
}
static void datasource_gc_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
datasource_gc_widgets_t *widgets = (datasource_gc_widgets_t *)user_data;
GtkWidget *num_label, *center_label, *miles_radius_label;
struct LatLon ll;
gchar *s_ll;
num_label = gtk_label_new (_("Number geocaches:"));
widgets->num_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( 20, 1, 1000, 10, 20, 0 )), 10, 0 );
center_label = gtk_label_new (_("Centered around:"));
widgets->center_entry = gtk_entry_new();
miles_radius_label = gtk_label_new ("Miles Radius:");
widgets->miles_radius_spin = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( 5, 1, 1000, 1, 20, 0 )), 25, 1 );
vik_coord_to_latlon ( vik_viewport_get_center(vvp), &ll );
s_ll = g_strdup_printf("%f,%f", ll.lat, ll.lon );
gtk_entry_set_text ( GTK_ENTRY(widgets->center_entry), s_ll );
g_free ( s_ll );
widgets->vvp = vvp;
widgets->circle_gc = vik_viewport_new_gc ( vvp, "#000000", 3 );
gdk_gc_set_function ( widgets->circle_gc, GDK_INVERT );
widgets->circle_onscreen = TRUE;
datasource_gc_draw_circle ( widgets );
g_signal_connect_swapped ( G_OBJECT(widgets->center_entry), "changed", G_CALLBACK(datasource_gc_draw_circle), widgets );
g_signal_connect_swapped ( G_OBJECT(widgets->miles_radius_spin), "value-changed", G_CALLBACK(datasource_gc_draw_circle), widgets );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), num_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), widgets->num_spin, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), center_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), widgets->center_entry, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), miles_radius_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), widgets->miles_radius_spin, FALSE, FALSE, 5 );
gtk_widget_show_all(dialog);
}
static void file_write ( VikAggregateLayer *top, FILE *f, gpointer vp )
{
Stack *stack = NULL;
VikLayer *current_layer;
struct LatLon ll;
VikViewportDrawMode mode;
gchar *modestring = NULL;
push(&stack);
stack->data = (gpointer) vik_aggregate_layer_get_children(VIK_AGGREGATE_LAYER(top));
stack->under = NULL;
/* crazhy CRAZHY */
vik_coord_to_latlon ( vik_viewport_get_center ( VIK_VIEWPORT(vp) ), &ll );
mode = vik_viewport_get_drawmode ( VIK_VIEWPORT(vp) );
switch ( mode ) {
case VIK_VIEWPORT_DRAWMODE_UTM: modestring = "utm"; break;
case VIK_VIEWPORT_DRAWMODE_EXPEDIA: modestring = "expedia"; break;
case VIK_VIEWPORT_DRAWMODE_MERCATOR: modestring = "mercator"; break;
case VIK_VIEWPORT_DRAWMODE_LATLON: modestring = "latlon"; break;
default:
g_critical("Houston, we've had a problem. mode=%d", mode);
}
fprintf ( f, "#VIKING GPS Data file " VIKING_URL "\n" );
fprintf ( f, "FILE_VERSION=%d\n", VIKING_FILE_VERSION );
fprintf ( f, "\nxmpp=%f\nympp=%f\nlat=%f\nlon=%f\nmode=%s\ncolor=%s\nhighlightcolor=%s\ndrawscale=%s\ndrawcentermark=%s\ndrawhighlight=%s\n",
vik_viewport_get_xmpp ( VIK_VIEWPORT(vp) ), vik_viewport_get_ympp ( VIK_VIEWPORT(vp) ), ll.lat, ll.lon,
modestring, vik_viewport_get_background_color(VIK_VIEWPORT(vp)),
vik_viewport_get_highlight_color(VIK_VIEWPORT(vp)),
vik_viewport_get_draw_scale(VIK_VIEWPORT(vp)) ? "t" : "f",
vik_viewport_get_draw_centermark(VIK_VIEWPORT(vp)) ? "t" : "f",
vik_viewport_get_draw_highlight(VIK_VIEWPORT(vp)) ? "t" : "f" );
if ( ! VIK_LAYER(top)->visible )
fprintf ( f, "visible=f\n" );
while (stack && stack->data)
{
current_layer = VIK_LAYER(((GList *)stack->data)->data);
fprintf ( f, "\n~Layer %s\n", vik_layer_get_interface(current_layer->type)->fixed_layer_name );
write_layer_params_and_data ( current_layer, f );
if ( current_layer->type == VIK_LAYER_AGGREGATE && !vik_aggregate_layer_is_empty(VIK_AGGREGATE_LAYER(current_layer)) )
{
push(&stack);
stack->data = (gpointer) vik_aggregate_layer_get_children(VIK_AGGREGATE_LAYER(current_layer));
}
else if ( current_layer->type == VIK_LAYER_GPS && !vik_gps_layer_is_empty(VIK_GPS_LAYER(current_layer)) )
{
push(&stack);
stack->data = (gpointer) vik_gps_layer_get_children(VIK_GPS_LAYER(current_layer));
}
else
{
stack->data = (gpointer) ((GList *)stack->data)->next;
fprintf ( f, "~EndLayer\n\n" );
while ( stack && (!stack->data) )
{
pop(&stack);
if ( stack )
{
stack->data = (gpointer) ((GList *)stack->data)->next;
fprintf ( f, "~EndLayer\n\n" );
}
}
}
}
/*
get vikaggregatelayer's children (?)
foreach write ALL params,
then layer data (IF function exists)
then endlayer
impl:
stack of layers (LIST) we are working on
when layer->next == NULL ...
we move on.
*/
}
void vik_coord_layer_draw ( VikCoordLayer *vcl, gpointer data )
{
VikViewport *vp = (VikViewport *) data;
if ( !vcl->gc ) {
return;
}
if ( vik_viewport_get_coord_mode(vp) != VIK_COORD_UTM )
{
VikCoord left, right, left2, right2;
gdouble l, r, i, j;
gint x1, y1, x2, y2, smod = 1, mmod = 1;
gboolean mins = FALSE, secs = FALSE;
GdkGC *dgc = vik_viewport_new_gc_from_color(vp, vcl->color, vcl->line_thickness);
GdkGC *mgc = vik_viewport_new_gc_from_color(vp, vcl->color, MAX(vcl->line_thickness/2, 1));
GdkGC *sgc = vik_viewport_new_gc_from_color(vp, vcl->color, MAX(vcl->line_thickness/5, 1));
vik_viewport_screen_to_coord ( vp, 0, 0, &left );
vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), 0, &right );
vik_viewport_screen_to_coord ( vp, 0, vik_viewport_get_height(vp), &left2 );
vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), vik_viewport_get_height(vp), &right2 );
#define CLINE(gc, c1, c2) { \
vik_viewport_coord_to_screen(vp, (c1), &x1, &y1); \
vik_viewport_coord_to_screen(vp, (c2), &x2, &y2); \
vik_viewport_draw_line (vp, (gc), x1, y1, x2, y2); \
}
l = left.east_west;
r = right.east_west;
if (60*fabs(l-r) < 4) {
secs = TRUE;
smod = MIN(6, (int)ceil(3600*fabs(l-r)/30.0));
}
if (fabs(l-r) < 4) {
mins = TRUE;
mmod = MIN(6, (int)ceil(60*fabs(l-r)/30.0));
}
for (i=floor(l*60); i<ceil(r*60); i+=1.0) {
if (secs) {
for (j=i*60+1; j<(i+1)*60; j+=1.0) {
left.east_west = j/3600.0;
left2.east_west = j/3600.0;
if ((int)j % smod == 0) CLINE(sgc, &left, &left2);
}
}
if (mins) {
left.east_west = i/60.0;
left2.east_west = i/60.0;
if ((int)i % mmod == 0) CLINE(mgc, &left, &left2);
}
if ((int)i % 60 == 0) {
left.east_west = i/60.0;
left2.east_west = i/60.0;
CLINE(dgc, &left, &left2);
}
}
vik_viewport_screen_to_coord ( vp, 0, 0, &left );
l = left2.north_south;
r = left.north_south;
for (i=floor(l*60); i<ceil(r*60); i+=1.0) {
if (secs) {
for (j=i*60+1; j<(i+1)*60; j+=1.0) {
left.north_south = j/3600.0;
right.north_south = j/3600.0;
if ((int)j % smod == 0) CLINE(sgc, &left, &right);
}
}
if (mins) {
left.north_south = i/60.0;
right.north_south = i/60.0;
if ((int)i % mmod == 0) CLINE(mgc, &left, &right);
}
if ((int)i % 60 == 0) {
left.north_south = i/60.0;
right.north_south = i/60.0;
CLINE(dgc, &left, &right);
}
}
#undef CLINE
g_object_unref(dgc);
g_object_unref(sgc);
g_object_unref(mgc);
return;
}
if ( vik_viewport_get_coord_mode(vp) == VIK_COORD_UTM )
{
const struct UTM *center = (const struct UTM *)vik_viewport_get_center ( vp );
gdouble xmpp = vik_viewport_get_xmpp ( vp ), ympp = vik_viewport_get_ympp ( vp );
guint16 width = vik_viewport_get_width ( vp ), height = vik_viewport_get_height ( vp );
struct LatLon ll, ll2, min, max;
double lon;
int x1, x2;
struct UTM utm;
utm = *center;
utm.northing = center->northing - ( ympp * height / 2 );
a_coords_utm_to_latlon ( &utm, &ll );
utm.northing = center->northing + ( ympp * height / 2 );
a_coords_utm_to_latlon ( &utm, &ll2 );
{
/* find corner coords in lat/lon.
start at whichever is less: top or bottom left lon. goto whichever more: top or bottom right lon
*/
struct LatLon topleft, topright, bottomleft, bottomright;
struct UTM temp_utm;
temp_utm = *center;
temp_utm.easting -= (width/2)*xmpp;
temp_utm.northing += (height/2)*ympp;
a_coords_utm_to_latlon ( &temp_utm, &topleft );
temp_utm.easting += (width*xmpp);
a_coords_utm_to_latlon ( &temp_utm, &topright );
temp_utm.northing -= (height*ympp);
a_coords_utm_to_latlon ( &temp_utm, &bottomright );
temp_utm.easting -= (width*xmpp);
a_coords_utm_to_latlon ( &temp_utm, &bottomleft );
min.lon = (topleft.lon < bottomleft.lon) ? topleft.lon : bottomleft.lon;
max.lon = (topright.lon > bottomright.lon) ? topright.lon : bottomright.lon;
min.lat = (bottomleft.lat < bottomright.lat) ? bottomleft.lat : bottomright.lat;
max.lat = (topleft.lat > topright.lat) ? topleft.lat : topright.lat;
}
lon = ((double) ((long) ((min.lon)/ vcl->deg_inc))) * vcl->deg_inc;
ll.lon = ll2.lon = lon;
for (; ll.lon <= max.lon; ll.lon+=vcl->deg_inc, ll2.lon+=vcl->deg_inc )
{
a_coords_latlon_to_utm ( &ll, &utm );
x1 = ( (utm.easting - center->easting) / xmpp ) + (width / 2);
a_coords_latlon_to_utm ( &ll2, &utm );
x2 = ( (utm.easting - center->easting) / xmpp ) + (width / 2);
vik_viewport_draw_line (vp, vcl->gc, x1, height, x2, 0);
}
utm = *center;
utm.easting = center->easting - ( xmpp * width / 2 );
a_coords_utm_to_latlon ( &utm, &ll );
utm.easting = center->easting + ( xmpp * width / 2 );
a_coords_utm_to_latlon ( &utm, &ll2 );
/* really lat, just reusing a variable */
lon = ((double) ((long) ((min.lat)/ vcl->deg_inc))) * vcl->deg_inc;
ll.lat = ll2.lat = lon;
for (; ll.lat <= max.lat ; ll.lat+=vcl->deg_inc, ll2.lat+=vcl->deg_inc )
{
a_coords_latlon_to_utm ( &ll, &utm );
x1 = (height / 2) - ( (utm.northing - center->northing) / ympp );
a_coords_latlon_to_utm ( &ll2, &utm );
x2 = (height / 2) - ( (utm.northing - center->northing) / ympp );
vik_viewport_draw_line (vp, vcl->gc, width, x2, 0, x1);
}
}
}
