void roadmap_address_search_dialog (const char *city,
RoadMapAddressSearchCB callback,
void *data) {
const char *title;
RoadMapAddressSearch *context =
(RoadMapAddressSearch *) malloc (sizeof(*context));
context->callback = callback;
context->data = data;
context->city = city;
context->prefix = NULL;
if (!context->city) {
title = roadmap_lang_get ("City");
} else {
title = roadmap_lang_get ("Street");
}
ssd_show_keyboard_dialog( title,
NULL,
keyboard_callback,
context);
}
void update_alert(){
SsdWidget text, bitmap;
char TextStr[200];
const char * iconName;
const char *alert_text;
int alertId = roadmap_alerter_get_active_alert_id();
roadmap_square_set_current(the_active_alert.square);
text = ssd_widget_get(dialog, "Alert Title");
alert_text = (*(RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_string)) (alertId) ;
if (!alert_text)
return;
sprintf(TextStr, "%s",roadmap_lang_get(alert_text));
ssd_text_set_text(text, TextStr);
text = ssd_widget_get(dialog, "Distance");
sprintf(TextStr,"%s: %d %s", roadmap_lang_get("In"), the_active_alert.distance_to_alert, roadmap_lang_get(roadmap_math_distance_unit()));
ssd_text_set_text(text, TextStr);
bitmap = ssd_widget_get(dialog, "alert_Icon");
if (the_active_alert.alert_type == ALERT){
iconName = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_alert_icon)) (alertId);
}
else {
iconName = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_warning_icon)) (alertId);
}
ssd_bitmap_update(bitmap, iconName);
}
void roadmap_sound_initialize ()
{
int curLvl;
char sound_dir[MAX_SOUND_NAME];
// Initialize the volume labels for GUI
SND_VOLUME_LVLS_LABELS[0] = roadmap_lang_get( "Silent" );
SND_VOLUME_LVLS_LABELS[1] = roadmap_lang_get( "Low" );
SND_VOLUME_LVLS_LABELS[2] = roadmap_lang_get( "Medium" );
SND_VOLUME_LVLS_LABELS[3] = roadmap_lang_get( "High" );
// Set current volume from the configuration
roadmap_config_declare("user", &RoadMapConfigVolControl, SND_DEFAULT_VOLUME_LVL, NULL );
curLvl = roadmap_config_get_integer( &RoadMapConfigVolControl );
// FreeMapNativeManager_SetVolume( curLvl, SND_VOLUME_LVLS[0], SND_VOLUME_LVLS[SND_VOLUME_LVLS_COUNT-1] );
// Preload the sound resources
snprintf( sound_dir, sizeof( sound_dir ), "%s//%s//%s",
roadmap_path_downloads(), "sound", roadmap_prompts_get_name() );
FreeMapNativeSoundManager_LoadSoundData( sound_dir );
sgInitialized = TRUE;
// Log the operation
roadmap_log( ROADMAP_DEBUG, "Current volume initialized to level : %d.", curLvl );
}
static void set_softkey(void){
ssd_widget_set_left_softkey_callback(dialog->parent, report_irrelevant);
ssd_widget_set_left_softkey_text(dialog->parent, roadmap_lang_get("Not there"));
ssd_widget_set_right_softkey_text(dialog->parent, roadmap_lang_get("Hide"));
ssd_widget_set_right_softkey_callback(dialog->parent, hide);
}
void roadmap_foursquare_login_dialog(void) {
const char *pVal;
if (!ssd_dialog_activate(FOURSQUARE_LOGIN_DIALOG_NAME, NULL)) {
create_login_dialog();
ssd_dialog_activate(FOURSQUARE_LOGIN_DIALOG_NAME, NULL);
}
if (roadmap_foursquare_logged_in())
ssd_dialog_set_value("Login Status Label", roadmap_lang_get("Status: logged in"));
else
ssd_dialog_set_value("Login Status Label", roadmap_lang_get("Status: not logged in"));
ssd_dialog_set_value("FoursquareUserName", roadmap_foursquare_get_username());
ssd_dialog_set_value("FoursquarePassword", roadmap_foursquare_get_password());
if (roadmap_foursquare_is_tweet_login_enabled())
pVal = yesno[0];
else
pVal = yesno[1];
ssd_dialog_set_data("FoursquareSendLogin", (void *) pVal);
if (roadmap_foursquare_is_tweet_badge_enabled())
pVal = yesno[0];
else
pVal = yesno[1];
ssd_dialog_set_data("FoursquareSendBadgeUnlock", (void *) pVal);
}
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;
}
/**
* Generate an Alert from TrafficInfo
* @param pTrafficInfo - pointer to the TrafficInfo
* @return TRUE operation was successful
*/
static BOOL RTTrafficInfo_GenerateAlert(RTTrafficInfo *pTrafficInfo, int iNodeNumber)
{
RTAlert alert;
int speed;
RTAlerts_Alert_Init(&alert);
alert.iID = pTrafficInfo->iID + ALERT_ID_OFFSET;
alert.iType = RT_ALERT_TYPE_TRAFFIC_INFO;
alert.iSubType = pTrafficInfo->iType;
alert.iSpeed = (int)(roadmap_math_meters_p_second_to_speed_unit( (float)pTrafficInfo->fSpeed)+0.5F);
strncpy_safe(alert.sLocationStr, pTrafficInfo->sDescription,RT_ALERT_LOCATION_MAX_SIZE);
speed = (int)(roadmap_math_meters_p_second_to_speed_unit((float)pTrafficInfo->fSpeed));
sprintf(alert.sDescription, roadmap_lang_get("Average speed %d %s"), speed, roadmap_lang_get(roadmap_math_speed_unit()) );
alert.iDirection = RT_ALERT_MY_DIRECTION;
alert.i64ReportTime = time(NULL);
alert.bAlertByMe = FALSE;
alert.iLatitude = pTrafficInfo->sNodes[iNodeNumber].Position.latitude;
alert.iLongitude = pTrafficInfo->sNodes[iNodeNumber].Position.longitude;
return RTAlerts_Add(&alert);
}
void roadmap_sound_initialize (void)
{
// Initialize the volume labels for GUI
SND_VOLUME_LVLS_LABELS[0] = roadmap_lang_get( "Silent" );
SND_VOLUME_LVLS_LABELS[1] = roadmap_lang_get( "Low" );
SND_VOLUME_LVLS_LABELS[2] = roadmap_lang_get( "Medium" );
SND_VOLUME_LVLS_LABELS[3] = roadmap_lang_get( "High" );
}
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 ();
}
static int on_next (SsdWidget widget, const char *new_value) {
static SsdWidget dialog;
SsdWidget button;
SsdWidget browserCont;
SsdSize dlg_size, cnt_size;
int browser_cont_flags = 0;
ssd_dialog_hide_current(dec_close);
if ( dialog != NULL )
{
if (ssd_dialog_currently_active_name() && !strcmp(ssd_dialog_currently_active_name(), "BonusBrowserDlg"))
ssd_dialog_hide_current(dec_close);
ssd_dialog_free( "BonusBrowserDlg", FALSE );
dialog = NULL;
}
dialog = ssd_dialog_new ( "BonusBrowserDlg", "", on_dialog_close,
SSD_CONTAINER_BORDER|SSD_DIALOG_FLOAT|SSD_DIALOG_MODAL|
SSD_ALIGN_CENTER|SSD_ROUNDED_CORNERS|SSD_ROUNDED_BLACK);
#ifndef TOUCH_SCREEN
browser_cont_flags = SSD_ALIGN_VCENTER;
ssd_dialog_add_vspace(dialog, 2 ,0);
#else
ssd_dialog_add_vspace(dialog, 5 ,0);
#endif
browserCont = ssd_container_new("BonusBrowserDlg.BrowserContainer","", SSD_MAX_SIZE, get_browser_height() , SSD_ALIGN_CENTER|browser_cont_flags);
browserCont->context = (void *)widget->context;
browserCont->draw = draw_browser_rect;
ssd_widget_set_color(browserCont, NULL, NULL);
ssd_widget_add(dialog, browserCont);
#ifdef TOUCH_SCREEN
ssd_dialog_add_vspace(dialog, 5 ,0);
button = ssd_button_label("Close_button", roadmap_lang_get("Close"), SSD_ALIGN_CENTER, on_button_close);
ssd_widget_add(dialog, button);
button = ssd_button_label("Navigate_button", roadmap_lang_get("Navigate"), SSD_ALIGN_CENTER, on_button_navigate);
button->context = widget->context;
ssd_widget_add(dialog, button);
#else
ssd_widget_set_left_softkey_callback(dialog, NULL);
ssd_widget_set_left_softkey_text(dialog, "");
#endif
ssd_dialog_activate ("BonusBrowserDlg", NULL);
ssd_dialog_recalculate( "BonusBrowserDlg" );
ssd_widget_get_size( dialog, &dlg_size, NULL );
ssd_widget_get_size( browserCont, &cnt_size, NULL );
return 1;
}
void navigate_res_update_ETA_widget(SsdWidget container, int iRouteDistance, int iRouteLenght, const char *via, BOOL showDistance){
SsdWidget text;
timeStruct ETA_struct;
timeStruct curTime ;
timeStruct timeToDest;
int distance_to_destination_far;
char str[100];
char unit_str[20];
char msg[250];
curTime = navigate_main_get_current_time();
timeToDest.hours = iRouteLenght / 3600;
timeToDest.minutes = (iRouteLenght % 3600) / 60;
timeToDest.seconds = iRouteLenght % 60;
ETA_struct = navigate_main_calculate_eta(curTime,timeToDest);
navigate_main_get_distance_str(iRouteDistance, &str[0], sizeof(str), &unit_str[0], sizeof(unit_str));
snprintf(msg, sizeof(msg), "%d", (int)(iRouteLenght/60.0));
text = ssd_widget_get (container, "ETA_W_Minutes_Text");
ssd_text_set_text(text, msg);
msg[0] = 0;
snprintf(msg + strlen(msg), sizeof(msg) - strlen(msg),
"%s",roadmap_lang_get("ETA"));
text = ssd_widget_get (container, "ETA_Text");
ssd_text_set_text(text, msg);
msg[0] = 0;
snprintf(msg + strlen(msg), sizeof(msg) - strlen(msg),
"%d:%02d",
ETA_struct.hours, ETA_struct.minutes);
text = ssd_widget_get (container, "ETA_W_ETA_TIME_Text");
ssd_text_set_text(text, msg);
if (showDistance){
text = ssd_widget_get (container, "ETA_W_Distance_Text");
ssd_text_set_text(text, str);
text = ssd_widget_get (container, "ETA_W_Distance_Unit_Text");
ssd_text_set_text(text, unit_str);
}
// VIA Text
if (via && (via[0] != 0)){
msg[0] = 0;
snprintf (msg, sizeof (msg), "%s: %s",
roadmap_lang_get("Via"),
roadmap_lang_get (via));
text = ssd_widget_get (container, "ETA_W_VIA_Text");
ssd_text_set_text(text, msg);
}
}
SsdWidget ssd_dialog_new (const char *name, const char *title,
PFN_ON_DIALOG_CLOSED on_dialog_closed, int flags)
{
SsdDialog dialog;
int width = SSD_MAX_SIZE;
int height = SSD_MAX_SIZE;
dialog = (SsdDialog)calloc( sizeof( struct ssd_dialog_item), 1);
roadmap_check_allocated(dialog);
dialog->name = strdup(name);
dialog->on_dialog_closed = on_dialog_closed;
dialog->in_focus = NULL;
dialog->tab_order_sorted = FALSE;
dialog->gui_tab_order_sorted = FALSE;
dialog->use_gui_tab_order = (SSD_DIALOG_GUI_TAB_ORDER & flags)? TRUE: FALSE;
dialog->ntv_kb_action = _ntv_kb_action_hide;
memset( &dialog->ntv_kb_params, 0, sizeof( RMNativeKBParams ) );
if (flags & SSD_DIALOG_FLOAT) {
if (flags & SSD_DIALOG_VERTICAL)
width = SSD_MIN_SIZE;
else
width = SSD_MAX_SIZE;
height = SSD_MIN_SIZE;
}
if (flags & SSD_DIALOG_NO_SCROLL) {
flags &= ~SSD_DIALOG_NO_SCROLL;
dialog->scroll = FALSE;
}
else{
dialog->scroll = TRUE;
}
dialog->container = ssd_container_new (name, title, width, height, flags);
dialog->next = RoadMapDialogWindows;
if (!(flags & SSD_DIALOG_FLOAT)){
dialog->scroll_container = ssd_container_new (name, title, width, SSD_MIN_SIZE, 0);
ssd_widget_set_color(dialog->scroll_container, NULL, NULL);
ssd_widget_add(dialog->container, dialog->scroll_container);
dialog->stop_offset = 0;
}
RoadMapDialogWindows = dialog;
ssd_widget_set_right_softkey_text(dialog->container, roadmap_lang_get("Back_key"));
ssd_widget_set_left_softkey_text (dialog->container, roadmap_lang_get("Exit_key"));
if (!(flags & SSD_DIALOG_FLOAT))
return dialog->scroll_container;
else
return dialog->container;
}
void roadmap_address_history (void) {
#define MAX_HISTORY_ENTRIES 100
static char *labels[MAX_HISTORY_ENTRIES];
static void *values[MAX_HISTORY_ENTRIES];
static int count = -1;
void *history;
static RoadMapAddressDialog context = {"Location", 0, 0, NULL, NULL,
NULL, NULL, 0};
if (count == -1) {
roadmap_history_declare ('A', 7);
labels[0] = (char *)roadmap_lang_get ("Other city");
}
history = roadmap_history_latest ('A');
count = 1;
while (history && (count < MAX_HISTORY_ENTRIES)) {
void *prev = history;
int i;
BOOL exist;
char *argv[4];
roadmap_history_get ('A', history, argv);
exist = FALSE;
for (i=0; i< count; i++){
if (!strcmp(labels[i], argv[2])){
exist = TRUE;
}
}
if (!exist){
if (labels[count]) free (labels[count]);
labels[count] = strdup(argv[2]);
values[count] = strdup(argv[2]);
count++;
}
history = roadmap_history_before ('A', history);
if (history == prev) break;
}
ssd_generic_list_dialog_show (roadmap_lang_get ("Address search"),
count,
(const char **)labels,
(const void **)values,
history_callback,
history_delete_callback,
&context, SSD_GEN_LIST_ENTRY_HEIGHT );
}
void show_alert_dialog(){
SsdWidget box;
SsdWidget bitmap, text;
char TextStr[200];
int alertId;
BOOL is_cancelable;
const char * iconName;
alertId = roadmap_alerter_get_active_alert_id();
roadmap_square_set_current(the_active_alert.square);
sprintf(TextStr, "%s",roadmap_lang_get((* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_string)) (alertId) ));
dialog = ssd_popup_new("Alert_Dlg", TextStr, NULL, SSD_MAX_SIZE, SSD_MIN_SIZE,NULL, SSD_PERSISTENT|SSD_ROUNDED_BLACK | SSD_HEADER_BLACK);
box = ssd_container_new ("box", NULL, SSD_MIN_SIZE,SSD_MIN_SIZE,SSD_WIDGET_SPACE);
ssd_widget_set_color(box, NULL, NULL);
ssd_widget_add (box, space(1));
sprintf(TextStr,"%s: %d %s", roadmap_lang_get("In"), the_active_alert.distance_to_alert, roadmap_lang_get(roadmap_math_distance_unit()));
text = ssd_text_new ("Distance", TextStr, 14,0);
ssd_widget_set_color(text, "#ffffff", "#ffffff");
ssd_widget_add (box, text);
ssd_widget_add (dialog, box);
if (the_active_alert.alert_type == ALERT){
iconName = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_alert_icon)) (alertId);
}
else {
iconName = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_warning_icon)) (alertId);
}
bitmap = ssd_bitmap_new("alert_Icon",iconName, SSD_ALIGN_RIGHT);
ssd_widget_add (box, bitmap);
is_cancelable = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->is_cancelable)) (alertId);
#ifdef TOUCH_SCREEN
ssd_widget_add (dialog,
ssd_button_label ("Hide", roadmap_lang_get ("Hide"),
SSD_WS_TABSTOP|SSD_ALIGN_CENTER, alert_dialog_buttons_callback));
if (is_cancelable){
ssd_widget_add (dialog,
ssd_button_label ("Irrelevant", roadmap_lang_get ("Not there"),
SSD_WS_TABSTOP|SSD_ALIGN_CENTER, alert_dialog_buttons_callback));
}
#else
if (is_cancelable)
set_softkey();
#endif
ssd_dialog_activate ("Alert_Dlg", NULL);
}
static BOOL keyboard_callback(int exit_code,
const char* value,
void* context)
{
RoadMapAddressSearch *search = (RoadMapAddressSearch *)context;
const char *title;
int count;
int is_kb_ok = (dec_ok == exit_code);
if (!search->city) {
if (!*value && is_kb_ok) {
search->callback ("", search->data);
free (search);
return TRUE;
}
title = roadmap_lang_get ("City");
} else {
title = roadmap_lang_get ("Street");
if (search->prefix && !strcmp(search->prefix, value)) {
ssd_dialog_set_value ("input", "");
free (search->prefix);
search->prefix = NULL;
return TRUE;
}
}
count = roadmap_address_search_count (is_kb_ok, value, search);
if (*value && !count) return 0;
if (!count) return 1;
if ((count <= MAX_LIST_RESULTS) || is_kb_ok)
{
roadmap_address_search_populate (is_kb_ok, value, search);
#ifndef J2ME
qsort (RoadMapAddressSearchNames, RoadMapAddressSearchCount,
sizeof(RoadMapAddressSearchNames[0]), cmpstring);
#endif
ssd_generic_list_dialog_show (title,
RoadMapAddressSearchCount,
(const char **)RoadMapAddressSearchNames,
NULL,
list_callback,
NULL,
search, SSD_GEN_LIST_ENTRY_HEIGHT );
}
return TRUE;
}
void roadmap_help_about (void) {
#ifdef IPHONE_NATIVE
roadmap_main_show_root(0);
#endif //IPHONE_NATIVE
char about[700];
sprintf (about, "Waze Qt port " PORT_RELEASE "\nDone by [email protected]\nhttp://code.google.com/p/waze-qt/\nBased on Waze(c) release %s\n%s\n%s",
roadmap_start_version(),
roadmap_lang_get("www.waze.com"),
roadmap_lang_get("Licensed under the terms of the\nGPL v2"));
about_dialog(about);
}
void roadmap_foursquare_venues_list (void) {
static const char* results[ROADMAP_FOURSQUARE_MAX_VENUE_COUNT];
static void* indexes[ROADMAP_FOURSQUARE_MAX_VENUE_COUNT];
static const char* icons[ROADMAP_FOURSQUARE_MAX_VENUE_COUNT];
int i;
roadmap_main_remove_periodic(roadmap_foursquare_venues_list);
for (i = 0; i < gsVenuesCount; i++) {
results[i] = gsVenuesList[i].sDescription;
#ifdef IPHONE_NATIVE
indexes[i] = (void*)(i+10);
#else
indexes[i] = (void*)i;
#endif
icons[i] = "foursquare_checkin";
}
#ifdef IPHONE_NATIVE
roadmap_list_menu_generic(roadmap_lang_get(FOURSQUARE_TITLE),
gsVenuesCount,
results,
(const void **)indexes,
icons,
NULL,
NULL,
on_venue_item_selected,
NULL,
NULL,
NULL,
60,
0,
NULL);
#else
ssd_generic_icon_list_dialog_show(roadmap_lang_get(FOURSQUARE_VENUES_TITLE),
gsVenuesCount,
results,
(const void **)indexes,
icons,
0,
on_venue_item_selected,
NULL,
NULL,
NULL,
NULL,
60,
0,
FALSE);
#endif //IPHONE_NATIVE
}
/***********************************************************
* Name : get_welcome_wiz_entry_group
* Purpose : Creates the entry with label
* Params : [in] - none
* : [out] - none
* Returns :
* Notes :
*/
static SsdWidget get_welcome_wiz_entry_group( const char* label_text, const char* entry_name, const char* edit_box_title )
{
SsdWidget entry;
entry = ssd_entry_label_new( entry_name, roadmap_lang_get ( label_text ), WELCOME_WIZ_DLG_LBL_FONT, WELCOME_WIZ_DLG_LBL_CNT_WIDTH,
WELCOME_WIZ_DLG_ENTRY_HEIGHT, SSD_END_ROW | SSD_WS_TABSTOP, "" );
ssd_entry_label_set_label_color( entry, WELCOME_WIZ_DLG_LBL_COLOR );
ssd_entry_label_set_label_offset( entry, WELCOME_WIZ_DLG_HOFFSET );
ssd_entry_label_set_kb_params( entry, roadmap_lang_get( edit_box_title ), NULL, NULL, NULL, SSD_KB_DLG_INPUT_ENGLISH );
ssd_entry_label_set_editbox_title( entry, roadmap_lang_get( edit_box_title ) );
return entry;
}
void roadmap_map_settings_init(void){
roadmap_log (ROADMAP_DEBUG, "intialiazing map settings");
initialized = 1;
roadmap_config_declare_enumeration
("user", &RoadMapConfigShowScreenIconsOnTap, NULL, "yes", "no", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigShowTopBarOnTap, NULL, "no", "yes", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigAutoShowStreetBar, NULL, "yes", "no", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigShowWazers, NULL, "yes", "no", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigColorRoads, NULL, "yes", "no", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigRoadGoodies, NULL, "yes", "no", NULL);
roadmap_config_declare ("user", &RoadMapConfigReportDontShow, "", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigShowSpeedCams, NULL, "yes", "no", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigShowSpeedometer, NULL, "yes", "no", NULL);
roadmap_config_declare_enumeration
("preferences", &RoadMapConfigEnableToggleConstruction, NULL, "yes", "no", NULL);
#if 0
roadmap_config_declare_enumeration
("user", &RoadMapConfigDisplayHouseNumbers, NULL, "no", "yes", NULL);
roadmap_config_declare_enumeration
("user", &RoadMapConfigDisplayMapProblems, NULL, "no", "yes", NULL);
#endif
// Define the labels and values
yesno_label[0] = roadmap_lang_get ("Yes");
yesno_label[1] = roadmap_lang_get ("No");
yesno[0] = "Yes";
yesno[1] = "No";
}
void roadmap_lang_initialize (void) {
const char *p;
initialized = TRUE;
roadmap_lang_initialize_params();
roadmap_lang_allocate ();
lang_labels[0] = "English";
lang_values[0] = "eng";
LangNextLoginCb = Realtime_NotifyOnLogin (roadmap_lang_login_cb);
roadmap_lang_conf_load(roadmap_path_downloads());
for (p = roadmap_path_first("user");
p != NULL && !RoadMapLangLoaded;
p = roadmap_path_next("user", p))
{
RoadMapLangLoaded = roadmap_lang_load (p);
}
RoadMapLangRTL = (strcasecmp(roadmap_lang_get ("RTL"), "Yes") == 0);
#ifdef QTMOBILITY
roadmap_lang_loaded();
#endif
}
static void create_messagebox (void) {
SsdWidget dialog;
dialog = ssd_dialog_new ("message_box", "", NULL,
SSD_CONTAINER_BORDER|SSD_CONTAINER_TITLE|SSD_DIALOG_FLOAT|
SSD_ALIGN_CENTER|SSD_ALIGN_VCENTER|SSD_ROUNDED_CORNERS);
ssd_widget_set_color (dialog, "#000000", "#ff0000000");
ssd_widget_add (dialog,
ssd_container_new ("spacer1", NULL, 0, 10, SSD_END_ROW));
ssd_widget_add (dialog,
ssd_text_new ("text", "", 13, SSD_END_ROW|SSD_WIDGET_SPACE));
/* Spacer */
ssd_widget_add (dialog,
ssd_container_new ("spacer2", NULL, 0, 20, SSD_END_ROW));
ssd_widget_add (dialog,
ssd_button_label ("confirm", roadmap_lang_get ("Ok"),
SSD_ALIGN_CENTER|SSD_START_NEW_ROW|SSD_WS_DEFWIDGET|
SSD_WS_TABSTOP,
button_callback));
}
void roadmap_lang_initialize (void) {
const char *p;
initialized = TRUE;
roadmap_log (ROADMAP_INFO, "Starting 'roadmap_lang_initialize'");
roadmap_lang_initialize_params();
roadmap_lang_allocate ();
lang_labels[0] = "English";
lang_values[0] = "eng";
p = roadmap_path_user ();
LangNextLoginCb = Realtime_NotifyOnLogin (roadmap_lang_login_cb);
roadmap_lang_conf_load(roadmap_path_downloads());
RoadMapLangLoaded = roadmap_lang_load (p);
if (!RoadMapLangLoaded){
p = roadmap_path_downloads();
RoadMapLangLoaded = roadmap_lang_load (p);
}
RoadMapLangRTL = (strcasecmp(roadmap_lang_get ("RTL"), "Yes") == 0);
NOPH_SetSystemLanguage(roadmap_lang_get_system_lang());
}
static void roadmap_factory_add_help (RoadMapMenu menu) {
int ok;
const char *label;
RoadMapCallback callback;
for (ok = roadmap_help_first_topic(&label, &callback);
ok;
ok = roadmap_help_next_topic(&label, &callback)) {
roadmap_main_add_menu_item (menu,
roadmap_lang_get (label),
roadmap_lang_get (label),
callback);
}
}
void roadmap_groups_alerts_action(void){
if (!roadmap_groups_feature_enabled())
return;
if (!roadmap_groups_tip_shown() && (roadmap_groups_get_num_following() > 0)){
if (roadmap_groups_get_popup_config() == POPUP_REPORT_NONE){
roadmap_message_ticker_show(roadmap_lang_get("Waze Groups Tip"),roadmap_lang_get("Want group messages to pop-up to you? Go to Settings >Groups"), "group_settings", -1);
}
roadmap_groups_set_tip_shown();
}
RTAlerts_clear_group_counter();
RealtimeAlertsListGroup();
}
void RealtimeAltRoutes_OnRouteSegments (NavigateRouteRC rc, const NavigateRouteResult *res, const NavigateRouteSegments *segments){
char msg[128];
roadmap_log (ROADMAP_DEBUG,"RealtimeAltRoutes_OnRouteSegments");
if (cancelled){
roadmap_log (ROADMAP_DEBUG,"RealtimeAltRoutes_OnRouteSegments - Navigation cancelled");
return;
}
if (rc != route_succeeded) {
switch (rc) {
case route_server_error:
// message already displayed
break;
case route_inconsistent:
default:
snprintf(msg, sizeof(msg), "%s.\n%s", roadmap_lang_get("The service failed to provide a valid route"), roadmap_lang_get("Please try again later"));
roadmap_log (ROADMAP_ERROR, "The service failed to provide a valid route rc=%d", rc);
roadmap_messagebox ("Oops", msg);
}
return;
}
navigate_main_on_route (res->flags, res->total_length, res->total_time, segments->segments,
segments->num_segments, segments->num_instrumented,
res->geometry.points, res->geometry.num_points, res->description, FALSE);
}
static void roadmap_address_street_result (const char *result, void *data) {
RoadMapAddressDialog *context = (RoadMapAddressDialog *)data;
char name[255];
char *tmp;
if ((result == NULL) || !strlen (result)) return;
strncpy_safe (name, result, sizeof(name));
tmp = strrchr (name, ',');
if (tmp) {
*tmp = 0;
tmp += 2;
if (*tmp && !*context->city_name) {
free (context->city_name);
context->city_name = strdup (tmp);
}
}
if (context->street_name) free(context->street_name);
context->street_name = strdup(name);
ssd_show_keyboard_dialog( roadmap_lang_get ("House number"),
NULL,
house_keyboard_callback,
context);
}
static int roadmap_address_show (const char *city,
const char *street_name,
const char *street_number_image,
RoadMapAddressDialog *context) {
int i;
int count;
RoadMapGeocode *selections;
char *state;
const char *argv[4];
address_info ai;
ai.state = NULL;
ai.country = NULL;
ai.city = city;
ai.street = street_name;
ai.house = street_number_image;
state = "IL";
if (context->use_zip) {
return 0; /* TBD: how to select by ZIP ? Need one more table in usdir. */
}
ssd_dialog_hide_all(dec_close);
count = roadmap_geocode_address (&selections,
street_number_image,
street_name,
city,
state);
if (count <= 0) {
roadmap_messagebox (roadmap_lang_get ("Warning"),
roadmap_geocode_last_error_string());
free (selections);
return 0;
}
argv[0] = street_number_image;
argv[1] = street_name;
argv[2] = city;
argv[3] = state;
roadmap_history_add ('A', argv);
roadmap_history_save();
roadmap_address_done (selections, context, &ai);
for (i = 0; i < count; ++i) {
free (selections[i].name);
selections[i].name = NULL;
}
free (selections);
return 1;
}
void roadmap_car_dialog (RoadMapCallback callback) {
char **files;
const char *cursor;
char **cursor2;
char *directory;
int count = 0;
static roadmap_car_list_dialog context = {"roadmap_car", NULL};
static char *labels[MAX_CAR_ENTRIES] ;
static void *values[MAX_CAR_ENTRIES] ;
static void *icons[MAX_CAR_ENTRIES];
context.callback = callback;
for (cursor = roadmap_path_first ("skin");
cursor != NULL;
cursor = roadmap_path_next ("skin", cursor)) {
directory = roadmap_path_join (cursor, "cars");
files = roadmap_path_list (directory, ".png");
for (cursor2 = files; *cursor2 != NULL; ++cursor2) {
labels[count] = (char *)roadmap_lang_get(*cursor2);
values[count] = strtok(*cursor2,".");
icons[count] = roadmap_path_join("cars", *cursor2);
count++;
}
}
ssd_generic_icon_list_dialog_show (roadmap_lang_get ("Select your car"),
count,
(const char **)labels,
(const void **)values,
(const char **)icons,
NULL,
roadmap_car_call_back,
NULL,
&context,
NULL,
NULL,
70,
0,
FALSE);
}
static void update_button(void){
char button_txt[20];
SsdWidget button = ssd_widget_get(dialog, "Hide");
if (g_seconds != -1)
sprintf(button_txt, "%s (%d)", roadmap_lang_get ("Hide"), g_seconds);
else
sprintf(button_txt, "%s", roadmap_lang_get ("Hide"));
#ifdef TOUCH_SCREEN
if (button)
ssd_button_change_text(button,button_txt );
#else
ssd_widget_set_right_softkey_text(dialog->parent, button_txt);
ssd_dialog_refresh_current_softkeys();
#endif
if (!roadmap_screen_refresh())
roadmap_screen_redraw();
}
static int history_delete_callback (SsdWidget widget, const char *new_value, const void *value,
void *data) {
char message[100];
if (!new_value[0] || !strcmp(new_value, roadmap_lang_get ("Other city"))) {
// do nothing here
return 0;
} else if (!strchr(new_value, ',')) {
// do nothing
return 0;
} else {
sprintf(message,"%s\n%s",roadmap_lang_get("Delete history entry"), new_value);
ssd_confirm_dialog("Delete History", message,FALSE, delete_callback, (void *)ssd_dialog_get_data ("list"));
return 0;
}
}
