void ssd_dialog_allign_focus(void){
SsdSize size;
int height;
int min;
SsdWidget title;
title = ssd_widget_get (RoadMapDialogCurrent->container, "title_bar");
if (title)
min = title->cached_size.height;
else
min = 0;
#ifndef TOUCH_SCREEN
if (!is_screen_wide())
min += roadmap_bar_top_height();
if( SSD_TAB_CONTROL & RoadMapDialogCurrent->container->flags)
min += ssd_tabcontrol_get_height();
#endif
#ifdef TOUCH_SCREEN
height = roadmap_canvas_height();
#else
height = roadmap_canvas_height() - roadmap_bar_bottom_height();
#endif
if (RoadMapDialogCurrent->in_focus && RoadMapDialogCurrent->scroll_container){
if ((RoadMapDialogCurrent->in_focus->position.y == -1) || (RoadMapDialogCurrent->in_focus->position.x == -1 )){
RoadMapDialogCurrent->in_focus->position.y = 0;
RoadMapDialogCurrent->scroll_container->offset_y +=20;
}
ssd_widget_get_size(RoadMapDialogCurrent->in_focus, &size, NULL);
if (( RoadMapDialogCurrent->in_focus->position.y == 0) || ((size.height + RoadMapDialogCurrent->in_focus->position.y) > height)){
while (( RoadMapDialogCurrent->in_focus->position.y == 0) || ((size.height + RoadMapDialogCurrent->in_focus->position.y) > height)) {
ssd_widget_set_offset(RoadMapDialogCurrent->scroll_container, 0, RoadMapDialogCurrent->scroll_container->offset_y-20);
ssd_dialog_draw();
}
while (RoadMapDialogCurrent->in_focus->position.y < min){
ssd_widget_set_offset(RoadMapDialogCurrent->scroll_container, 0, RoadMapDialogCurrent->scroll_container->offset_y+20);
ssd_dialog_draw();
}
}
else{
while (RoadMapDialogCurrent->in_focus->position.y < min){
ssd_widget_set_offset(RoadMapDialogCurrent->scroll_container, 0, RoadMapDialogCurrent->scroll_container->offset_y+20);
ssd_dialog_draw();
}
}
}
}
void ssd_generic_icon_list_dialog_show(
const char* title,
int count,
const char** labels,
const void** values,
const char** icons,
const int* flags,
PFN_ON_ITEM_SELECTED on_item_selected,
PFN_ON_ITEM_SELECTED on_item_deleted,
void* context,
const char* left_softkey_text,
SsdSoftKeyCallback left_softkey_callback,
int list_height,
int dialog_flags,
BOOL add_next_button)
{
static SsdListContext list_context;
SsdWidget list;
int list_flags = 0;
#if defined (OPENGL)
/*
* Borders are fast in OPENGL
*/
list_flags |= SSD_ALIGN_CENTER|SSD_CONTAINER_BORDER|SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE;
#endif // OPENGL
list_context.on_item_selected= on_item_selected;
list_context.on_item_deleted = on_item_deleted;
list_context.context = context;
list_context.left_softkey_callback = left_softkey_callback;
if ( !ssd_dialog_exists( SSD_GEN_LIST_DLG_NAME ) )
{
GenericList = ssd_dialog_new ( SSD_GEN_LIST_DLG_NAME, "", on_dialog_closed, SSD_CONTAINER_TITLE|dialog_flags);
list = ssd_list_new ("list", SSD_MAX_SIZE, SSD_MAX_SIZE, inputtype_none, 0, NULL);
ssd_widget_add (GenericList, list);
}
else{
GenericList->flags &= ~SSD_HEADER_BLACK;
GenericList->flags |= dialog_flags;
}
ssd_widget_set_offset(GenericList,0,0);
list = ssd_widget_get (GenericList, "list");
GenericList->set_value (GenericList->parent, title);
ssd_widget_set_context (GenericList, &list_context);
ssd_widget_reset_cache (list->parent);
ssd_widget_reset_position(GenericList);
ssd_list_resize ( list, list_height );
ssd_list_populate (list, count, labels, values,icons,flags, list_callback, del_callback, add_next_button);
ssd_widget_set_left_softkey_text(GenericList, left_softkey_text);
if (left_softkey_callback != NULL)
ssd_widget_set_left_softkey_callback(GenericList, list_left_softkey_callback);
ssd_dialog_activate (SSD_GEN_LIST_DLG_NAME, NULL);
ssd_dialog_draw();
}
void roadmap_groups_dialog (RoadMapCallback callback) {
int row_height = 60;
SsdWidget groupDlg;
SsdWidget list;
int flags = 0;
int i;
int count;
const char *active_name;
static char *labels[MAX_GROUPS] ;
static void *values[MAX_GROUPS] ;
static void *icons[MAX_GROUPS];
int num_following;
if (roadmap_screen_is_hd_screen()){
row_height = 80;
}
#ifdef OPENGL
flags |= SSD_ALIGN_CENTER|SSD_CONTAINER_BORDER|SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE;
#endif
groupDlg = ssd_dialog_new ( "groupDlg", roadmap_lang_get ("Groups"), NULL, SSD_CONTAINER_TITLE);
groupDlg->context = (void *)callback;
list = ssd_list_new ("list", SSD_MAX_SIZE, SSD_MAX_SIZE, inputtype_none, flags, NULL);
ssd_list_resize ( list, row_height );
active_name = roadmap_groups_get_active_group_name();
count = roadmap_groups_get_num_following();
num_following = roadmap_groups_get_num_following();
if (active_name[0] != 0){
values[0] = (void *)roadmap_groups_get_active_group_name();
icons[0] = (void *) roadmap_groups_get_active_group_icon();
labels[0] = (char *)active_name;
num_following -= 1;
}
else{
values[0] = "";
icons[0] = NULL;
labels[0] = (char *)roadmap_lang_get("No group");
}
for (i = 0; i< num_following; i++){
values[i+1] = (void *)roadmap_group_get_following_name(i);
icons[i+1] = (void *) roadmap_group_get_following_icon(i);
labels[i+1] = (char *) roadmap_group_get_following_name(i);
}
if (active_name[0] != 0){
values[count] = "";
icons[count] = NULL;
labels[count] = (char *)roadmap_lang_get("No group");
}
ssd_list_populate (list, count+1, (const char **)labels, (const void **)values, (const char **)icons, NULL, groups_callback, NULL, FALSE);
ssd_widget_add (groupDlg, list);
ssd_dialog_activate ("groupDlg", NULL);
ssd_dialog_draw ();
}
void ssd_generic_list_dialog_show(const char* title,
int count,
const char** labels,
const void** values,
PFN_ON_ITEM_SELECTED on_item_selected,
PFN_ON_ITEM_SELECTED on_item_deleted,
void* context,
int list_height )
{
static SsdListContext list_context;
SsdWidget list;
int flags = 0;
#if defined (OPENGL)
/*
* Borders are fast in OPENGL
*/
flags |= SSD_ALIGN_CENTER|SSD_CONTAINER_BORDER|SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE;
#endif // OPENGL
list_context.on_item_selected= on_item_selected;
list_context.on_item_deleted = on_item_deleted;
list_context.context = context;
list_context.left_softkey_callback = NULL;
if (!GenericList)
{
GenericList = ssd_dialog_new ( SSD_GEN_LIST_DLG_NAME, "", on_dialog_closed,
SSD_CONTAINER_TITLE);
ssd_dialog_add_vspace (GenericList, 5, 0);
list = ssd_list_new ("list", ssd_container_get_width(), SSD_MAX_SIZE, inputtype_none, flags, NULL);
ssd_widget_add (GenericList, list);
}
list = ssd_widget_get (GenericList, "list");
ssd_widget_set_offset(GenericList,0,0);
ssd_widget_set_left_softkey_text(GenericList, roadmap_lang_get("Exit_key"));
ssd_widget_set_left_softkey_callback(GenericList, NULL);
GenericList->set_value (GenericList->parent, title);
ssd_widget_set_context (GenericList, &list_context);
ssd_widget_reset_cache (list->parent);
ssd_widget_reset_position(GenericList);
ssd_list_resize ( list, list_height );
ssd_list_populate (list, count, labels, values, NULL, NULL, list_callback, del_callback, FALSE);
ssd_dialog_activate ( SSD_GEN_LIST_DLG_NAME, NULL );
ssd_dialog_draw();
}
/***********************************************************
* Name : ssd_progress_msg_dialog_set_text
*
* Purpose : change the text of the progress dialog
*
* Params : [in] dlg_text - the text to be displayed in message
* :
* :
* :
* Returns : void
*/
void ssd_progress_msg_dialog_set_text( const char* dlg_text )
{
if ( !gProgressMsgDlg )
{
// Create the dialog. Return in case of failure
if ( !( gProgressMsgDlg = ssd_progress_msg_dialog_new() ) )
return;
}
ssd_dialog_set_value( SSD_PROGRESS_MSG_TEXT_FLD, dlg_text );
ssd_dialog_draw();
}
int ssd_dialog_drag_motion (RoadMapGuiPoint *point) {
SsdDialog dialog = RoadMapDialogCurrent;
if (dialog == NULL)
return 0;
if (dialog->container->flags & SSD_DIALOG_FLOAT){
if (LastPointerPoint.x == -1)
return 0;
else
return 1;
}
if (dialog->scroll_container && dialog->scroll_container->drag_motion)
return (*dialog->scroll_container->drag_motion)(dialog->container, point);
else{
if ((dialog->scroll_container) && (dialog->scroll)){
int diff = abs(dialog->drag_last_motion.y - point->y);
if (diff > 5){
int goffsef;
LastPointerPoint.x = -1;
goffsef = (int)(1 * (point->y - dialog->drag_start_point.y ) + dialog->stop_offset);
if ((goffsef) > roadmap_canvas_height()/3){
dialog->scroll_counter = SCROLL_AFTER_END_COUNTER;
return 1;
}
else{
SsdSize size;
ssd_widget_get_size(dialog->scroll_container, &size, NULL);
if (size.height > roadmap_canvas_height()){
if ((dialog->scroll_container->position.y + size.height) < roadmap_canvas_height()*2/3){
dialog->scroll_counter = SCROLL_AFTER_END_COUNTER;
return 1;
}
}
}
dialog->drag_last_motion.y = point->y;
dialog->drag_last_motion.x = point->x;
ssd_widget_set_offset(dialog->scroll_container,0,goffsef);
ssd_dialog_draw();
}
return 1;
}
}
return 1;
}
void roadmap_messagebox (const char *title, const char *text) {
SsdWidget dialog = ssd_dialog_activate ("message_box", NULL);
title = roadmap_lang_get (title);
text = roadmap_lang_get (text);
if (!dialog) {
create_messagebox ();
dialog = ssd_dialog_activate ("message_box", NULL);
}
dialog->set_value (dialog, title);
ssd_widget_set_value (dialog, "text", text);
kill_messagebox_timer ();
ssd_dialog_draw ();
}
void ssd_confirm_dialog_custom (const char *title, const char *text, BOOL default_yes, ConfirmDialogCallback callback, void *context,const char *textYes, const char *textNo) {
SsdWidget dialog;
confirm_dialog_context *data =
(confirm_dialog_context *)calloc (1, sizeof(*data));
data->default_yes = default_yes;
dialog = ssd_dialog_activate ("confirm_dialog", NULL);
title = roadmap_lang_get (title);
text = roadmap_lang_get (text);
if (!dialog) {
create_confirm_dialog (default_yes,textYes,textNo);
dialog = ssd_dialog_activate ("confirm_dialog", NULL);
}
else{
#ifdef TOUCH_SCREEN
//set button text & softkeys
SsdWidget buttonYes;
SsdWidget buttonNo;
buttonYes = ssd_widget_get(dialog, roadmap_lang_get ("Yes")); // change the buttons to custom text
ssd_button_change_text(buttonYes, textYes);
buttonNo = ssd_widget_get(dialog, roadmap_lang_get ("No"));
ssd_button_change_text(buttonNo, textNo);
#else //Non touch
set_soft_keys(dialog, textYes, textNo); // change softkeys text to custom text
ssd_dialog_refresh_current_softkeys();
#endif
}
if (title[0] == 0){
ssd_widget_hide(ssd_widget_get(dialog, "title_bar"));
}
else{
ssd_widget_show(ssd_widget_get(dialog, "title_bar"));
}
data->callback = callback;
data->context = context;
dialog->set_value (dialog, title);
ssd_widget_set_value (dialog, "text", text);
dialog->context = data;
ssd_dialog_draw ();
}
/***********************************************************
* Name : ssd_progress_msg_dialog_show
*
* Purpose : Shows the dialog with the given name. Creates the new one if not exists
*
* Params : [in] dlg_text - the text to be displayed in message
* :
* :
* Returns : void
*/
void ssd_progress_msg_dialog_show( const char* dlg_text )
{
if ( !gProgressMsgDlg )
{
// Create the dialog. Return in case of failure
if ( !( gProgressMsgDlg = ssd_progress_msg_dialog_new() ) )
return;
}
#ifdef TOUCH_SCREEN
ssd_widget_show(ssd_widget_get(gProgressMsgDlg, "Hide Button" ));
#endif
ssd_dialog_activate( SSD_PROGRESS_MSG_DLG_NAME, NULL );
ssd_dialog_set_value( SSD_PROGRESS_MSG_TEXT_FLD, dlg_text );
ssd_dialog_draw();
}
int on_checkbox_selected (SsdWidget widget, const char *new_value){
SsdWidget container = widget->parent->parent;
const char *add_reminder = ssd_dialog_get_data("add_reminder");
if (!container)
return 0;
if (!strcmp( add_reminder, "no" )){
ssd_widget_hide(ssd_widget_get(container,"DescriptionEntry"));
ssd_widget_hide(ssd_widget_get(container,"Repeat"));
ssd_widget_hide(ssd_widget_get(container,"Distance"));
}
else{
ssd_widget_show(ssd_widget_get(container,"DescriptionEntry"));
ssd_widget_show(ssd_widget_get(container,"Repeat"));
ssd_widget_show(ssd_widget_get(container,"Distance"));
}
ssd_dialog_draw();
return 1;
}
static int roadmap_exclusive_mood_call_back (SsdWidget widget, const char *new_value, const void *value) {
RoadMapCallback cb = (RoadMapCallback)widget->parent->context;
int iMood = roadmap_mood_from_string( value);
if ( (iMood <= Mood_Gold) && (iMood >= Mood_Bronze) && (iMood - Mood_Bronze) > roadmap_mood_get_exclusive_moods() -1) {
ssd_dialog_set_focus(NULL);
ssd_dialog_draw();
return 0;
}
roadmap_analytics_log_event(ANALYTICS_EVENT_MOOD, ANALYTICS_EVENT_INFO_CHANGED_TO, value);
roadmap_mood_set(value);
ssd_dialog_hide ( "MoodDlg", dec_close );
if (cb)
(*cb)();
return 1;
}
static int fill_dialog(PluginLine *line, RoadMapPosition *pos,
int direction) {
const char *street_name = NULL;
const char *city_name = NULL;
int fraddl;
int toaddl;
int fraddr;
int toaddr;
int left;
int right;
char str[100];
if (line->plugin_id == EditorPluginID) {
#if 0
EditorStreetProperties properties;
if (editor_db_activate (line->fips) == -1) return -1;
editor_street_get_properties (line->line_id, &properties);
street_name = editor_street_get_street_name (&properties);
city_name = editor_street_get_street_city
(&properties, ED_STREET_LEFT_SIDE);
editor_street_get_street_range
(&properties, ED_STREET_LEFT_SIDE, &fraddl, &toaddl);
editor_street_get_street_range
(&properties, ED_STREET_RIGHT_SIDE, &fraddr, &toaddr);
#endif
} else {
RoadMapStreetProperties properties;
if (roadmap_locator_activate (line->fips) < 0) return -1;
roadmap_street_get_properties (line->line_id, &properties);
street_name = roadmap_street_get_street_name (&properties);
city_name = roadmap_street_get_street_city
(&properties, ROADMAP_STREET_LEFT_SIDE);
roadmap_street_get_street_range
(&properties, ROADMAP_STREET_LEFT_SIDE, &fraddl, &toaddl);
roadmap_street_get_street_range
(&properties, ROADMAP_STREET_RIGHT_SIDE, &fraddr, &toaddr);
}
if (!city_name) city_name = "";
get_estimated_range
(line, pos, direction, fraddl, toaddl, fraddr, toaddr, &left, &right);
#ifndef SSD
roadmap_dialog_set_data ("Update", STREET_PREFIX, street_name);
roadmap_dialog_set_data ("Update", CITY_PREFIX, city_name);
snprintf(str, sizeof(str), "%s:%d %s:%d",
roadmap_lang_get ("Left"), left,
roadmap_lang_get ("Right"), right);
roadmap_dialog_set_data ("Update", "Estimated", str);
roadmap_dialog_set_data ("Update", UPDATE_LEFT, "");
roadmap_dialog_set_data ("Update", UPDATE_RIGHT, "");
#else
ssd_dialog_set_value (STREET_PREFIX, street_name);
ssd_dialog_set_value (CITY_PREFIX, city_name);
sprintf(str, "%d", left);
ssd_dialog_set_value ("estimated_left", str);
sprintf(str, "%d", right);
ssd_dialog_set_value ("estimated_right", str);
ssd_dialog_set_value (UPDATE_LEFT, "");
ssd_dialog_set_value (UPDATE_RIGHT, "");
ssd_dialog_draw ();
#endif
return 0;
}
int ssd_dialog_drag_end (RoadMapGuiPoint *point) {
uint32_t time_diff, drag_diff, speed;
SsdDialog dialog = RoadMapDialogCurrent;
if (dialog == NULL)
return 0;
if (dialog->container->flags & SSD_DIALOG_FLOAT){
if (LastPointerPoint.x == -1)
return 0;
else
return 1;
}
dialog->drag_end_time_ms = roadmap_time_get_millis();
dialog->drag_end_motion.y = point->y;
dialog->drag_end_motion.x = point->x;
time_diff = dialog->drag_end_time_ms - dialog->drag_start_time_ms;
drag_diff = abs(dialog->drag_end_motion.y - dialog->drag_start_point.y);
if (time_diff > 0)
speed = (int)(drag_diff*10)/time_diff;
#if 0
if ((dialog->scroll_counter < SCROLL_AFTER_END_COUNTER) && (drag_diff > 40)){
dialog->drag_speed = speed;
roadmap_main_set_periodic (30, keep_dragging);
dialog->time_active = TRUE;
return 1;
}
#endif
if (dialog->scroll_container && dialog->scroll_container->drag_end)
return (*dialog->scroll_container->drag_end)(dialog->container, point);
else if ((dialog->scroll_container) && (dialog->scroll)){
SsdWidget title;
SsdSize size, size2;
int height;
int goffsef = (int)(1 * (point->y - dialog->drag_start_point.y ) + dialog->stop_offset);
title = ssd_widget_get (RoadMapDialogCurrent->container, "title_bar");
height = roadmap_canvas_height() - title->cached_size.height - 4;
ssd_widget_reset_cache(dialog->scroll_container);
ssd_widget_get_size(dialog->scroll_container, &size, NULL);
if (size.height == roadmap_canvas_height() +1){
ssd_widget_reset_cache(dialog->scroll_container);
size2.width = SSD_MIN_SIZE;
size2.height = SSD_MIN_SIZE;
ssd_widget_get_size(dialog->scroll_container, &size, &size2);
}
if (size.height < height)
goffsef = 0;
else if ((goffsef + size.height) > height) {
if (goffsef + dialog->scroll_container->position.y > dialog->container->children->cached_size.height)
goffsef = 0 ;
}
else if ((goffsef + dialog->scroll_container->position.y + size.height ) < roadmap_canvas_height()){
goffsef = height - size.height -2 ;
}
ssd_widget_set_offset(dialog->scroll_container,0,goffsef);
dialog->stop_offset = goffsef;
ssd_dialog_draw();
}
return 1;
}
/////////////////////////////////////////////////////////////////////
// Twitter
/////////////////////////////////////////////////////////////////////
void welcome_wizard_twitter_dialog(void){
SsdWidget dialog;
SsdWidget group, box, label, label_cnt;
SsdWidget group_title, text;
SsdWidget bitmap, button;
const char* icons[3];
dialog = ssd_dialog_new( WELCOME_WIZ_DLG_TWITTER_NAME, roadmap_lang_get( WELCOME_WIZ_DLG_TWITTER_TITLE ), NULL, SSD_CONTAINER_TITLE|SSD_DIALOG_NO_SCROLL );
// Space before white container
ssd_dialog_add_vspace( dialog, ADJ_SCALE( 3 ), 0 );
box = ssd_container_new ( "Sign Up Box", NULL, SSD_MAX_SIZE,
SSD_MIN_SIZE, SSD_END_ROW | SSD_ALIGN_CENTER | SSD_CONTAINER_BORDER | SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE|SSD_WIDGET_SPACE );
// Space inside white container
ssd_dialog_add_vspace( box, ADJ_SCALE( 1 ), 0 );
// Twitter title
group = ssd_container_new ( "Twitter title group", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_END_ROW );
ssd_dialog_add_hspace( group, ADJ_SCALE( WELCOME_WIZ_DLG_HOFFSET ), SSD_ALIGN_VCENTER );
bitmap = ssd_bitmap_new( "Twitter logo","welcome_twitter", SSD_ALIGN_VCENTER);
ssd_widget_add( group, bitmap );
ssd_dialog_add_hspace( group, ADJ_SCALE( 15 ), SSD_ALIGN_VCENTER );
group_title = ssd_text_new( "Twitter", roadmap_lang_get( "Twitter" ), 15, SSD_TEXT_LABEL );
ssd_text_set_color( group_title, "#202020" );
ssd_widget_add( group, group_title );
ssd_widget_add( box, group );
// Tweeter explanation text
ssd_dialog_add_vspace( box, ADJ_SCALE( 16 ), 0 );
group = ssd_container_new ( "Twitter text", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_END_ROW );
ssd_dialog_add_hspace( group, ADJ_SCALE( 5 ), SSD_ALIGN_VCENTER );
label = ssd_text_new( "Label", roadmap_lang_get ( "Tweet your road reports" ), WELCOME_WIZ_DLG_LBL_FONT,
SSD_TEXT_LABEL | SSD_ALIGN_VCENTER | SSD_TEXT_NORMAL_FONT );
ssd_text_set_color( label, WELCOME_WIZ_DLG_LBL_COLOR );
ssd_widget_add( group, label );
ssd_widget_add( box, group );
// Username
ssd_dialog_add_vspace( box, ADJ_SCALE( 14 ), 0 );
group = get_welcome_wiz_entry_group( "Username", "TwitterUserName", "Username" );
ssd_widget_add( box, group );
// Password
ssd_dialog_add_vspace( box, ADJ_SCALE( 10 ), 0 );
group = get_welcome_wiz_entry_group( "Password", "TwitterPassword", "Password" );
ssd_widget_add( box, group );
// Tweet checkout waze
ssd_dialog_add_vspace( box, ADJ_SCALE( 4 ), 0 );
group = ssd_container_new ("Tweet checkout group", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_END_ROW | SSD_WS_TABSTOP );
ssd_widget_set_color ( group, NULL, NULL );
ssd_dialog_add_hspace( group, ADJ_SCALE( WELCOME_WIZ_DLG_HOFFSET ), 0 );
ssd_widget_add( group, ssd_checkbox_new ( WELCOME_WIZ_DLG_TWITTER_SET_SIGNUP, TRUE, 0, NULL, NULL, NULL, CHECKBOX_STYLE_DEFAULT ) );
label_cnt = ssd_container_new ( "Label container", NULL, SSD_MIN_SIZE, SSD_MIN_SIZE, SSD_ALIGN_VCENTER );
ssd_widget_set_color ( label_cnt, NULL, NULL );
ssd_dialog_add_hspace( label_cnt, ADJ_SCALE( 10 ), 0 );
label = ssd_text_new ("Label", roadmap_lang_get ( "Tweet that I'm checking-out waze"), WELCOME_WIZ_DLG_LBL_FONT,
SSD_TEXT_NORMAL_FONT|SSD_TEXT_LABEL|SSD_ALIGN_VCENTER );
ssd_text_set_color( label, WELCOME_WIZ_DLG_LBL_COLOR );
ssd_widget_add ( label_cnt, label );
ssd_widget_add ( group, label_cnt );
ssd_widget_add ( box, group);
ssd_dialog_add_vspace( box, ADJ_SCALE( 10 ), 0 );
#ifdef TOUCH_SCREEN
icons[0] = "welcome_btn";
icons[1] = "welcome_btn_h";
icons[2] = NULL;
// Preload image to get dimensions
group = ssd_container_new ( "Buttons group", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_ALIGN_CENTER | SSD_END_ROW );
button = ssd_button_label_custom( "Skip", roadmap_lang_get ("Skip"), SSD_ALIGN_CENTER | SSD_ALIGN_VCENTER, twitter_button_callback,
icons, 2, "#FFFFFF", "#FFFFFF",14 );
text = ssd_widget_get( button, "label" );
text->flags |= SSD_TEXT_NORMAL_FONT;
ssd_text_set_font_size( text, 15 );
ssd_widget_add ( group, button );
ssd_dialog_add_hspace( group, ADJ_SCALE( 10 ), SSD_ALIGN_CENTER | SSD_ALIGN_VCENTER );
// Skip button
button = ssd_button_label_custom( "Next", roadmap_lang_get ("Next"), SSD_ALIGN_CENTER | SSD_ALIGN_VCENTER, twitter_button_callback,
icons, 2, "#FFFFFF", "#FFFFFF",14 );
text = ssd_widget_get( button, "label" );
text->flags |= SSD_TEXT_NORMAL_FONT;
ssd_text_set_font_size( text, 15 );
ssd_widget_add ( group, button );
ssd_widget_add ( box, group );
ssd_dialog_add_vspace( box, ADJ_SCALE( 6 ), 0 );
#else
ssd_widget_set_left_softkey_text ( dialog, roadmap_lang_get("Next"));
ssd_widget_set_left_softkey_callback ( dialog, on_softkey_next_twitter);
#endif
ssd_widget_add ( dialog, box );
ssd_dialog_activate( WELCOME_WIZ_DLG_TWITTER_NAME, NULL );
ssd_dialog_draw();
}
/////////////////////////////////////////////////////////////////////
// Ping
/////////////////////////////////////////////////////////////////////
void welcome_wizard_ping_dialog(void){
SsdWidget dialog;
SsdWidget group, box, label, label_cnt;
SsdWidget group_title, text;
SsdWidget button;
const char* icons[3];
char str[512];
dialog = ssd_dialog_new( WELCOME_WIZ_DLG_PING_NAME, roadmap_lang_get( WELCOME_WIZ_DLG_PING_TITLE ), NULL,
SSD_CONTAINER_TITLE|SSD_DIALOG_NO_SCROLL );
box = ssd_container_new ( "Ping Box", NULL, SSD_MAX_SIZE,
SSD_MIN_SIZE, SSD_END_ROW | SSD_ALIGN_CENTER | SSD_CONTAINER_BORDER | SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE|SSD_WIDGET_SPACE );
// Space inside white container
ssd_dialog_add_vspace( box, ADJ_SCALE( 1 ), 0 );
// Ping title
group = ssd_container_new ( "Ping title group", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_END_ROW );
ssd_dialog_add_hspace( group, ADJ_SCALE( WELCOME_WIZ_DLG_PING_HOFFSET ), SSD_ALIGN_VCENTER );
group_title = ssd_text_new( "Ping", roadmap_lang_get( "Ping" ), 15, SSD_TEXT_LABEL );
ssd_text_set_color( group_title, "#202020" );
ssd_widget_add( group, group_title );
ssd_widget_add( box, group );
// Ping explanation text
ssd_dialog_add_vspace( box, ADJ_SCALE( 16 ), 0 );
snprintf( str, sizeof(str), "%s\n%s",
roadmap_lang_get("Allow wazers to ping you."),
roadmap_lang_get("It's useful, fun and you can always turn it off."));
group = ssd_container_new ( "Ping text", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_END_ROW );
ssd_dialog_add_hspace( group, ADJ_SCALE( WELCOME_WIZ_DLG_PING_HOFFSET ), SSD_ALIGN_VCENTER );
label_cnt = ssd_container_new ( "Label container", NULL, WELCOME_WIZ_DLG_PING_TEXT_WIDTH, SSD_MIN_SIZE, SSD_END_ROW );
label = ssd_text_new( "Label", str, WELCOME_WIZ_DLG_LBL_FONT,
SSD_TEXT_LABEL | SSD_TEXT_NORMAL_FONT );
ssd_text_set_color( label, WELCOME_WIZ_DLG_LBL_COLOR );
ssd_widget_add( label_cnt, label );
ssd_widget_add( group, label_cnt );
ssd_widget_add( box, group );
ssd_dialog_add_vspace( box, ADJ_SCALE( 34 ), 0 );
// Ping checkbox
group = ssd_container_new ("Ping agree group", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_END_ROW | SSD_WS_TABSTOP );
ssd_widget_set_color ( group, NULL, NULL );
ssd_dialog_add_hspace( group, ADJ_SCALE( WELCOME_WIZ_DLG_PING_HOFFSET ), 0 );
ssd_widget_add( group, ssd_checkbox_new ( WELCOME_WIZ_DLG_PING_AGREE, TRUE, 0, NULL, NULL, NULL, CHECKBOX_STYLE_DEFAULT ) );
label_cnt = ssd_container_new ( "Label container", NULL, SSD_MIN_SIZE, SSD_MIN_SIZE, SSD_ALIGN_VCENTER );
ssd_widget_set_color ( label_cnt, NULL, NULL );
ssd_dialog_add_hspace( label_cnt, ADJ_SCALE( 10 ), 0 );
label = ssd_text_new ("Label", roadmap_lang_get( "I agree to be pinged" ), WELCOME_WIZ_DLG_LBL_FONT,
SSD_TEXT_NORMAL_FONT|SSD_TEXT_LABEL|SSD_ALIGN_VCENTER );
ssd_text_set_color( label, WELCOME_WIZ_DLG_LBL_COLOR );
ssd_widget_add ( label_cnt, label );
ssd_widget_add ( group, label_cnt );
ssd_widget_add ( box, group);
#ifdef TOUCH_SCREEN
// Next button
ssd_dialog_add_vspace( box, ADJ_SCALE( 8 ), 0 );
icons[0] = "welcome_btn";
icons[1] = "welcome_btn_h";
icons[2] = NULL;
group = ssd_container_new ( "Buttons group", NULL, ssd_container_get_width()*0.9, SSD_MIN_SIZE, SSD_ALIGN_CENTER | SSD_END_ROW );
button = ssd_button_label_custom( "Next", roadmap_lang_get ("Next"), SSD_ALIGN_RIGHT | SSD_ALIGN_VCENTER, ping_button_callback,
icons, 2, "#FFFFFF", "#FFFFFF",14 );
text = ssd_widget_get( button, "label" );
text->flags |= SSD_TEXT_NORMAL_FONT;
ssd_text_set_font_size( text, 15 );
ssd_widget_add ( group, button );
ssd_widget_add ( box, group );
#else
ssd_widget_set_left_softkey_text ( dialog, roadmap_lang_get("Next"));
ssd_widget_set_left_softkey_callback ( dialog, on_softkey_next_ping );
#endif
ssd_dialog_add_vspace( box, ADJ_SCALE( 12 ), 0 );
ssd_widget_add ( dialog, box );
ssd_dialog_activate( WELCOME_WIZ_DLG_PING_NAME, NULL );
ssd_dialog_draw();
}
/////////////////////////////////////////////////////////////////////
// Way to go dialog
/////////////////////////////////////////////////////////////////////
void welcome_wizard_way_to_go( void )
{
SsdWidget dialog;
SsdWidget group, box;
SsdWidget group_title, text;
SsdWidget button, separator, way_to_go_bmp;
const char* explanation_text;
const char* icons[3];
#define WAY_TO_GO_TEXT_1_WIDTH 225
#define WAY_TO_GO_TEXT_2_WIDTH 290
dialog = ssd_dialog_new( WELCOME_WIZ_DLG_WAY_TO_GO_NAME, roadmap_lang_get( WELCOME_WIZ_DLG_WAY_TO_GO_TITLE ), NULL,
SSD_CONTAINER_TITLE );
ssd_dialog_add_vspace( dialog, ADJ_SCALE( 5 ), 0 );
box = ssd_container_new ( "Way to go box", NULL, ssd_container_get_width(),
SSD_MIN_SIZE, SSD_END_ROW | SSD_ALIGN_CENTER | SSD_CONTAINER_BORDER | SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE|SSD_WIDGET_SPACE );
// Space inside white container
ssd_dialog_add_vspace( box, ADJ_SCALE( 12 ), 0 );
// Title
group = ssd_container_new ( "Way to go title group", NULL, SSD_MAX_SIZE, SSD_MIN_SIZE, SSD_END_ROW );
ssd_dialog_add_hspace( group, ADJ_SCALE( WELCOME_WIZ_DLG_WAY_TO_GO_HOFFSET ), SSD_ALIGN_VCENTER );
group_title = ssd_text_new( "Way to go title text", roadmap_lang_get( "Way to go!" ), 25, SSD_TEXT_LABEL );
ssd_text_set_color( group_title, WELCOME_WIZ_DLG_WAY_TO_GO_TITLE_COLOR );
ssd_widget_add( group, group_title );
ssd_widget_add( box, group );
ssd_dialog_add_vspace( box, ADJ_SCALE( 7 ), 0 );
group = ssd_container_new ( "Way to go separator group", NULL, ssd_container_get_width()*0.9, SSD_MIN_SIZE, SSD_ALIGN_CENTER|SSD_END_ROW );
separator = ssd_separator_new( "Separator", SSD_ALIGN_CENTER|SSD_WIDGET_SPACE );
ssd_widget_add( group, separator );
ssd_widget_add( box, group );
/*
* Logo bitmap
*/
ssd_dialog_add_vspace( box, ADJ_SCALE( 10 ), 0 );
way_to_go_bmp = ssd_bitmap_new( "Way to go bitmap", "way_to_go_wazer", SSD_ALIGN_CENTER|SSD_END_ROW );
ssd_widget_add( box, way_to_go_bmp );
// Explanation text - I
ssd_dialog_add_vspace( box, ADJ_SCALE( 12 ), 0 );
group = ssd_container_new ( "Explanation text I", NULL, ADJ_SCALE( WAY_TO_GO_TEXT_1_WIDTH ), SSD_MIN_SIZE, SSD_END_ROW|SSD_ALIGN_CENTER );
ssd_widget_set_color( group, NULL, NULL );
if ( Realtime_is_random_user() )
explanation_text = "Your temporary account has been created!";
else
explanation_text = "Your account has been created!";
text = ssd_text_new( "Way to go explanation text", roadmap_lang_get( explanation_text ), 16, SSD_TEXT_LABEL|SSD_ALIGN_CENTER );
ssd_text_set_color( text, WELCOME_WIZ_DLG_WAY_TO_GO_EXPL_COLOR );
ssd_widget_add( group, text );
ssd_widget_add( box, group );
// Explanation text - II
ssd_dialog_add_vspace( box, ADJ_SCALE( 20 ), 0 );
group = ssd_container_new ( "Explanation text II", NULL, ADJ_SCALE( WAY_TO_GO_TEXT_2_WIDTH ), SSD_MIN_SIZE, SSD_END_ROW|SSD_ALIGN_CENTER );
ssd_widget_set_color( group, NULL, NULL );
explanation_text = "Take a moment to click through the following screens to familiarize yourself with waze...";
text = ssd_text_new( "Way to go explanation text", roadmap_lang_get( explanation_text ), 15, SSD_TEXT_LABEL|SSD_ALIGN_CENTER );
ssd_text_set_color( text, WELCOME_WIZ_DLG_WAY_TO_GO_EXPL_COLOR );
ssd_widget_add( group, text );
ssd_widget_add( box, group );
ssd_dialog_add_vspace( box, ADJ_SCALE( 12 ), 0 );
#ifdef TOUCH_SCREEN
icons[0] = "welcome_btn";
icons[1] = "welcome_btn_h";
icons[2] = NULL;
button = ssd_button_label_custom( "Go", roadmap_lang_get ( "Go" ), SSD_ALIGN_CENTER, way_to_go_button_callback, icons, 2, "#FFFFFF", "#FFFFFF", 14 );
// text = ssd_widget_get( button, "label" );
// text->flags |= SSD_TEXT_NORMAL_FONT;
// ssd_text_set_font_size( text, 15 );
ssd_widget_add ( box, button );
#else
ssd_widget_set_left_softkey_text ( dialog, roadmap_lang_get("Go"));
ssd_widget_set_left_softkey_callback ( dialog, on_softkey_left_way_to_go );
#endif
ssd_dialog_add_vspace( box, ADJ_SCALE( 16 ), 0 );
ssd_widget_add ( dialog, box );
ssd_dialog_activate( WELCOME_WIZ_DLG_WAY_TO_GO_NAME, NULL );
ssd_dialog_draw();
}
void roadmap_mood_dialog (RoadMapCallback callback) {
char **files;
const char *cursor;
char **cursor2;
char *directory = NULL;
int count = 0;
SsdWidget moodDlg;
SsdWidget list;
SsdWidget exclusive_list;
SsdWidget baby_list;
SsdWidget text;
int i;
BOOL only_baby_mood = Realtime_IsNewbie();
int row_height = ssd_container_get_row_height();
SsdListCallback exclusive_callback = NULL;
SsdListCallback regular_mood_callback = roadmap_mood_call_back;
int flags = 0;
int width = SSD_MAX_SIZE;
static roadmap_mood_list_dialog context = {"roadmap_mood", NULL};
static char *labels[MAX_MOOD_ENTRIES] ;
static void *values[MAX_MOOD_ENTRIES] ;
static void *icons[MAX_MOOD_ENTRIES];
static char *exclusive_labels[MAX_EXCLUSIVE_ICONS] ;
static void *exclusive_values[MAX_EXCLUSIVE_ICONS] ;
static void *exclusive_icons[MAX_EXCLUSIVE_ICONS];
static char *baby_labels[1] ;
static void *baby_values[1] ;
static void *baby_icons[1];
flags |= SSD_ALIGN_CENTER|SSD_CONTAINER_BORDER|SSD_CONTAINER_FLAGS;
width = ssd_container_get_width();
moodDlg = ssd_dialog_new ( "MoodDlg", roadmap_lang_get ("Select your mood"), NULL, SSD_CONTAINER_TITLE);
moodDlg->context = (void *)callback;
exclusive_list = ssd_list_new ("list", width, SSD_MAX_SIZE, inputtype_none, flags, NULL);
ssd_list_resize ( exclusive_list, row_height );
baby_list = ssd_list_new ("baby_list", width, SSD_MAX_SIZE, inputtype_none, flags, NULL);
ssd_list_resize ( baby_list, row_height );
exclusive_labels[0] = (char *)roadmap_lang_get("wazer_gold");
exclusive_values[0] = "wazer_gold";
exclusive_icons[0] = "wazer_gold";
exclusive_labels[1] = (char *)roadmap_lang_get("wazer_silver");
exclusive_values[1] = "wazer_silver";
exclusive_icons[1] = "wazer_silver";
exclusive_labels[2] = (char *)roadmap_lang_get("wazer_bronze");
exclusive_values[2] = "wazer_bronze";
exclusive_icons[2] = "wazer_bronze";
if (roadmap_mood_get_exclusive_moods() > 0){
exclusive_callback = roadmap_exclusive_mood_call_back;
}
ssd_list_populate (exclusive_list, 3, (const char **)exclusive_labels, (const void **)exclusive_values, (const char **)exclusive_icons, NULL, exclusive_callback, NULL, FALSE);
if (only_baby_mood){
char msg[150];
baby_labels[0] = (char *)roadmap_lang_get("Baby");
baby_values[0] = "wazer_baby";
baby_icons[0] = "wazer_baby";
ssd_list_populate (baby_list, 1, (const char **)baby_labels, (const void **)baby_values, (const char **)baby_icons, NULL, NULL, NULL, FALSE);
ssd_dialog_add_hspace(moodDlg, 20, 0);
text = ssd_text_new ("Baby Mood Txt", roadmap_lang_get("Waze newbie"), SSD_HEADER_TEXT_SIZE, SSD_TEXT_NORMAL_FONT | SSD_END_ROW);
ssd_widget_add(moodDlg, text);
ssd_dialog_add_hspace(moodDlg, 20, 0);
snprintf(msg, sizeof(msg), roadmap_lang_get("(Gotta drive %d+ %s to access other moods)"), roadmap_mood_get_number_of_newbie_miles(), roadmap_lang_get(roadmap_math_trip_unit()));
text = ssd_text_new ("Gold Mood Txt", msg, 12, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
ssd_widget_add(moodDlg, text);
ssd_widget_add (moodDlg, baby_list);
}
ssd_dialog_add_vspace(moodDlg, ADJ_SCALE(5),0);
ssd_dialog_add_hspace(moodDlg, 20, 0);
text = ssd_text_new ("Gold Mood Txt", roadmap_lang_get("Exclusive moods"), SSD_HEADER_TEXT_SIZE, SSD_TEXT_NORMAL_FONT | SSD_END_ROW);
ssd_widget_add(moodDlg, text);
ssd_dialog_add_hspace(moodDlg, 20, 0);
text = ssd_text_new ("Gold Mood Txt", roadmap_lang_get("(Available only to top weekly scoring wazers)"), SSD_FOOTER_TEXT_SIZE, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
ssd_widget_add(moodDlg, text);
ssd_dialog_add_vspace(moodDlg, ADJ_SCALE(3),0);
ssd_widget_add (moodDlg, exclusive_list);
for (i = 0; i < (3 - roadmap_mood_get_exclusive_moods()); i++){
SsdWidget row = ssd_list_get_row(exclusive_list, i);
if (row){
SsdWidget label = ssd_widget_get(row,"label");
if (label)
ssd_text_set_color(label,"#999999");
}
}
list = ssd_list_new ("list", width, SSD_MAX_SIZE, inputtype_none, flags, NULL);
exclusive_list->key_pressed = NULL;
ssd_dialog_add_vspace(moodDlg, ADJ_SCALE(10), 0);
ssd_dialog_add_hspace(moodDlg, 20, 0);
text = ssd_text_new ("Gold Mood Txt", roadmap_lang_get("Everyday moods"), SSD_HEADER_TEXT_SIZE, SSD_TEXT_NORMAL_FONT | SSD_END_ROW);
ssd_widget_add(moodDlg, text);
ssd_dialog_add_hspace(moodDlg, 20, 0);
text = ssd_text_new ("Gold Mood Txt", roadmap_lang_get("(Available to all)"), SSD_FOOTER_TEXT_SIZE, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
ssd_widget_add(moodDlg, text);
ssd_dialog_add_vspace(moodDlg, ADJ_SCALE(3),0);
ssd_widget_add (moodDlg, list);
ssd_list_resize ( list, row_height );
context.callback = callback;
for (cursor = roadmap_path_first ("skin");
cursor != NULL;
cursor = roadmap_path_next ("skin", cursor)) {
directory = roadmap_path_join (cursor, "moods");
files = roadmap_path_list (directory, ".png");
if ( *files == NULL )
{
files = roadmap_path_list (directory, NULL);
}
for (cursor2 = files; *cursor2 != NULL; ++cursor2) {
labels[count] = (char *)(strtok(*cursor2,"."));
count++;
}
}
qsort((void *) &labels[0], count, sizeof(void *), cstring_cmp);
for (i = 0; i< count; i++){
values[i] = labels[i];
icons[i] = roadmap_path_join("moods", labels[i]);
labels[i] = (char *)roadmap_lang_get(labels[i]);
}
if (only_baby_mood){
regular_mood_callback = NULL;
}
free(directory);
ssd_list_populate (list, count, (const char **)labels, (const void **)values, (const char **)icons, NULL, regular_mood_callback, NULL, FALSE);
if (only_baby_mood){
for (i = 0; i< count; i++){
SsdWidget row = ssd_list_get_row(list, i);
if (row){
SsdWidget label = ssd_widget_get(row,"label");
if (label)
ssd_text_set_color(label,"#999999");
}
}
}
// else{
// SsdWidget row = ssd_list_get_row(baby_list,0 );
// if (row){
// SsdWidget label = ssd_widget_get(row,"label");
// if (label)
// ssd_text_set_color(label,"#999999");
// }
// }
exclusive_list->key_pressed = NULL;
ssd_dialog_activate ("MoodDlg", NULL);
ssd_dialog_draw ();
}
void ssd_dialog_hide (const char *name, int exit_code) {
SsdDialog prev = NULL;
SsdDialog dialog = RoadMapDialogCurrent;
if (dialog == NULL)
return;
dialog = RoadMapDialogCurrent; //might have changes
while (dialog && strcmp(dialog->name, name)) {
prev = dialog;
dialog = dialog->activated_prev;
}
if (!dialog) {
return;
}
if (dialog->on_dialog_closed) {
dialog->on_dialog_closed( exit_code, dialog->context);
}
if (prev == NULL) {
if (RoadMapDialogCurrent)
RoadMapDialogCurrent = RoadMapDialogCurrent->activated_prev;
} else {
prev->activated_prev = dialog->activated_prev;
}
if (RoadMapDialogCurrent) {
ssd_dialog_disable_key ();
// if (RoadMapDialogCurrent->in_focus)
// ssd_widget_loose_focus(RoadMapDialogCurrent->in_focus);
} else {
roadmap_pointer_unregister_pressed (ssd_dialog_pressed);
roadmap_pointer_unregister_released (ssd_dialog_released);
roadmap_pointer_unregister_short_click (ssd_dialog_short_click);
roadmap_pointer_unregister_long_click (ssd_dialog_long_click);
roadmap_keyboard_unregister_from_event__key_pressed(OnKeyPressed);
roadmap_pointer_unregister_drag_start
(&ssd_dialog_drag_start);
roadmap_pointer_unregister_drag_end
(&ssd_dialog_drag_end);
roadmap_pointer_unregister_drag_motion
(&ssd_dialog_drag_motion);
}
hide_softkeys(dialog);
ssd_dialog_handle_native_kb( RoadMapDialogCurrent );
if (RoadMapScreenFrozen) {
dialog = RoadMapDialogCurrent;
while (dialog) {
if ( !(dialog->container->flags &
(SSD_DIALOG_FLOAT|SSD_DIALOG_TRANSPARENT))) {
ssd_dialog_draw ();
return;
}
dialog = dialog->activated_prev;
}
}
roadmap_input_type_set_mode( inputtype_numeric );
RoadMapScreenFrozen = 0;
roadmap_start_screen_refresh (1);
}
void editor_segments_properties (SelectedLine *lines, int lines_count) {
char str[100];
int total_length = 0;
int total_time = 0;
int i;
DialogSelectedLines *selected_lines = malloc (sizeof(*selected_lines));
selected_lines->lines = lines;
selected_lines->count = lines_count;
activate_dialog("Segment Properties", selected_lines);
editor_segments_fill_dialog (lines, lines_count);
/* Collect info data */
for (i=0; i<selected_lines->count; i++) {
int line_length;
int time;
SelectedLine *line = &selected_lines->lines[i];
if (line->line.plugin_id == EditorPluginID) {
line_length = editor_line_length (line->line.line_id);
time = editor_line_get_cross_time (line->line.line_id, 1);
} else {
LineRouteTime from_cross_time;
LineRouteTime to_cross_time;
roadmap_square_set_current (line->line.square);
line_length = roadmap_line_length (line->line.line_id);
if (roadmap_line_speed_get_cross_times
(line->line.line_id, &from_cross_time, &to_cross_time) == -1) {
time = -1; //TODO get real speed
} else {
time = from_cross_time;
}
}
if (time > 0) {
total_time += time;
} else {
if ((total_time == 0) || (total_length == 0)) {
total_time += (int)(1.0 *line_length / 10);
} else {
total_time +=
(int)(1.0 * line_length / (total_length/total_time)) + 1;
}
}
total_length += line_length;
}
#ifdef SSD
if (selected_lines->lines[0].line.plugin_id == ROADMAP_PLUGIN_ID) {
int line = selected_lines->lines[0].line.line_id;
int avg_speed = roadmap_line_speed_get_avg_speed (line, 0);
int cur_speed = roadmap_line_speed_get_speed (line, 0);
snprintf (str, sizeof(str), " : %d (%d)",
roadmap_math_to_speed_unit(avg_speed), roadmap_math_to_speed_unit(cur_speed));
ssd_dialog_set_value ("Speed", str);
} else {
ssd_dialog_set_value ("Speed", "");
}
#endif
snprintf (str, sizeof(str), " : %d %s",
roadmap_math_distance_to_current(total_length), roadmap_lang_get(roadmap_math_distance_unit()));
#ifdef SSD
ssd_dialog_set_value ("Length", str);
#else
roadmap_dialog_set_data ("Info", "Length", str);
#endif
snprintf (str, sizeof(str), " : %d %s",
total_time, roadmap_lang_get("seconds"));
#ifdef SSD
ssd_dialog_set_value ("Time", str);
ssd_dialog_draw ();
#else
roadmap_dialog_set_data ("Info", "Time", str);
#endif
}
