C++ roadmap_lang_get函数代码示例

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

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