static VikLayerParamData dem_layer_get_param ( VikDEMLayer *vdl, guint16 id, gboolean is_file_operation ) { VikLayerParamData rv; switch ( id ) { case PARAM_FILES: rv.sl = vdl->files; if ( is_file_operation ) // Save in relative format if necessary if ( a_vik_get_file_ref_format() == VIK_FILE_REF_FORMAT_RELATIVE ) rv.sl = dem_layer_convert_to_relative_filenaming ( rv.sl ); break; case PARAM_SOURCE: rv.u = vdl->source; break; case PARAM_TYPE: rv.u = vdl->type; break; case PARAM_COLOR: rv.c = vdl->color; break; case PARAM_MIN_ELEV: /* Convert for display in desired units NB file operation always in internal units (metres) */ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET ) rv.d = VIK_METERS_TO_FEET(vdl->min_elev); else rv.d = vdl->min_elev; break; case PARAM_MAX_ELEV: /* Convert for display in desired units NB file operation always in internal units (metres) */ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET ) rv.d = VIK_METERS_TO_FEET(vdl->max_elev); else rv.d = vdl->max_elev; break; default: break; } return rv; }
gboolean dem_layer_set_param ( VikDEMLayer *vdl, guint16 id, VikLayerParamData data, VikViewport *vp, gboolean is_file_operation ) { switch ( id ) { case PARAM_COLOR: vdl->color = data.c; gdk_gc_set_rgb_fg_color ( vdl->gcs[0], &(vdl->color) ); break; case PARAM_SOURCE: vdl->source = data.u; break; case PARAM_TYPE: vdl->type = data.u; break; case PARAM_MIN_ELEV: /* Convert to store internally NB file operation always in internal units (metres) */ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET ) vdl->min_elev = VIK_FEET_TO_METERS(data.d); else vdl->min_elev = data.d; break; case PARAM_MAX_ELEV: /* Convert to store internally NB file operation always in internal units (metres) */ if (!is_file_operation && a_vik_get_units_height () == VIK_UNITS_HEIGHT_FEET ) vdl->max_elev = VIK_FEET_TO_METERS(data.d); else vdl->max_elev = data.d; break; case PARAM_FILES: { // Clear out old settings - if any commonalities with new settings they will have to be read again a_dems_list_free ( vdl->files ); // Set file list so any other intermediate screen drawing updates will show currently loaded DEMs by the working thread vdl->files = data.sl; // No need for thread if no files if ( vdl->files ) { // Thread Load dem_load_thread_data *dltd = g_malloc ( sizeof(dem_load_thread_data) ); dltd->vdl = vdl; dltd->vdl->files = data.sl; a_background_thread ( VIK_GTK_WINDOW_FROM_WIDGET(vp), _("DEM Loading"), (vik_thr_func) dem_layer_load_list_thread, dltd, (vik_thr_free_func) dem_layer_thread_data_free, (vik_thr_free_func) dem_layer_thread_cancel, g_list_length ( data.sl ) ); // Number of DEM files } break; } default: break; } return TRUE; }
static void tpwin_sync_alt_to_tp ( VikTrwLayerTpwin *tpwin ) { if ( tpwin->cur_tp && (!tpwin->sync_to_tp_block) ) { // Always store internally in metres vik_units_height_t height_units = a_vik_get_units_height (); switch (height_units) { case VIK_UNITS_HEIGHT_METRES: tpwin->cur_tp->altitude = gtk_spin_button_get_value ( tpwin->alt ); break; case VIK_UNITS_HEIGHT_FEET: tpwin->cur_tp->altitude = VIK_FEET_TO_METERS(gtk_spin_button_get_value ( tpwin->alt )); break; default: tpwin->cur_tp->altitude = gtk_spin_button_get_value ( tpwin->alt ); g_critical("Houston, we've had a problem. height=%d", height_units); } } }
/** * vik_trw_layer_tpwin_set_tp: * @tpwin: The Trackpoint Edit Window * @tpl: The #Glist of trackpoints pointing at the current trackpoint * @track_name: The name of the track in which the trackpoint belongs * @is_route: Is the track of the trackpoint actually a route? * * Sets the Trackpoint Edit Window to the values of the current trackpoint given in @tpl. * */ void vik_trw_layer_tpwin_set_tp ( VikTrwLayerTpwin *tpwin, GList *tpl, const gchar *track_name, gboolean is_route ) { static char tmp_str[64]; static struct LatLon ll; VikTrackpoint *tp = VIK_TRACKPOINT(tpl->data); if ( tp->name ) gtk_entry_set_text ( GTK_ENTRY(tpwin->trkpt_name), tp->name ); else gtk_editable_delete_text ( GTK_EDITABLE(tpwin->trkpt_name), 0, -1 ); gtk_widget_set_sensitive ( tpwin->trkpt_name, TRUE ); /* Only can insert if not at the end (otherwise use extend track) */ gtk_widget_set_sensitive ( tpwin->button_insert, (gboolean) GPOINTER_TO_INT (tpl->next) ); gtk_widget_set_sensitive ( tpwin->button_delete, TRUE ); /* We can only split up a track if it's not an endpoint. Makes sense to me. */ gtk_widget_set_sensitive ( tpwin->button_split, tpl->next && tpl->prev ); gtk_widget_set_sensitive ( tpwin->button_forward, (gboolean) GPOINTER_TO_INT (tpl->next) ); gtk_widget_set_sensitive ( tpwin->button_back, (gboolean) GPOINTER_TO_INT (tpl->prev) ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->lat), TRUE ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->lon), TRUE ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->alt), TRUE ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->ts), tp->has_timestamp ); gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->time), tp->has_timestamp ); // Enable adding timestamps - but not on routepoints if ( !tp->has_timestamp && !is_route ) { gtk_widget_set_sensitive ( GTK_WIDGET(tpwin->time), TRUE ); GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU ); gtk_button_set_image ( GTK_BUTTON(tpwin->time), img ); } else vik_trw_layer_tpwin_set_track_name ( tpwin, track_name ); tpwin->sync_to_tp_block = TRUE; /* don't update while setting data. */ vik_coord_to_latlon ( &(tp->coord), &ll ); gtk_spin_button_set_value ( tpwin->lat, ll.lat ); gtk_spin_button_set_value ( tpwin->lon, ll.lon ); vik_units_height_t height_units = a_vik_get_units_height (); switch (height_units) { case VIK_UNITS_HEIGHT_METRES: gtk_spin_button_set_value ( tpwin->alt, tp->altitude ); break; case VIK_UNITS_HEIGHT_FEET: gtk_spin_button_set_value ( tpwin->alt, VIK_METERS_TO_FEET(tp->altitude) ); break; default: gtk_spin_button_set_value ( tpwin->alt, tp->altitude ); g_critical("Houston, we've had a problem. height=%d", height_units); } tpwin_update_times ( tpwin, tp ); tpwin->sync_to_tp_block = FALSE; // don't update while setting data. vik_units_speed_t speed_units = a_vik_get_units_speed (); vik_units_distance_t dist_units = a_vik_get_units_distance (); if ( tpwin->cur_tp ) { switch (dist_units) { case VIK_UNITS_DISTANCE_KILOMETRES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f m", vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord))); break; case VIK_UNITS_DISTANCE_MILES: case VIK_UNITS_DISTANCE_NAUTICAL_MILES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f yards", vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord))*1.0936133); break; default: g_critical("Houston, we've had a problem. distance=%d", dist_units); } gtk_label_set_text ( tpwin->diff_dist, tmp_str ); if ( tp->has_timestamp && tpwin->cur_tp->has_timestamp ) { g_snprintf ( tmp_str, sizeof(tmp_str), "%ld s", tp->timestamp - tpwin->cur_tp->timestamp); gtk_label_set_text ( tpwin->diff_time, tmp_str ); if ( tp->timestamp == tpwin->cur_tp->timestamp ) gtk_label_set_text ( tpwin->diff_speed, "--" ); else { switch (speed_units) { case VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f km/h", VIK_MPS_TO_KPH(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_MILES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f mph", VIK_MPS_TO_MPH(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_METRES_PER_SECOND: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f m/s", vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / ABS(tp->timestamp - tpwin->cur_tp->timestamp) ); break; case VIK_UNITS_SPEED_KNOTS: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f knots", VIK_MPS_TO_KNOTS(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_SECONDS_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f s/km", VIK_MPS_TO_PACE_SPK(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_MINUTES_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/km", VIK_MPS_TO_PACE_MPK(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_SECONDS_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f sec/mi", VIK_MPS_TO_PACE_SPM(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; case VIK_UNITS_SPEED_MINUTES_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/mi", VIK_MPS_TO_PACE_MPM(vik_coord_diff(&(tp->coord), &(tpwin->cur_tp->coord)) / (ABS(tp->timestamp - tpwin->cur_tp->timestamp))) ); break; default: g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); g_critical("Houston, we've had a problem. speed=%d", speed_units); } gtk_label_set_text ( tpwin->diff_speed, tmp_str ); } } else { gtk_label_set_text ( tpwin->diff_time, NULL ); gtk_label_set_text ( tpwin->diff_speed, NULL ); } } if ( isnan(tp->course) ) g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); else g_snprintf ( tmp_str, sizeof(tmp_str), "%05.1f\302\260", tp->course ); gtk_label_set_text ( tpwin->course, tmp_str ); if ( isnan(tp->speed) ) g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); else { switch (speed_units) { case VIK_UNITS_SPEED_MILES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f mph", VIK_MPS_TO_MPH(tp->speed) ); break; case VIK_UNITS_SPEED_METRES_PER_SECOND: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f m/s", tp->speed ); break; case VIK_UNITS_SPEED_KNOTS: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f knots", VIK_MPS_TO_KNOTS(tp->speed) ); break; case VIK_UNITS_SPEED_SECONDS_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f s/km", VIK_MPS_TO_PACE_SPK(tp->speed) ); break; case VIK_UNITS_SPEED_MINUTES_PER_KM: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/km", VIK_MPS_TO_PACE_MPK(tp->speed) ); break; case VIK_UNITS_SPEED_SECONDS_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f s/mi", VIK_MPS_TO_PACE_SPM(tp->speed) ); break; case VIK_UNITS_SPEED_MINUTES_PER_MILE: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f min/mi", VIK_MPS_TO_PACE_MPM(tp->speed) ); break; default: // VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: g_snprintf ( tmp_str, sizeof(tmp_str), "%.2f km/h", VIK_MPS_TO_KPH(tp->speed) ); break; } } gtk_label_set_text ( tpwin->speed, tmp_str ); switch (dist_units) { case VIK_UNITS_DISTANCE_KILOMETRES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f m", tp->hdop ); gtk_label_set_text ( tpwin->hdop, tmp_str ); g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f m", tp->pdop ); gtk_label_set_text ( tpwin->pdop, tmp_str ); break; case VIK_UNITS_DISTANCE_NAUTICAL_MILES: case VIK_UNITS_DISTANCE_MILES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f yards", tp->hdop*1.0936133 ); gtk_label_set_text ( tpwin->hdop, tmp_str ); g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f yards", tp->pdop*1.0936133 ); gtk_label_set_text ( tpwin->pdop, tmp_str ); break; default: g_critical("Houston, we've had a problem. distance=%d", dist_units); } switch (height_units) { case VIK_UNITS_HEIGHT_METRES: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f m", tp->vdop ); break; case VIK_UNITS_HEIGHT_FEET: g_snprintf ( tmp_str, sizeof(tmp_str), "%.5f feet", VIK_METERS_TO_FEET(tp->vdop) ); break; default: g_snprintf ( tmp_str, sizeof(tmp_str), "--" ); g_critical("Houston, we've had a problem. height=%d", height_units); } gtk_label_set_text ( tpwin->vdop, tmp_str ); g_snprintf ( tmp_str, sizeof(tmp_str), "%d / %d", tp->nsats, tp->fix_mode ); gtk_label_set_text ( tpwin->sat, tmp_str ); tpwin->cur_tp = tp; }
/** * vu_trackpoint_formatted_message: * @format_code: String describing the message to generate * @trkpt: The trackpoint for which the message is generated about * @trkpt_prev: A trackpoint (presumed previous) for interpolating values with the other trackpoint (such as speed) * @trk: The track in which the trackpoints reside * * TODO: One day replace this cryptic format code with some kind of tokenizer parsing * thus would make it more user friendly and maybe even GUI controlable. * However for now at least there is some semblance of user control */ gchar* vu_trackpoint_formatted_message ( gchar *format_code, VikTrackpoint *trkpt, VikTrackpoint *trkpt_prev, VikTrack *trk ) { if ( !trkpt ) return NULL; gint len = 0; if ( format_code ) len = strlen ( format_code ); if ( len > FMT_MAX_NUMBER_CODES ) len = FMT_MAX_NUMBER_CODES; gchar* values[FMT_MAX_NUMBER_CODES]; int i; for ( i = 0; i < FMT_MAX_NUMBER_CODES; i++ ) { values[i] = '\0'; } gchar *speed_units_str = NULL; vik_units_speed_t speed_units = a_vik_get_units_speed (); switch (speed_units) { case VIK_UNITS_SPEED_MILES_PER_HOUR: speed_units_str = g_strdup ( _("mph") ); break; case VIK_UNITS_SPEED_METRES_PER_SECOND: speed_units_str = g_strdup ( _("m/s") ); break; case VIK_UNITS_SPEED_KNOTS: speed_units_str = g_strdup ( _("knots") ); break; default: // VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: speed_units_str = g_strdup ( _("km/h") ); break; } gchar *separator = g_strdup ( " | " ); for ( i = 0; i < len; i++ ) { switch ( g_ascii_toupper ( format_code[i] ) ) { case 'G': values[i] = g_strdup ( _("GPSD") ); break; // GPS Preamble case 'K': values[i] = g_strdup ( _("Trkpt") ); break; // Trkpt Preamble case 'S': { gdouble speed = 0.0; gchar *speedtype = NULL; if ( isnan(trkpt->speed) && trkpt_prev ) { if ( trkpt->has_timestamp && trkpt_prev->has_timestamp ) { if ( trkpt->timestamp == trkpt_prev->timestamp ) { // Work out from previous trackpoint location and time difference speed = vik_coord_diff(&(trkpt->coord), &(trkpt_prev->coord)) / ABS(trkpt->timestamp - trkpt_prev->timestamp); switch (speed_units) { case VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: speed = VIK_MPS_TO_KPH(speed); break; case VIK_UNITS_SPEED_MILES_PER_HOUR: speed = VIK_MPS_TO_MPH(speed); break; case VIK_UNITS_SPEED_KNOTS: speed = VIK_MPS_TO_KNOTS(speed); break; default: // VIK_UNITS_SPEED_METRES_PER_SECOND: // Already in m/s so nothing to do break; } speedtype = g_strdup ( "*" ); // Interpolated } else speedtype = g_strdup ( "**" ); } else speedtype = g_strdup ( "**" ); } else { speed = trkpt->speed; speedtype = g_strdup ( "" ); } values[i] = g_strdup_printf ( _("%sSpeed%s %.1f%s"), separator, speedtype, speed, speed_units_str ); g_free ( speedtype ); break; } case 'A': { vik_units_height_t height_units = a_vik_get_units_height (); switch (height_units) { case VIK_UNITS_HEIGHT_FEET: values[i] = g_strdup_printf ( _("%sAlt %dfeet"), separator, (int)round(VIK_METERS_TO_FEET(trkpt->altitude)) ); break; default: //VIK_UNITS_HEIGHT_METRES: values[i] = g_strdup_printf ( _("%sAlt %dm"), separator, (int)round(trkpt->altitude) ); break; } break; } case 'C': { gint heading = isnan(trkpt->course) ? 0 : (gint)round(trkpt->course); values[i] = g_strdup_printf ( _("%sCourse %03d\302\260" ), separator, heading ); break; } case 'P': { if ( trkpt_prev ) { gint diff = (gint) round ( vik_coord_diff ( &(trkpt->coord), &(trkpt_prev->coord) ) ); gchar *dist_units_str = NULL; vik_units_distance_t dist_units = a_vik_get_units_distance (); // expect the difference between track points to be small hence use metres or yards switch (dist_units) { case VIK_UNITS_DISTANCE_MILES: dist_units_str = g_strdup ( _("yards") ); break; default: // VIK_UNITS_DISTANCE_KILOMETRES: dist_units_str = g_strdup ( _("m") ); break; } values[i] = g_strdup_printf ( _("%sDistance diff %d%s"), separator, diff, dist_units_str ); g_free ( dist_units_str ); } break; } case 'T': { gchar tmp[64]; tmp[0] = '\0'; if ( trkpt->has_timestamp ) { // Compact date time format strftime (tmp, sizeof(tmp), "%x %X", localtime(&(trkpt->timestamp))); } else g_snprintf (tmp, sizeof(tmp), "--"); values[i] = g_strdup_printf ( _("%sTime %s"), separator, tmp ); break; } case 'M': { if ( trkpt_prev ) { if ( trkpt->has_timestamp && trkpt_prev->has_timestamp ) { time_t t_diff = trkpt->timestamp - trkpt_prev->timestamp; values[i] = g_strdup_printf ( _("%sTime diff %lds"), separator, t_diff ); } } break; } case 'X': values[i] = g_strdup_printf ( _("%sNo. of Sats %d"), separator, trkpt->nsats ); break; case 'D': { if ( trk ) { // Distance from start (along the track) gdouble distd = vik_track_get_length_to_trackpoint (trk, trkpt); gchar *dist_units_str = NULL; vik_units_distance_t dist_units = a_vik_get_units_distance (); // expect the difference between track points to be small hence use metres or yards switch (dist_units) { case VIK_UNITS_DISTANCE_MILES: dist_units_str = g_strdup ( _("miles") ); distd = VIK_METERS_TO_MILES(distd); break; default: // VIK_UNITS_DISTANCE_KILOMETRES: dist_units_str = g_strdup ( _("km") ); distd = distd / 1000.0; break; } values[i] = g_strdup_printf ( _("%sDistance along %.2f%s"), separator, distd, dist_units_str ); g_free ( dist_units_str ); } break; } case 'L': { // Location (Lat/Long) gchar *lat = NULL, *lon = NULL; struct LatLon ll; vik_coord_to_latlon (&(trkpt->coord), &ll); a_coords_latlon_to_string ( &ll, &lat, &lon ); values[i] = g_strdup_printf ( "%s%s %s", separator, lat, lon ); g_free ( lat ); g_free ( lon ); break; } case 'N': // Name of track values[i] = g_strdup_printf ( _("%sTrack: %s"), separator, trk->name ); break; case 'E': // Name of trackpoint if available if ( trkpt->name ) values[i] = g_strdup_printf ( "%s%s", separator, trkpt->name ); else values[i] = g_strdup ( "" ); break; default: break; } } g_free ( separator ); g_free ( speed_units_str ); gchar *msg = g_strconcat ( values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], NULL ); for ( i = 0; i < FMT_MAX_NUMBER_CODES; i++ ) { if ( values[i] != '\0' ) g_free ( values[i] ); } return msg; }
/* todo: less on this side, like add track */ gchar *a_dialog_waypoint ( GtkWindow *parent, gchar *default_name, VikTrwLayer *vtl, VikWaypoint *wp, VikCoordMode coord_mode, gboolean is_new, gboolean *updated ) { GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Waypoint Properties"), parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); struct LatLon ll; GtkWidget *latlabel, *lonlabel, *namelabel, *latentry, *lonentry, *altentry, *altlabel, *nameentry=NULL; GtkWidget *commentlabel, *commententry, *descriptionlabel, *descriptionentry, *imagelabel, *imageentry, *symbollabel, *symbolentry; GtkWidget *sourcelabel = NULL, *sourceentry = NULL; GtkWidget *typelabel = NULL, *typeentry = NULL; GtkWidget *timelabel = NULL; GtkWidget *timevaluebutton = NULL; GtkWidget *hasGeotagCB = NULL; GtkWidget *consistentGeotagCB = NULL; GtkWidget *direction_sb = NULL; GtkWidget *direction_hb = NULL; GtkListStore *store; gchar *lat, *lon, *alt; vik_coord_to_latlon ( &(wp->coord), &ll ); lat = g_strdup_printf ( "%f", ll.lat ); lon = g_strdup_printf ( "%f", ll.lon ); vik_units_height_t height_units = a_vik_get_units_height (); switch (height_units) { case VIK_UNITS_HEIGHT_METRES: alt = g_strdup_printf ( "%f", wp->altitude ); break; case VIK_UNITS_HEIGHT_FEET: alt = g_strdup_printf ( "%f", VIK_METERS_TO_FEET(wp->altitude) ); break; default: alt = g_strdup_printf ( "%f", wp->altitude ); g_critical("Houston, we've had a problem. height=%d", height_units); } *updated = FALSE; namelabel = gtk_label_new (_("Name:")); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), namelabel, FALSE, FALSE, 0); // Name is now always changeable nameentry = gtk_entry_new (); if ( default_name ) gtk_entry_set_text( GTK_ENTRY(nameentry), default_name ); g_signal_connect_swapped ( nameentry, "activate", G_CALLBACK(a_dialog_response_accept), GTK_DIALOG(dialog) ); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), nameentry, FALSE, FALSE, 0); latlabel = gtk_label_new (_("Latitude:")); latentry = gtk_entry_new (); gtk_entry_set_text ( GTK_ENTRY(latentry), lat ); g_free ( lat ); lonlabel = gtk_label_new (_("Longitude:")); lonentry = gtk_entry_new (); gtk_entry_set_text ( GTK_ENTRY(lonentry), lon ); g_free ( lon ); altlabel = gtk_label_new (_("Altitude:")); altentry = gtk_entry_new (); gtk_entry_set_text ( GTK_ENTRY(altentry), alt ); g_free ( alt ); if ( wp->comment && !strncmp(wp->comment, "http", 4) ) commentlabel = gtk_link_button_new_with_label (wp->comment, _("Comment:") ); else commentlabel = gtk_label_new (_("Comment:")); commententry = gtk_entry_new (); gchar *cmt = NULL; // Auto put in some kind of 'name' as a comment if one previously 'goto'ed this exact location cmt = a_vik_goto_get_search_string_for_this_place(VIK_WINDOW(parent)); if (cmt) gtk_entry_set_text(GTK_ENTRY(commententry), cmt); if ( wp->description && !strncmp(wp->description, "http", 4) ) descriptionlabel = gtk_link_button_new_with_label (wp->description, _("Description:") ); else descriptionlabel = gtk_label_new (_("Description:")); descriptionentry = gtk_entry_new (); sourcelabel = gtk_label_new (_("Source:")); if ( wp->source ) { sourceentry = gtk_entry_new (); gtk_entry_set_text(GTK_ENTRY(sourceentry), wp->source); } typelabel = gtk_label_new (_("Type:")); if ( wp->type ) { typeentry = gtk_entry_new (); gtk_entry_set_text(GTK_ENTRY(typeentry), wp->type); } imagelabel = gtk_label_new (_("Image:")); imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, VF_FILTER_IMAGE, NULL, NULL); { GtkCellRenderer *r; symbollabel = gtk_label_new (_("Symbol:")); GtkTreeIter iter; store = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING); symbolentry = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(symbolentry), 6); g_signal_connect(symbolentry, "changed", G_CALLBACK(symbol_entry_changed_cb), store); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, NULL, 1, NULL, 2, _("(none)"), -1); a_populate_sym_list(store); r = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "pixbuf", 1, NULL); r = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (symbolentry), r, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (symbolentry), r, "text", 2, NULL); if ( !is_new && wp->symbol ) { gboolean ok; gchar *sym; for (ok = gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &iter ); ok; ok = gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter)) { gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 ); if (sym && !strcmp(sym, wp->symbol)) { g_free(sym); break; } else { g_free(sym); } } // Ensure is it a valid symbol in the given symbol set (large vs small) // Not all symbols are available in both // The check prevents a Gtk Critical message if ( iter.stamp ) gtk_combo_box_set_active_iter(GTK_COMBO_BOX(symbolentry), &iter); } } if ( !is_new && wp->comment ) gtk_entry_set_text ( GTK_ENTRY(commententry), wp->comment ); if ( !is_new && wp->description ) gtk_entry_set_text ( GTK_ENTRY(descriptionentry), wp->description ); if ( !edit_wp ) edit_wp = vik_waypoint_new (); edit_wp = vik_waypoint_copy ( wp ); if ( !is_new && wp->image ) { vik_file_entry_set_filename ( VIK_FILE_ENTRY(imageentry), wp->image ); #ifdef VIK_CONFIG_GEOTAG // Geotag Info [readonly] hasGeotagCB = gtk_check_button_new_with_label ( _("Has Geotag") ); gtk_widget_set_sensitive ( hasGeotagCB, FALSE ); gboolean hasGeotag; gchar *ignore = a_geotag_get_exif_date_from_file ( wp->image, &hasGeotag ); g_free ( ignore ); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(hasGeotagCB), hasGeotag ); consistentGeotagCB = gtk_check_button_new_with_label ( _("Consistent Position") ); gtk_widget_set_sensitive ( consistentGeotagCB, FALSE ); if ( hasGeotag ) { struct LatLon ll = a_geotag_get_position ( wp->image ); VikCoord coord; vik_coord_load_from_latlon ( &coord, coord_mode, &ll ); gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(consistentGeotagCB), vik_coord_equalish(&coord, &wp->coord) ); } // ATM the direction value box is always shown, even when there is no information. // It would be nice to be able to hide it until the 'Add' has been performed, // however I've not been able to achieve this. // Thus simply sensistizing it instead. GtkWidget *direction_label = gtk_label_new ( _("Image Direction:") ); direction_hb = gtk_hbox_new ( FALSE, 0 ); gtk_box_pack_start (GTK_BOX(direction_hb), direction_label, FALSE, FALSE, 0); direction_sb = gtk_spin_button_new ( (GtkAdjustment*)gtk_adjustment_new (0, 0.0, 359.9, 5.0, 1, 0 ), 1, 1 ); if ( !is_new && !isnan(wp->image_direction) ) { GtkWidget *direction_ref = gtk_label_new ( NULL ); if ( wp->image_direction_ref == WP_IMAGE_DIRECTION_REF_MAGNETIC ) gtk_label_set_label ( GTK_LABEL(direction_ref), _("Magnetic") ); else gtk_label_set_label ( GTK_LABEL(direction_ref), _("True") ); gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref, TRUE, FALSE, 0); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(direction_sb), wp->image_direction ); } else { GtkWidget *direction_ref_button = gtk_button_new (); gtk_button_set_relief ( GTK_BUTTON(direction_ref_button), GTK_RELIEF_NONE ); GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU ); gtk_button_set_image ( GTK_BUTTON(direction_ref_button), img ); gtk_box_pack_start (GTK_BOX(direction_hb), direction_ref_button, TRUE, FALSE, 0); gtk_widget_set_sensitive ( direction_sb, FALSE ); direction_signal_id = g_signal_connect ( G_OBJECT(direction_ref_button), "button-release-event", G_CALLBACK(direction_add_click), direction_sb ); } #endif } timelabel = gtk_label_new ( _("Time:") ); timevaluebutton = gtk_button_new(); gtk_button_set_relief ( GTK_BUTTON(timevaluebutton), GTK_RELIEF_NONE ); // TODO: Consider if there should be a remove time button... if ( !is_new && wp->has_timestamp ) { update_time ( timevaluebutton, wp ); } else { GtkWidget *img = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_MENU ); gtk_button_set_image ( GTK_BUTTON(timevaluebutton), img ); // Initially use current time or otherwise whatever the last value used was if ( edit_wp->timestamp == 0 ) { time ( &edit_wp->timestamp ); } } g_signal_connect ( G_OBJECT(timevaluebutton), "button-release-event", G_CALLBACK(time_edit_click), edit_wp ); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latlabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), latentry, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonlabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), lonentry, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timelabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), timevaluebutton, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altlabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), altentry, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commentlabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), commententry, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionlabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), descriptionentry, FALSE, FALSE, 0); if ( wp->source ) { gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourcelabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), sourceentry, FALSE, FALSE, 0); } if ( wp->type ) { gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typelabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), typeentry, FALSE, FALSE, 0); } gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imagelabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), imageentry, FALSE, FALSE, 0); if ( hasGeotagCB ) { GtkWidget *hbox = gtk_hbox_new ( FALSE, 0 ); gtk_box_pack_start (GTK_BOX(hbox), hasGeotagCB, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(hbox), consistentGeotagCB, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), hbox, FALSE, FALSE, 0); } if ( direction_hb ) gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_hb, FALSE, FALSE, 0); if ( direction_sb ) gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), direction_sb, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), symbollabel, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GTK_WIDGET(symbolentry), FALSE, FALSE, 0); gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT ); gtk_widget_show_all ( gtk_dialog_get_content_area(GTK_DIALOG(dialog)) ); if ( !is_new ) { // Shift left<->right to try not to obscure the waypoint. trw_layer_dialog_shift ( vtl, GTK_WINDOW(dialog), &(wp->coord), FALSE ); } while ( gtk_dialog_run ( GTK_DIALOG(dialog) ) == GTK_RESPONSE_ACCEPT ) { if ( strlen((gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) )) == 0 ) /* TODO: other checks (isalpha or whatever ) */ a_dialog_info_msg ( parent, _("Please enter a name for the waypoint.") ); else { // NB: No check for unique names - this allows generation of same named entries. gchar *entered_name = g_strdup ( (gchar*)gtk_entry_get_text ( GTK_ENTRY(nameentry) ) ); /* Do It */ ll.lat = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(latentry) ) ); ll.lon = convert_dms_to_dec ( gtk_entry_get_text ( GTK_ENTRY(lonentry) ) ); vik_coord_load_from_latlon ( &(wp->coord), coord_mode, &ll ); // Always store in metres switch (height_units) { case VIK_UNITS_HEIGHT_METRES: wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) ); break; case VIK_UNITS_HEIGHT_FEET: wp->altitude = VIK_FEET_TO_METERS(atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) )); break; default: wp->altitude = atof ( gtk_entry_get_text ( GTK_ENTRY(altentry) ) ); g_critical("Houston, we've had a problem. height=%d", height_units); } if ( g_strcmp0 ( wp->comment, gtk_entry_get_text ( GTK_ENTRY(commententry) ) ) ) vik_waypoint_set_comment ( wp, gtk_entry_get_text ( GTK_ENTRY(commententry) ) ); if ( g_strcmp0 ( wp->description, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) ) ) vik_waypoint_set_description ( wp, gtk_entry_get_text ( GTK_ENTRY(descriptionentry) ) ); if ( g_strcmp0 ( wp->image, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) ) ) vik_waypoint_set_image ( wp, vik_file_entry_get_filename ( VIK_FILE_ENTRY(imageentry) ) ); if ( sourceentry && g_strcmp0 ( wp->source, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) ) ) vik_waypoint_set_source ( wp, gtk_entry_get_text ( GTK_ENTRY(sourceentry) ) ); if ( typeentry && g_strcmp0 ( wp->type, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) ) ) vik_waypoint_set_type ( wp, gtk_entry_get_text ( GTK_ENTRY(typeentry) ) ); if ( wp->image && *(wp->image) && (!a_thumbnails_exists(wp->image)) ) a_thumbnails_create ( wp->image ); if ( edit_wp->timestamp ) { wp->timestamp = edit_wp->timestamp; wp->has_timestamp = TRUE; } if ( direction_sb ) { if ( gtk_widget_get_sensitive (direction_sb) ) { wp->image_direction = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(direction_sb) ); if ( wp->image_direction != edit_wp->image_direction ) a_geotag_write_exif_gps ( wp->image, wp->coord, wp->altitude, wp->image_direction, wp->image_direction_ref, TRUE ); } } GtkTreeIter iter, first; gtk_tree_model_get_iter_first ( GTK_TREE_MODEL(store), &first ); if ( !gtk_combo_box_get_active_iter ( GTK_COMBO_BOX(symbolentry), &iter ) || !memcmp(&iter, &first, sizeof(GtkTreeIter)) ) { vik_waypoint_set_symbol ( wp, NULL ); } else { gchar *sym; gtk_tree_model_get ( GTK_TREE_MODEL(store), &iter, 0, (void *)&sym, -1 ); vik_waypoint_set_symbol ( wp, sym ); g_free(sym); } gtk_widget_destroy ( dialog ); if ( is_new ) return entered_name; else { *updated = TRUE; // See if name has been changed if ( g_strcmp0 (default_name, entered_name ) ) return entered_name; else return NULL; } } } gtk_widget_destroy ( dialog ); return NULL; }
/** * vik_trw_layer_waypoint_list_internal: * @dialog: The dialog to create the widgets in * @waypoints_and_layers: The list of waypoints (and it's layer) to be shown * @show_layer_names: Show the layer names that each waypoint belongs to * * Create a table of waypoints with corresponding waypoint information * This table does not support being actively updated */ static void vik_trw_layer_waypoint_list_internal ( GtkWidget *dialog, GList *waypoints_and_layers, gboolean show_layer_names ) { if ( !waypoints_and_layers ) return; // It's simple storing the gdouble values in the tree store as the sort works automatically // Then apply specific cell data formatting (rather default double is to 6 decimal places!) // However not storing any doubles for waypoints ATM // TODO: Consider adding the waypoint icon into this store for display in the list GtkTreeStore *store = gtk_tree_store_new ( WPT_LIST_COLS, G_TYPE_STRING, // 0: Layer Name G_TYPE_STRING, // 1: Waypoint Name G_TYPE_STRING, // 2: Date G_TYPE_BOOLEAN, // 3: Visible G_TYPE_STRING, // 4: Comment G_TYPE_INT, // 5: Height GDK_TYPE_PIXBUF, // 6: Symbol Icon G_TYPE_POINTER, // 7: TrackWaypoint Layer pointer G_TYPE_POINTER ); // 8: Waypoint pointer //gtk_tree_selection_set_select_function ( gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL ); vik_units_height_t height_units = a_vik_get_units_height (); //GList *gl = get_waypoints_and_layers_cb ( vl, user_data ); //g_list_foreach ( waypoints_and_layers, (GFunc) trw_layer_waypoint_list_add, store ); GList *gl = waypoints_and_layers; while ( gl ) { trw_layer_waypoint_list_add ( (vik_trw_waypoint_list_t*)gl->data, store, height_units ); gl = g_list_next ( gl ); } GtkWidget *view = gtk_tree_view_new(); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); GtkTreeViewColumn *column; GtkTreeViewColumn *sort_by_column; gint column_runner = 0; if ( show_layer_names ) { // Insert column for the layer name when viewing multi layers column = my_new_column_text ( _("Layer"), renderer, view, column_runner++ ); g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_set_expand ( column, TRUE ); // remember the layer column so we can sort by it later sort_by_column = column; } else column_runner++; column = my_new_column_text ( _("Name"), renderer, view, column_runner++ ); gtk_tree_view_column_set_expand ( column, TRUE ); if ( !show_layer_names ) // remember the name column so we can sort by it later sort_by_column = column; column = my_new_column_text ( _("Date"), renderer, view, column_runner++ ); gtk_tree_view_column_set_resizable ( column, TRUE ); GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes ( _("Visible"), renderer_toggle, "active", column_runner, NULL ); gtk_tree_view_column_set_sort_column_id ( column, column_runner ); gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column ); column_runner++; column = my_new_column_text ( _("Comment"), renderer, view, column_runner++ ); gtk_tree_view_column_set_expand ( column, TRUE ); if ( height_units == VIK_UNITS_HEIGHT_FEET ) column = my_new_column_text ( _("Max Height\n(Feet)"), renderer, view, column_runner++ ); else column = my_new_column_text ( _("Max Height\n(Metres)"), renderer, view, column_runner++ ); GtkCellRenderer *renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); g_object_set (G_OBJECT (renderer_pixbuf), "xalign", 0.5, NULL); column = gtk_tree_view_column_new_with_attributes ( _("Symbol"), renderer_pixbuf, "pixbuf", column_runner++, NULL ); // Special sort required for pixbufs gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE(store), column_runner, sort_pixbuf_compare_func, NULL, NULL ); gtk_tree_view_column_set_sort_column_id ( column, column_runner ); gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column ); gtk_tree_view_set_model ( GTK_TREE_VIEW(view), GTK_TREE_MODEL(store) ); gtk_tree_selection_set_mode ( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_BROWSE ); // GTK_SELECTION_MULTIPLE gtk_tree_view_set_rules_hint ( GTK_TREE_VIEW(view), TRUE ); g_object_unref(store); GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_container_add ( GTK_CONTAINER(scrolledwindow), view ); g_object_set ( view, "has-tooltip", TRUE, NULL); g_signal_connect ( view, "query-tooltip", G_CALLBACK (trw_layer_waypoint_tooltip_cb), NULL ); //g_signal_connect ( gtk_tree_view_get_selection (GTK_TREE_VIEW(view)), "changed", G_CALLBACK(trw_layer_waypoint_select_cb), view ); g_signal_connect ( view, "popup-menu", G_CALLBACK(trw_layer_waypoint_menu_popup), waypoints_and_layers ); g_signal_connect ( view, "button-press-event", G_CALLBACK(trw_layer_waypoint_button_pressed), waypoints_and_layers ); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0); // Set ordering of the initial view by one of the name columns gtk_tree_view_column_clicked ( sort_by_column ); // Ensure a reasonable number of items are shown // TODO: may be save window size, column order, sorted by between invocations. gtk_window_set_default_size ( GTK_WINDOW(dialog), show_layer_names ? 700 : 500, 400 ); }
/** * table_output: * * Update the given widgets table with the values from the track stats */ static void table_output ( track_stats ts, GtkWidget *content[], gboolean extended ) { int cnt = 0; gchar tmp_buf[64]; g_snprintf ( tmp_buf, sizeof(tmp_buf), "%d", ts.count ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.count == 0 ) { // Blank all other fields g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); for ( cnt = 1; cnt < G_N_ELEMENTS(label_texts); cnt++ ) gtk_label_set_text ( GTK_LABEL(content[cnt]), tmp_buf ); return; } // Check for potential date range // Test if the same day by comparing the date string of the timestamp GDate* gdate_start = g_date_new (); g_date_set_time_t ( gdate_start, ts.start_time ); gchar time_start[32]; g_date_strftime ( time_start, sizeof(time_start), "%x", gdate_start ); g_date_free ( gdate_start ); GDate* gdate_end = g_date_new (); g_date_set_time_t ( gdate_end, ts.end_time ); gchar time_end[32]; g_date_strftime ( time_end, sizeof(time_end), "%x", gdate_end ); g_date_free ( gdate_end ); if ( ts.start_time == ts.end_time ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("No Data") ); else if ( strncmp(time_start, time_end, 32) ) g_snprintf ( tmp_buf, sizeof(tmp_buf), "%s --> %s", time_start, time_end ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "%s", time_start ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); switch (a_vik_get_units_distance ()) { case VIK_UNITS_DISTANCE_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f miles"), VIK_METERS_TO_MILES(ts.length) ); break; case VIK_UNITS_DISTANCE_NAUTICAL_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f NM"), VIK_METERS_TO_NAUTICAL_MILES(ts.length) ); break; default: //VIK_UNITS_DISTANCE_KILOMETRES g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f km"), ts.length/1000.0 ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); switch (a_vik_get_units_distance ()) { case VIK_UNITS_DISTANCE_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f miles"), (VIK_METERS_TO_MILES(ts.length)/ts.count) ); break; case VIK_UNITS_DISTANCE_NAUTICAL_MILES: g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f NM"), (VIK_METERS_TO_NAUTICAL_MILES(ts.length)/ts.count) ); break; default: //VIK_UNITS_DISTANCE_KILOMETRES g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f km"), ts.length/(1000.0*ts.count) ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( extended ) { // Note that this currently is a simplified approach to calculate the Eddington number. // In that a per track value is used, rather than trying to work out a length per day. // (i.e. doesn't combine multiple tracks for a single day or split very long tracks into days) tracks_stats[TS_TRACKS].e_list = g_list_sort ( tracks_stats[TS_TRACKS].e_list, rsort_by_distance ); guint Eddington = 0; guint position = 0; for (GList *iter = g_list_first (tracks_stats[TS_TRACKS].e_list); iter != NULL; iter = g_list_next (iter)) { position++; gdouble *num = (gdouble*)iter->data; if ( *num > position ) Eddington = position; } g_snprintf ( tmp_buf, sizeof(tmp_buf), ("%d"), Eddington ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); } else cnt++; // I'm sure this could be cleaner... g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); switch (a_vik_get_units_speed()) { case VIK_UNITS_SPEED_MILES_PER_HOUR: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f mph"), (double)VIK_MPS_TO_MPH(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), ("%.1f mph"), (double)VIK_MPS_TO_MPH(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_METRES_PER_SECOND: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f m/s"), (double)ts.max_speed ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), ("%.2f m/s"), (double)(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_KNOTS: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f knots"), (double)VIK_MPS_TO_KNOTS(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f knots"), (double)VIK_MPS_TO_KNOTS(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_SECONDS_PER_KM: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d s/km"), (int)VIK_MPS_TO_PACE_SPK(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d s/km"), (int)VIK_MPS_TO_PACE_SPK(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_MINUTES_PER_KM: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/km"), (double)VIK_MPS_TO_PACE_MPK(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/km"), (double)VIK_MPS_TO_PACE_MPK(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_SECONDS_PER_MILE: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d sec/mi"), (int)VIK_MPS_TO_PACE_SPM(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d sec/mi"), (int)VIK_MPS_TO_PACE_SPM(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; case VIK_UNITS_SPEED_MINUTES_PER_MILE: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/mi"), (double)VIK_MPS_TO_PACE_MPM(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.1f min/mi"), (double)VIK_MPS_TO_PACE_MPM(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; default: //VIK_UNITS_SPEED_KILOMETRES_PER_HOUR: if ( ts.max_speed > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f km/h"), (double)VIK_MPS_TO_KPH(ts.max_speed) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.duration > 0 ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%.2f km/h"), (double)VIK_MPS_TO_KPH(ts.length/ts.duration) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); switch ( a_vik_get_units_height() ) { // Note always round off height value output since sub unit accuracy is overkill case VIK_UNITS_HEIGHT_FEET: if ( ts.min_alt != VIK_VAL_MIN_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet"), (int)round(VIK_METERS_TO_FEET(ts.min_alt)) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.max_alt != VIK_VAL_MAX_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet"), (int)round(VIK_METERS_TO_FEET(ts.max_alt)) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet / %d feet"), (int)round(VIK_METERS_TO_FEET(ts.elev_gain)), (int)round(VIK_METERS_TO_FEET(ts.elev_loss)) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d feet / %d feet"), (int)round(VIK_METERS_TO_FEET(ts.elev_gain/ts.count)), (int)round(VIK_METERS_TO_FEET(ts.elev_loss/ts.count)) ); break; default: //VIK_UNITS_HEIGHT_METRES if ( ts.min_alt != VIK_VAL_MIN_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m"), (int)round(ts.min_alt) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); if ( ts.max_alt != VIK_VAL_MAX_ALT ) g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m"), (int)round(ts.max_alt) ); else g_snprintf ( tmp_buf, sizeof(tmp_buf), "--" ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m / %d m"), (int)round(ts.elev_gain), (int)round(ts.elev_loss) ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d m / %d m"), (int)round(ts.elev_gain/ts.count), (int)round(ts.elev_loss/ts.count) ); break; } gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); gint hours; gint minutes; gint days; // Total Duration days = (gint)(ts.duration / (60*60*24)); hours = (gint)floor((ts.duration - (days*60*60*24)) / (60*60)); minutes = (gint)((ts.duration - (days*60*60*24) - (hours*60*60)) / 60); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d:%02d:%02d days:hrs:mins"), days, hours, minutes ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); // Average Duration gint avg_dur = ts.duration / ts.count; hours = (gint)floor(avg_dur / (60*60)); minutes = (gint)((avg_dur - (hours*60*60)) / 60); g_snprintf ( tmp_buf, sizeof(tmp_buf), _("%d:%02d hrs:mins"), hours, minutes ); gtk_label_set_text ( GTK_LABEL(content[cnt++]), tmp_buf ); }