int editor_track_report_get_current_position (RoadMapGpsPosition* GPS_position,
int* from_node,
int* to_node,
int* direction) {
PluginLine line;
//TODO: change implementation to use internal trkseg info
(*from_node) = (*to_node) = -1;
if( -1 == roadmap_navigate_get_current( GPS_position, &line, direction))
{
// This is not an error:
roadmap_log( ROADMAP_DEBUG, "editor_track_report_get_current_position() - 'roadmap_navigate_get_current()' failed");
return 0;
}
editor_track_util_get_line_point_ids (&line,
ROUTE_DIRECTION_AGAINST_LINE == *direction,
from_node,
to_node);
if( (-1 == (*from_node)) || (-1 == (*to_node)))
{
roadmap_log( ROADMAP_WARNING, "editor_track_report_get_current_position() - 'editor_track_util_get_line_point_ids()' returned (from:%d; to:%d) for (line %d",
(*from_node), (*to_node), line.line_id);
(*from_node) = (*to_node) = -1;
return 0;
}
return 1;
}
static void append_current_location( char* buffer)
{
char float_string_longitude[32];
char float_string_latitude [32];
PluginLine line;
int direction;
RoadMapGpsPosition MyLocation;
if( roadmap_navigate_get_current( &MyLocation, &line, &direction) != -1)
{
convert_int_coordinate_to_float_string( float_string_longitude, MyLocation.longitude);
convert_int_coordinate_to_float_string( float_string_latitude , MyLocation.latitude);
sprintf( buffer, "&lon=%s&lat=%s", float_string_longitude, float_string_latitude);
}
else{
const RoadMapPosition *Location;
Location = roadmap_trip_get_position( "Location" );
if ( (Location != NULL) && !IS_DEFAULT_LOCATION( Location ) ){
convert_int_coordinate_to_float_string( float_string_longitude, Location->longitude);
convert_int_coordinate_to_float_string( float_string_latitude , Location->latitude);
sprintf( buffer, "&lon=%s&lat=%s", float_string_longitude, float_string_latitude);
}
else{
roadmap_log( ROADMAP_DEBUG, "address_search::no location used");
sprintf( buffer, "&lon=0&lat=0");
}
}
}
static int report_irrelevant(SsdWidget widget, const char *new_value, void *context){
char message[200];
PluginLine line;
int direction;
const char *str;
RoadMapGpsPosition *CurrentGpsPoint;
if (the_active_alert.active_alert_id == -1)
return 1;
CurrentGpsPoint = malloc(sizeof(*CurrentGpsPoint));
if (roadmap_navigate_get_current
(CurrentGpsPoint, &line, &direction) == -1) {
roadmap_messagebox ("Error", "Can't find current street.");
return 0;
}
roadmap_trip_set_gps_position ("AlertSelection", "Selection", NULL, CurrentGpsPoint);
str = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_string)) (the_active_alert.active_alert_id);
if (str != NULL){
const char *alertStr = roadmap_lang_get(str);
sprintf(message,"%s\n%s",roadmap_lang_get("Please confirm that the following alert is not relevant:"), alertStr);
ssd_confirm_dialog("Delete Alert", message,FALSE, delete_callback, (void *)NULL);
}
return 1;
}
int editor_track_is_new_direction_roads (){
PluginLine line;
static int last_state;
if (!TrackConfirmedStreet.valid){
last_state = FALSE;
return FALSE;
}
if (editor_override_exists(TrackConfirmedLine.line.line_id, TrackConfirmedLine.line.square)) {
last_state = FALSE;
return FALSE;
}else{
int direction;
roadmap_square_set_current(TrackConfirmedLine.line.square);
if ((roadmap_navigate_get_current(NULL, &line, &direction) == -1) ||
(!roadmap_plugin_same_line(&line, &TrackConfirmedLine.line)))
return last_state;
if (!roadmap_line_route_is_low_weight (TrackConfirmedLine.line.line_id)) {
last_state = FALSE;
return FALSE;
}
last_state = TRUE;
return TRUE;
}
}
void update_range_dialog(void) {
RoadMapPosition from;
RoadMapPosition to;
PluginLine line;
RoadMapNeighbour result;
int direction;
if (roadmap_navigate_get_current
(&CurrentGpsPoint, &line, &direction) == -1) {
roadmap_messagebox ("Error", "Can't find current street.");
return;
}
roadmap_plugin_line_from (&line, &from);
roadmap_plugin_line_to (&line, &to);
if (!roadmap_plugin_get_distance
((RoadMapPosition *)&CurrentGpsPoint, &line, &result)) {
roadmap_messagebox ("Error", "Can't find a road near point.");
return;
}
CurrentFixedPosition = result.intersection;
#ifndef SSD
if (roadmap_dialog_activate ("Update house number", NULL, 1)) {
roadmap_dialog_new_label ("Update", STREET_PREFIX);
roadmap_dialog_new_label ("Update", CITY_PREFIX);
roadmap_dialog_new_label ("Update", "Estimated");
roadmap_dialog_new_entry ("Update", UPDATE_LEFT, NULL);
roadmap_dialog_new_entry ("Update", UPDATE_RIGHT, NULL);
roadmap_dialog_add_button ("Cancel", update_range_cancel);
roadmap_dialog_add_button ("OK", update_range_apply);
roadmap_dialog_complete (roadmap_preferences_use_keyboard ());
}
#else
if (!ssd_dialog_activate ("Update house number", NULL)) {
create_ssd_dialog();
ssd_dialog_activate ("Update house number", NULL);
}
#endif
fill_dialog (&line, &CurrentFixedPosition, direction);
}
static void SpeedCheck_Timer(void){
RoadMapGpsPosition pos;
BOOL gps_active;
gps_active = roadmap_gps_have_reception();
if (!gps_active)
return;
roadmap_navigate_get_current(&pos, NULL, NULL);
if (pos.speed < 2){
roadmap_main_remove_periodic(SpeedCheck_Timer);
display_ticker();
}
}
static BOOL RealtimeAltRoutes_GetOrigin(RoadMapGpsPosition *pos, PluginLine *line, int *fromPoint){
int direction;
if ((roadmap_navigate_get_current (pos, line, &direction) != -1) &&
(roadmap_plugin_get_id(line) == ROADMAP_PLUGIN_ID)){
int from;
int to;
roadmap_square_set_current (line->square);
roadmap_line_points (line->line_id, &from, &to);
if (direction == ROUTE_DIRECTION_WITH_LINE){
*fromPoint = to;
} else{
*fromPoint = from;
}
return TRUE;
}
return FALSE;
}
static void softkey_callback(void) {
char message[200];
PluginLine line;
int direction;
RoadMapGpsPosition *CurrentGpsPoint;
CurrentGpsPoint = malloc(sizeof(*CurrentGpsPoint));
if (roadmap_navigate_get_current
(CurrentGpsPoint, &line, &direction) == -1) {
roadmap_messagebox ("Error", "Can't find current street.");
return;
}
roadmap_trip_set_gps_position ("AlertSelection", "Selection", NULL, CurrentGpsPoint);
sprintf(message,"%s\n%s",roadmap_lang_get("Please confirm that the following alert is not relevant:"), roadmap_lang_get((* (RoadMapAlertProvidors.providor[the_active_alert.alert_providor]->get_string)) (the_active_alert.active_alert_id) ));
ssd_confirm_dialog("Delete Alert", message,FALSE, delete_callback, (void *)NULL);
alert_should_be_visible = FALSE;
}
static void OnUserContribution(int iUserContribution, int iTrafficInfoId){
traffic_info_context *context;
RoadMapGpsPosition pos;
static BOOL ask_once = FALSE;
roadmap_navigate_get_current(&pos, NULL, NULL);
if (pos.speed > 20)
return;
if (ask_once)
return;
editor_points_add_new_points(iUserContribution);
editor_points_display_new_points_timed(iUserContribution, 6, user_contribution_event);
context = ( traffic_info_context* ) malloc( sizeof( traffic_info_context ) );
context->iTrafficInfoId = iTrafficInfoId;
context->iUserContribution = iUserContribution;
ssd_confirm_dialog_timeout("Traffic detected","Are you experiencing traffic?",TRUE, TrafficConfirmedCallback, context ,10);
ask_once = TRUE;
}
static int report_irrelevant(SsdWidget widget, const char *new_value, void *context){
PluginLine line;
int direction;
RoadMapGpsPosition *CurrentGpsPoint;
BOOL success;
if (the_active_alert.active_alert_id == -1)
return 1;
CurrentGpsPoint = malloc(sizeof(*CurrentGpsPoint));
if (roadmap_navigate_get_current
(CurrentGpsPoint, &line, &direction) == -1) {
roadmap_messagebox ("Error", "Can't find current street.");
return 0;
}
success = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->cancel))(the_active_alert.active_alert_id);
alert_active = FALSE;
the_active_alert.active_alert_id = -1;
alert_should_be_visible = FALSE;
return 1;
}
static void roadmap_speedometer_after_refresh (void){
RoadMapGuiPoint image_position;
RoadMapGuiPoint text_position;
RoadMapGuiPoint units_position;
RoadMapGpsPosition pos;
RoadMapPen speedometer_pen;
char str[30];
char unit_str[30];
int font_size = 20;
int font_size_units = 10;
int speed_offset = 6;
int units_offset = 6;
int speed;
#ifdef IPHONE_NATIVE
font_size = 18;
font_size_units = 8;
#else
if ( roadmap_lang_rtl() )
font_size_units--; // Longer text for units
#endif
if (SpeedometerImage == NULL){
return;
}
if (gHideSpeedometer){
after_refresh_callback();
return;
}
if (!roadmap_map_settings_isShowSpeedometer()){
after_refresh_callback();
return;
}
if (roadmap_screen_is_hd_screen()){
speed_offset *= 1.5;
units_offset *= 1.5;
}
roadmap_navigate_get_current (&pos, NULL, NULL);
speed = pos.speed;
if ((speed == -1) || !roadmap_gps_have_reception()){
after_refresh_callback();
return;
}
speedometer_pen = roadmap_canvas_create_pen ("speedometer_pen");
if (roadmap_skin_state() == 1)
roadmap_canvas_set_foreground(SPEEDOMETER_SPEED_COLOR_NIGHT);
else
roadmap_canvas_set_foreground(SPEEDOMETER_SPEED_COLOR_DAY);
image_position.x = roadmap_canvas_width() - roadmap_canvas_image_width(SpeedometerImage);
image_position.y = roadmap_canvas_height() - roadmap_canvas_image_height(SpeedometerImage) - roadmap_bar_bottom_height() - gOffset;
roadmap_canvas_draw_image (SpeedometerImage, &image_position, 0, IMAGE_NORMAL);
text_position.y = image_position.y + roadmap_canvas_image_height(SpeedometerImage) *.8;
units_position.y = image_position.y + roadmap_canvas_image_height(SpeedometerImage)*.8;
if (speed != -1){
if (!roadmap_gps_is_show_raw()) {
snprintf (str, sizeof(str), "%3d", roadmap_math_to_speed_unit(speed));
snprintf (unit_str, sizeof(unit_str), "%s", roadmap_lang_get(roadmap_math_speed_unit()));
} else {
snprintf (str, sizeof(str), "%3d", pos.accuracy);
snprintf (unit_str, sizeof(unit_str), "%s", "ac");
}
if (ssd_widget_rtl(NULL)){
text_position.x = roadmap_canvas_width() -speed_offset;
roadmap_canvas_draw_string_size(&text_position, ROADMAP_CANVAS_BOTTOMRIGHT, font_size, str);
units_position.x = image_position.x + units_offset;
roadmap_canvas_draw_string_size(&units_position, ROADMAP_CANVAS_BOTTOMLEFT, font_size_units, unit_str);
}
else{
text_position.x = image_position.x + speed_offset;
roadmap_canvas_draw_string_size(&text_position, ROADMAP_CANVAS_BOTTOMLEFT, font_size, str);
units_position.x = roadmap_canvas_width() -units_offset;
roadmap_canvas_draw_string_size(&units_position, ROADMAP_CANVAS_BOTTOMRIGHT, font_size_units, unit_str);
}
}
after_refresh_callback();
}
