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; } }