/**
* 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;
}
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. */
}
}
static void georef_layer_draw ( VikGeorefLayer *vgl, VikViewport *vp )
{
if ( vgl->pixbuf )
{
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;
guint width = vik_viewport_get_width(vp), height = vik_viewport_get_height(vp);
gint32 x, y;
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 );
/* mark to scale the pixbuf if it doesn't match our dimensions */
gboolean scale = FALSE;
if ( xmpp != vgl->mpp_easting || ympp != vgl->mpp_northing )
{
scale = TRUE;
layer_width = round(vgl->width * vgl->mpp_easting / xmpp);
layer_height = round(vgl->height * vgl->mpp_northing / ympp);
}
// If image not in viewport bounds - no need to draw it (or bother with any scaling)
if ( (x < 0 || x < width) && (y < 0 || y < height) && x+layer_width > 0 && y+layer_height > 0 ) {
if ( scale )
{
/* 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;
}
}
vik_viewport_draw_pixbuf ( vp, pixbuf, 0, 0, x, y, layer_width, layer_height ); /* todo: draw only what we need to. */
}
}
}
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 void vik_dem_layer_draw_dem ( VikDEMLayer *vdl, VikViewport *vp, VikDEM *dem )
{
VikDEMColumn *column, *prevcolumn, *nextcolumn;
struct LatLon dem_northeast, dem_southwest;
gdouble max_lat, max_lon, min_lat, min_lon;
/**** Check if viewport and DEM data overlap ****/
/* get min, max lat/lon of viewport */
vik_viewport_get_min_max_lat_lon ( vp, &min_lat, &max_lat, &min_lon, &max_lon );
/* get min, max lat/lon of DEM data */
if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
dem_northeast.lat = dem->max_north / 3600.0;
dem_northeast.lon = dem->max_east / 3600.0;
dem_southwest.lat = dem->min_north / 3600.0;
dem_southwest.lon = dem->min_east / 3600.0;
} else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
struct UTM dem_northeast_utm, dem_southwest_utm;
dem_northeast_utm.northing = dem->max_north;
dem_northeast_utm.easting = dem->max_east;
dem_southwest_utm.northing = dem->min_north;
dem_southwest_utm.easting = dem->min_east;
dem_northeast_utm.zone = dem_southwest_utm.zone = dem->utm_zone;
dem_northeast_utm.letter = dem_southwest_utm.letter = dem->utm_letter;
a_coords_utm_to_latlon(&dem_northeast_utm, &dem_northeast);
a_coords_utm_to_latlon(&dem_southwest_utm, &dem_southwest);
}
if ( (max_lat > dem_northeast.lat && min_lat > dem_northeast.lat) ||
(max_lat < dem_southwest.lat && min_lat < dem_southwest.lat) )
return;
else if ( (max_lon > dem_northeast.lon && min_lon > dem_northeast.lon) ||
(max_lon < dem_southwest.lon && min_lon < dem_southwest.lon) )
return;
/* else they overlap */
/**** End Overlap Check ****/
/* boxes to show where we have DEM instead of actually drawing the DEM.
* useful if we want to see what areas we have coverage for (if we want
* to get elevation data for a track) but don't want to cover the map.
*/
#if 0
/* draw a box if a DEM is loaded. in future I'd like to add an option for this
* this is useful if we want to see what areas we have dem for but don't want to
* cover the map (or maybe we just need translucent DEM?) */
{
VikCoord demne, demsw;
gint x1, y1, x2, y2;
vik_coord_load_from_latlon(&demne, vik_viewport_get_coord_mode(vp), &dem_northeast);
vik_coord_load_from_latlon(&demsw, vik_viewport_get_coord_mode(vp), &dem_southwest);
vik_viewport_coord_to_screen ( vp, &demne, &x1, &y1 );
vik_viewport_coord_to_screen ( vp, &demsw, &x2, &y2 );
if ( x1 > vik_viewport_get_width(vp) ) x1=vik_viewport_get_width(vp);
if ( y2 > vik_viewport_get_height(vp) ) y2=vik_viewport_get_height(vp);
if ( x2 < 0 ) x2 = 0;
if ( y1 < 0 ) y1 = 0;
vik_viewport_draw_rectangle ( vp, gtk_widget_get_style(GTK_WIDGET(vp))->black_gc,
FALSE, x2, y1, x1-x2, y2-y1 );
return;
}
#endif
if ( dem->horiz_units == VIK_DEM_HORIZ_LL_ARCSECONDS ) {
VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
gdouble max_lat_as, max_lon_as, min_lat_as, min_lon_as;
gdouble start_lat_as, end_lat_as, start_lon_as, end_lon_as;
gdouble start_lat, end_lat, start_lon, end_lon;
struct LatLon counter;
guint x, y, start_x, start_y;
gint16 elev;
guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 80 ); /* todo: smarter calculation. */
gdouble nscale_deg = dem->north_scale / ((gdouble) 3600);
gdouble escale_deg = dem->east_scale / ((gdouble) 3600);
max_lat_as = max_lat * 3600;
min_lat_as = min_lat * 3600;
max_lon_as = max_lon * 3600;
min_lon_as = min_lon * 3600;
start_lat_as = MAX(min_lat_as, dem->min_north);
end_lat_as = MIN(max_lat_as, dem->max_north);
start_lon_as = MAX(min_lon_as, dem->min_east);
end_lon_as = MIN(max_lon_as, dem->max_east);
start_lat = floor(start_lat_as / dem->north_scale) * nscale_deg;
end_lat = ceil (end_lat_as / dem->north_scale) * nscale_deg;
start_lon = floor(start_lon_as / dem->east_scale) * escale_deg;
end_lon = ceil (end_lon_as / dem->east_scale) * escale_deg;
vik_dem_east_north_to_xy ( dem, start_lon_as, start_lat_as, &start_x, &start_y );
guint gradient_skip_factor = 1;
if(vdl->type == DEM_TYPE_GRADIENT)
gradient_skip_factor = skip_factor;
/* verify sane elev interval */
if ( vdl->max_elev <= vdl->min_elev )
vdl->max_elev = vdl->min_elev + 1;
for ( x=start_x, counter.lon = start_lon; counter.lon <= end_lon+escale_deg*skip_factor; counter.lon += escale_deg * skip_factor, x += skip_factor ) {
// NOTE: ( counter.lon <= end_lon + ESCALE_DEG*SKIP_FACTOR ) is neccessary so in high zoom modes,
// the leftmost column does also get drawn, if the center point is out of viewport.
if ( x < dem->n_columns ) {
column = g_ptr_array_index ( dem->columns, x );
// get previous and next column. catch out-of-bound.
gint32 new_x = x;
new_x -= gradient_skip_factor;
if(new_x < 1)
prevcolumn = g_ptr_array_index ( dem->columns, x+1);
else
prevcolumn = g_ptr_array_index ( dem->columns, new_x);
new_x = x;
new_x += gradient_skip_factor;
if(new_x >= dem->n_columns)
nextcolumn = g_ptr_array_index ( dem->columns, x-1);
else
nextcolumn = g_ptr_array_index ( dem->columns, new_x);
for ( y=start_y, counter.lat = start_lat; counter.lat <= end_lat; counter.lat += nscale_deg * skip_factor, y += skip_factor ) {
if ( y > column->n_points )
break;
elev = column->points[y];
// calculate bounding box for drawing
gint box_x, box_y, box_width, box_height;
struct LatLon box_c;
box_c = counter;
box_c.lat += (nscale_deg * skip_factor)/2;
box_c.lon -= (escale_deg * skip_factor)/2;
vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &box_c);
vik_viewport_coord_to_screen(vp, &tmp, &box_x, &box_y);
// catch box at borders
if(box_x < 0)
box_x = 0;
if(box_y < 0)
box_y = 0;
box_c.lat -= nscale_deg * skip_factor;
box_c.lon += escale_deg * skip_factor;
vik_coord_load_from_latlon(&tmp, vik_viewport_get_coord_mode(vp), &box_c);
vik_viewport_coord_to_screen(vp, &tmp, &box_width, &box_height);
box_width -= box_x;
box_height -= box_y;
// catch box at borders
if(box_width < 0 || box_height < 0)
continue; // skip this. this is out of our viewport anyway. FIXME: why?
gboolean below_minimum = FALSE;
if(vdl->type == DEM_TYPE_HEIGHT) {
if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev ) {
// Prevent 'elev - vdl->min_elev' from being negative so can safely use as array index
elev = ceil ( vdl->min_elev );
below_minimum = TRUE;
}
if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
elev = vdl->max_elev;
}
{
if(box_width < 0 || box_height < 0) // FIXME: why does this happen?
continue;
if(vdl->type == DEM_TYPE_GRADIENT) {
if( elev == VIK_DEM_INVALID_ELEVATION ) {
/* don't draw it */
} else {
// calculate and sum gradient in all directions
gint16 change = 0;
gint32 new_y;
// calculate gradient from height points all around the current one
new_y = y - gradient_skip_factor;
if(new_y < 0)
new_y = y;
change += get_height_difference(elev, prevcolumn->points[new_y]);
change += get_height_difference(elev, column->points[new_y]);
change += get_height_difference(elev, nextcolumn->points[new_y]);
change += get_height_difference(elev, prevcolumn->points[y]);
change += get_height_difference(elev, nextcolumn->points[y]);
new_y = y + gradient_skip_factor;
if(new_y >= column->n_points)
new_y = y;
change += get_height_difference(elev, prevcolumn->points[new_y]);
change += get_height_difference(elev, column->points[new_y]);
change += get_height_difference(elev, nextcolumn->points[new_y]);
change = change / ((skip_factor > 1) ? log(skip_factor) : 0.55); // FIXME: better calc.
if(change < vdl->min_elev)
// Prevent 'change - vdl->min_elev' from being negative so can safely use as array index
change = ceil ( vdl->min_elev );
if(change > vdl->max_elev)
change = vdl->max_elev;
// void vik_viewport_draw_rectangle ( VikViewport *vvp, GdkGC *gc, gboolean filled, gint x1, gint y1, gint x2, gint y2 );
vik_viewport_draw_rectangle(vp, vdl->gcsgradient[(gint)floor(((change - vdl->min_elev)/(vdl->max_elev - vdl->min_elev))*(DEM_N_GRADIENT_COLORS-2))+1], TRUE, box_x, box_y, box_width, box_height);
}
} else {
if(vdl->type == DEM_TYPE_HEIGHT) {
if ( elev == VIK_DEM_INVALID_ELEVATION )
; /* don't draw it */
else if ( elev <= 0 || below_minimum )
/* If 'sea' colour or below the defined mininum draw in the configurable colour */
vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, box_x, box_y, box_width, box_height);
else
vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor(((elev - vdl->min_elev)/(vdl->max_elev - vdl->min_elev))*(DEM_N_HEIGHT_COLORS-2))+1], TRUE, box_x, box_y, box_width, box_height);
}
}
}
} /* for y= */
}
} /* for x= */
} else if ( dem->horiz_units == VIK_DEM_HORIZ_UTM_METERS ) {
gdouble max_nor, max_eas, min_nor, min_eas;
gdouble start_nor, start_eas, end_nor, end_eas;
gint16 elev;
guint x, y, start_x, start_y;
VikCoord tmp; /* TODO: don't use coord_load_from_latlon, especially if in latlon drawing mode */
struct UTM counter;
guint skip_factor = ceil ( vik_viewport_get_xmpp(vp) / 10 ); /* todo: smarter calculation. */
VikCoord tleft, tright, bleft, bright;
vik_viewport_screen_to_coord ( vp, 0, 0, &tleft );
vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), 0, &tright );
vik_viewport_screen_to_coord ( vp, 0, vik_viewport_get_height(vp), &bleft );
vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp), vik_viewport_get_height(vp), &bright );
vik_coord_convert(&tleft, VIK_COORD_UTM);
vik_coord_convert(&tright, VIK_COORD_UTM);
vik_coord_convert(&bleft, VIK_COORD_UTM);
vik_coord_convert(&bright, VIK_COORD_UTM);
max_nor = MAX(tleft.north_south, tright.north_south);
min_nor = MIN(bleft.north_south, bright.north_south);
max_eas = MAX(bright.east_west, tright.east_west);
min_eas = MIN(bleft.east_west, tleft.east_west);
start_nor = MAX(min_nor, dem->min_north);
end_nor = MIN(max_nor, dem->max_north);
if ( tleft.utm_zone == dem->utm_zone && bleft.utm_zone == dem->utm_zone
&& (tleft.utm_letter >= 'N') == (dem->utm_letter >= 'N')
&& (bleft.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
start_eas = MAX(min_eas, dem->min_east);
else
start_eas = dem->min_east;
if ( tright.utm_zone == dem->utm_zone && bright.utm_zone == dem->utm_zone
&& (tright.utm_letter >= 'N') == (dem->utm_letter >= 'N')
&& (bright.utm_letter >= 'N') == (dem->utm_letter >= 'N') ) /* if the utm zones/hemispheres are different, min_eas will be bogus */
end_eas = MIN(max_eas, dem->max_east);
else
end_eas = dem->max_east;
start_nor = floor(start_nor / dem->north_scale) * dem->north_scale;
end_nor = ceil (end_nor / dem->north_scale) * dem->north_scale;
start_eas = floor(start_eas / dem->east_scale) * dem->east_scale;
end_eas = ceil (end_eas / dem->east_scale) * dem->east_scale;
vik_dem_east_north_to_xy ( dem, start_eas, start_nor, &start_x, &start_y );
/* TODO: why start_x and start_y are -1 -- rounding error from above? */
counter.zone = dem->utm_zone;
counter.letter = dem->utm_letter;
for ( x=start_x, counter.easting = start_eas; counter.easting <= end_eas; counter.easting += dem->east_scale * skip_factor, x += skip_factor ) {
if ( x > 0 && x < dem->n_columns ) {
column = g_ptr_array_index ( dem->columns, x );
for ( y=start_y, counter.northing = start_nor; counter.northing <= end_nor; counter.northing += dem->north_scale * skip_factor, y += skip_factor ) {
if ( y > column->n_points )
continue;
elev = column->points[y];
if ( elev != VIK_DEM_INVALID_ELEVATION && elev < vdl->min_elev )
elev=vdl->min_elev;
if ( elev != VIK_DEM_INVALID_ELEVATION && elev > vdl->max_elev )
elev=vdl->max_elev;
{
gint a, b;
vik_coord_load_from_utm(&tmp, vik_viewport_get_coord_mode(vp), &counter);
vik_viewport_coord_to_screen(vp, &tmp, &a, &b);
if ( elev == VIK_DEM_INVALID_ELEVATION )
; /* don't draw it */
else if ( elev <= 0 )
vik_viewport_draw_rectangle(vp, vdl->gcs[0], TRUE, a-1, b-1, 2, 2 );
else
vik_viewport_draw_rectangle(vp, vdl->gcs[(gint)floor((elev - vdl->min_elev)/(vdl->max_elev - vdl->min_elev)*(DEM_N_HEIGHT_COLORS-2))+1], TRUE, a-1, b-1, 2, 2 );
}
} /* for y= */
}
} /* for x= */
}
}
void vik_viewport_set_center_utm ( VikViewport *vvp, const struct UTM *utm )
{
vik_coord_load_from_utm ( &(vvp->center), vvp->coord_mode, utm );
if ( vvp->coord_mode == VIK_COORD_UTM )
viewport_utm_zone_check ( vvp );
}
/* returns TRUE if OK was pressed. */
static gboolean georef_layer_dialog ( VikGeorefLayer *vgl, gpointer vp, GtkWindow *w, gboolean have_apply_button )
{
GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Layer Properties"), w,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
if ( have_apply_button )
gtk_dialog_add_button ( GTK_DIALOG(dialog), GTK_STOCK_APPLY, GTK_RESPONSE_APPLY );
gtk_dialog_add_button ( GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT );
/* Default to reject as user really needs to specify map file first */
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
#endif
GtkWidget *table, *wfp_hbox, *wfp_label, *wfp_button, *ce_label, *cn_label, *xlabel, *ylabel, *imagelabel;
changeable_widgets cw;
GtkBox *dgbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
table = gtk_table_new ( 4, 2, FALSE );
gtk_box_pack_start ( dgbox, table, TRUE, TRUE, 0 );
wfp_hbox = gtk_hbox_new ( FALSE, 0 );
wfp_label = gtk_label_new ( _("World File Parameters:") );
wfp_button = gtk_button_new_with_label ( _("Load From File...") );
gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_label, TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_button, FALSE, FALSE, 3 );
ce_label = gtk_label_new ( _("Corner pixel easting:") );
cw.ce_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, -15000000.0, 1500000.0, 1, 5, 0 ), 1, 4 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.ce_spin), _("the UTM \"easting\" value of the upper-left corner pixel of the map") );
cn_label = gtk_label_new ( _("Corner pixel northing:") );
cw.cn_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, -15000000.0, 15000000.0, 1, 5, 0 ), 1, 4 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.cn_spin), _("the UTM \"northing\" value of the upper-left corner pixel of the map") );
xlabel = gtk_label_new ( _("X (easting) scale (mpp): "));
ylabel = gtk_label_new ( _("Y (northing) scale (mpp): "));
cw.x_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.x_spin), _("the scale of the map in the X direction (meters per pixel)") );
cw.y_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 );
gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.y_spin), _("the scale of the map in the Y direction (meters per pixel)") );
imagelabel = gtk_label_new ( _("Map Image:") );
cw.imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, VF_FILTER_IMAGE, maybe_read_world_file, &cw);
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.ce_spin), vgl->corner.easting );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.cn_spin), vgl->corner.northing );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.x_spin), vgl->mpp_easting );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.y_spin), vgl->mpp_northing );
if ( vgl->image )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(cw.imageentry), vgl->image );
gtk_table_attach_defaults ( GTK_TABLE(table), imagelabel, 0, 1, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table), cw.imageentry, 1, 2, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table), wfp_hbox, 0, 2, 1, 2 );
gtk_table_attach_defaults ( GTK_TABLE(table), xlabel, 0, 1, 2, 3 );
gtk_table_attach_defaults ( GTK_TABLE(table), cw.x_spin, 1, 2, 2, 3 );
gtk_table_attach_defaults ( GTK_TABLE(table), ylabel, 0, 1, 3, 4 );
gtk_table_attach_defaults ( GTK_TABLE(table), cw.y_spin, 1, 2, 3, 4 );
cw.tabs = gtk_notebook_new();
GtkWidget *table_utm = gtk_table_new ( 3, 2, FALSE );
gtk_table_attach_defaults ( GTK_TABLE(table_utm), ce_label, 0, 1, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table_utm), cw.ce_spin, 1, 2, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table_utm), cn_label, 0, 1, 1, 2 );
gtk_table_attach_defaults ( GTK_TABLE(table_utm), cw.cn_spin, 1, 2, 1, 2 );
GtkWidget *utm_hbox = gtk_hbox_new ( FALSE, 0 );
cw.utm_zone_spin = gtk_spin_button_new ((GtkAdjustment*)gtk_adjustment_new( vgl->corner.zone, 1, 60, 1, 5, 0 ), 1, 0 );
gtk_box_pack_start ( GTK_BOX(utm_hbox), gtk_label_new(_("Zone:")), TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(utm_hbox), cw.utm_zone_spin, TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(utm_hbox), gtk_label_new(_("Letter:")), TRUE, TRUE, 0 );
cw.utm_letter_entry = gtk_entry_new ();
gtk_entry_set_max_length ( GTK_ENTRY(cw.utm_letter_entry), 1 );
gtk_entry_set_width_chars ( GTK_ENTRY(cw.utm_letter_entry), 2 );
gchar tmp_letter[2];
tmp_letter[0] = vgl->corner.letter;
tmp_letter[1] = '\0';
gtk_entry_set_text ( GTK_ENTRY(cw.utm_letter_entry), tmp_letter );
gtk_box_pack_start ( GTK_BOX(utm_hbox), cw.utm_letter_entry, TRUE, TRUE, 0 );
gtk_table_attach_defaults ( GTK_TABLE(table_utm), utm_hbox, 0, 2, 2, 3 );
// Lat/Lon
GtkWidget *table_ll = gtk_table_new ( 5, 2, FALSE );
GtkWidget *lat_tl_label = gtk_label_new ( _("Upper left latitude:") );
cw.lat_tl_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-90,90.0,0.05,0.1,0), 0.1, 6 );
GtkWidget *lon_tl_label = gtk_label_new ( _("Upper left longitude:") );
cw.lon_tl_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-180,180.0,0.05,0.1,0), 0.1, 6 );
GtkWidget *lat_br_label = gtk_label_new ( _("Lower right latitude:") );
cw.lat_br_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-90,90.0,0.05,0.1,0), 0.1, 6 );
GtkWidget *lon_br_label = gtk_label_new ( _("Lower right longitude:") );
cw.lon_br_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-180.0,180.0,0.05,0.1,0), 0.1, 6 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), lat_tl_label, 0, 1, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lat_tl_spin, 1, 2, 0, 1 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), lon_tl_label, 0, 1, 1, 2 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lon_tl_spin, 1, 2, 1, 2 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), lat_br_label, 0, 1, 2, 3 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lat_br_spin, 1, 2, 2, 3 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), lon_br_label, 0, 1, 3, 4 );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lon_br_spin, 1, 2, 3, 4 );
GtkWidget *calc_mpp_button = gtk_button_new_with_label ( _("Calculate MPP values from coordinates") );
gtk_widget_set_tooltip_text ( calc_mpp_button, _("Enter all corner coordinates before calculating the MPP values from the image size") );
gtk_table_attach_defaults ( GTK_TABLE(table_ll), calc_mpp_button, 0, 2, 4, 5 );
VikCoord vc;
vik_coord_load_from_utm (&vc, VIK_COORD_LATLON, &(vgl->corner));
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lat_tl_spin), vc.north_south );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lon_tl_spin), vc.east_west );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lat_br_spin), vgl->ll_br.lat );
gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lon_br_spin), vgl->ll_br.lon );
gtk_notebook_append_page(GTK_NOTEBOOK(cw.tabs), GTK_WIDGET(table_utm), gtk_label_new(_("UTM")));
gtk_notebook_append_page(GTK_NOTEBOOK(cw.tabs), GTK_WIDGET(table_ll), gtk_label_new(_("Latitude/Longitude")));
gtk_box_pack_start ( dgbox, cw.tabs, TRUE, TRUE, 0 );
GtkWidget *alpha_hbox = gtk_hbox_new ( FALSE, 0 );
// GTK3 => GtkWidget *alpha_scale = gtk_scale_new_with_range ( GTK_ORIENTATION_HORIZONTAL, 0, 255, 1 );
GtkWidget *alpha_scale = gtk_hscale_new_with_range ( 0, 255, 1 );
gtk_scale_set_digits ( GTK_SCALE(alpha_scale), 0 );
gtk_range_set_value ( GTK_RANGE(alpha_scale), vgl->alpha );
gtk_box_pack_start ( GTK_BOX(alpha_hbox), gtk_label_new(_("Alpha:")), TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(alpha_hbox), alpha_scale, TRUE, TRUE, 0 );
gtk_box_pack_start ( dgbox, alpha_hbox, TRUE, TRUE, 0 );
vgl->cw = cw;
g_signal_connect ( G_OBJECT(vgl->cw.tabs), "switch-page", G_CALLBACK(switch_tab), vgl );
g_signal_connect ( G_OBJECT(calc_mpp_button), "clicked", G_CALLBACK(calculate_mpp_from_coords), vgl );
g_signal_connect_swapped ( G_OBJECT(wfp_button), "clicked", G_CALLBACK(georef_layer_dialog_load), &cw );
if ( response_w )
gtk_widget_grab_focus ( response_w );
gtk_widget_show_all ( dialog );
// Remember setting the notebook page must be done after the widget is visible.
gint page_num = 0;
if ( a_settings_get_integer ( VIK_SETTINGS_GEOREF_TAB, &page_num ) )
if ( page_num < 0 || page_num > 1 )
page_num = 0;
gtk_notebook_set_current_page ( GTK_NOTEBOOK(cw.tabs), page_num );
gboolean answer = FALSE;
gint resp = GTK_RESPONSE_APPLY;
while ( resp == GTK_RESPONSE_APPLY ) {
resp = gtk_dialog_run ( GTK_DIALOG(dialog) );
if ( resp == GTK_RESPONSE_ACCEPT || resp == GTK_RESPONSE_APPLY ) {
align_coords ( vgl );
vgl->corner.easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.ce_spin) );
vgl->corner.northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.cn_spin) );
vgl->corner.zone = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(cw.utm_zone_spin) );
const gchar *letter = gtk_entry_get_text ( GTK_ENTRY(cw.utm_letter_entry) );
if (*letter)
vgl->corner.letter = toupper(*letter);
vgl->mpp_easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.x_spin) );
vgl->mpp_northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.y_spin) );
vgl->ll_br = get_ll_br (vgl);
check_br_is_good_or_msg_user ( vgl );
// TODO check if image has changed otherwise no need to regenerate pixbuf
if ( !vgl->pixbuf ) {
if ( g_strcmp0 (vgl->image, vik_file_entry_get_filename(VIK_FILE_ENTRY(cw.imageentry)) ) != 0 ) {
georef_layer_set_image ( vgl, vik_file_entry_get_filename(VIK_FILE_ENTRY(cw.imageentry)) );
georef_layer_load_image ( vgl, VIK_VIEWPORT(vp), FALSE );
}
}
vgl->alpha = (guint8) gtk_range_get_value ( GTK_RANGE(alpha_scale) );
if ( vgl->pixbuf && vgl->alpha <= 255 )
vgl->pixbuf = ui_pixbuf_set_alpha ( vgl->pixbuf, vgl->alpha );
if ( vgl->scaled && vgl->alpha <= 255 )
vgl->scaled = ui_pixbuf_set_alpha ( vgl->scaled, vgl->alpha );
a_settings_set_integer ( VIK_SETTINGS_GEOREF_TAB, gtk_notebook_get_current_page(GTK_NOTEBOOK(cw.tabs)) );
if ( resp == GTK_RESPONSE_APPLY ) {
vik_layer_emit_update ( VIK_LAYER(vgl) );
answer = FALSE;
}
else
answer = TRUE;
}
}
gtk_widget_destroy ( GTK_WIDGET(dialog) );
return answer;
}
