Пример #1
0
SsdWidget ssd_checkbox_new (const char *name,
                          BOOL Selected,
                          int flags,
                          SsdCallback callback,
                          const char *checked_icon,
                          const char *unchecked_icon,
                          int style) {


   SsdWidget button;
   SsdWidget choice;

   struct ssd_checkbox_data *data =
      (struct ssd_checkbox_data *)calloc (1, sizeof(*data));

   choice =
      ssd_container_new (name, NULL, SSD_MIN_SIZE, SSD_MIN_SIZE, flags);
   ssd_widget_set_color(choice, NULL, NULL);

   data->callback = callback;
   data->selected = Selected;
   data->style = style;
   choice->get_value = get_value;
   choice->get_data = get_data;
   choice->set_value = set_value;
   choice->set_data = set_data;
   choice->data = data;
   choice->bg_color = NULL;

   if (checked_icon == NULL)
   		data->checked_icon = checked_button[data->style];
   else
   		data->checked_icon = checked_icon;

   if (unchecked_icon == NULL)
   		data->unchecked_icon = unchecked_button[data->style];
   else
   		data->unchecked_icon = unchecked_icon;


   if (Selected)
   	button = ssd_button_new ("checkbox_button", "", &data->checked_icon, 1,
                   SSD_ALIGN_VCENTER, choice_callback);
   else
   	button = ssd_button_new ("checkbox_button", "", &data->unchecked_icon, 1,
                   SSD_ALIGN_VCENTER, choice_callback);
   ssd_widget_add (choice, button);

   if (sgChkBoxOffsets.left == 0) {
      sgChkBoxOffsets.left = -ADJ_SCALE(CHKBOX_CLICK_OFFSET_DEFAULT_X);
      sgChkBoxOffsets.top = -ADJ_SCALE(CHKBOX_CLICK_OFFSET_DEFAULT_Y);
      sgChkBoxOffsets.right = ADJ_SCALE(CHKBOX_CLICK_OFFSET_DEFAULT_X);
      sgChkBoxOffsets.bottom = ADJ_SCALE(CHKBOX_CLICK_OFFSET_DEFAULT_Y);
   }

   ssd_widget_set_click_offsets( button, &sgChkBoxOffsets );
   ssd_widget_set_click_offsets( choice, &sgChkBoxOffsets );

   return choice;
}
Пример #2
0
static SsdWidget create_del_button(){
   char *icons[3];
   SsdWidget button;
   icons[0] = "DeleteReminder";
   icons[1] = "DeleteReminder_s";
   icons[2] = NULL;
   button = ssd_button_new("Delete_button", "Delete", (const char**) &icons[0], 2, SSD_ALIGN_CENTER|SSD_WS_TABSTOP|SSD_ALIGN_BOTTOM, on_delete);
   ssd_widget_set_offset(button, 0, -20);
   return button;
}
Пример #3
0
SsdWidget ssd_dialog_new_button (const char *name, const char *value,
                                 const char **bitmaps, int num_bitmaps,
                                 int flags, SsdCallback callback) {

   SsdWidget child =
      ssd_button_new (name, value, bitmaps, num_bitmaps, flags, callback);
   append_child (child);

   return child;
}
Пример #4
0
static void add_title (SsdWidget w, int flags) {
   SsdWidget title, text;
	int rt_soft_key_flag;
	int lf_soft_key_flag;
	int align_flag = SSD_ALIGN_CENTER;

#ifdef TOUCH_SCREEN
	const char *back_buttons[] = {"back_button", "back_button_s"};
#endif

	if (ssd_widget_rtl (NULL)) {
		rt_soft_key_flag = SSD_END_ROW;
		lf_soft_key_flag = SSD_ALIGN_RIGHT;
	}
	else{
		rt_soft_key_flag = SSD_ALIGN_RIGHT;
		lf_soft_key_flag = SSD_END_ROW;
	}


  if (!((w->flags & SSD_DIALOG_FLOAT) && !(w->flags & SSD_DIALOG_TRANSPARENT)))
  {
	int height = ADJ_SCALE( 34 );

#ifdef ANDROID
   align_flag = 0;
#endif //ANDROID

#ifndef TOUCH_SCREEN
      height = 28;
#endif
   title = ssd_container_new ("title_bar", NULL, SSD_MAX_SIZE, height, SSD_END_ROW);
   ssd_widget_set_click_offsets_ext( title, 0, 0, 0, 10 );
   ssd_widget_set_offset(title, 0, 0);
   title->draw = draw_title;
  }
  else{
   int height = 28;
      if ( roadmap_screen_is_hd_screen() )
      {
         height = height*1.8;
      }

      title = ssd_container_new ("title_bar", NULL, SSD_MAX_SIZE, height,
                              SSD_END_ROW);
  }

   ssd_widget_set_color (title, "#ffffff", "#ff0000000");

   text = ssd_text_new ("title_text", "" , 13, SSD_WIDGET_SPACE|SSD_ALIGN_VCENTER|align_flag);

   ssd_widget_set_color (text, "#ffffff", "#ff0000000");



   if ((w->flags & SSD_ROUNDED_CORNERS) && (!(w->flags & SSD_POINTER_MENU)))
   	ssd_widget_set_color (text, "#ffffff", "#ff0000000");

   if (w->flags & SSD_CONTAINER_TITLE){
   		if (w->flags & SSD_ROUNDED_BLACK)
   		   ssd_widget_set_color (text, "#ffffff", "#ffffff");
   		else if (!(w->flags & SSD_DIALOG_FLOAT))
   			ssd_widget_set_color (text, "#ffffff", "#ff0000000");
   		else
   		   if (flags & SSD_DIALOG_TRANSPARENT)
   		      ssd_widget_set_color (text, "#ffffff", "#ff0000000");
   		   else
   		      ssd_widget_set_color (text, "#000000", "#ff0000000");
   }
#if defined(TOUCH_SCREEN)
   if (!( ((flags & SSD_DIALOG_FLOAT)&& !(flags & SSD_DIALOG_TRANSPARENT)) || (flags & SSD_DIALOG_NO_BACK))){
      SsdWidget btn = NULL;
#ifndef ANDROID
      btn = ssd_button_new (SSD_DIALOG_BUTTON_BACK_NAME, "", back_buttons, 2,
                        SSD_ALIGN_VCENTER, button_callback );
#endif


	   if ( ssd_widget_rtl(NULL) )
	   {
         SsdWidget btn2 =             ssd_button_new ("right_title_button", "", back_buttons, 2,
                  SSD_ALIGN_VCENTER, NULL );
         ssd_widget_add( title, btn2 );
         ssd_widget_set_click_offsets_ext( btn2, -40, -20, 20, 10 );
         ssd_widget_hide(btn2);
#ifdef ANDROID
         ssd_dialog_add_hspace (title, 10, 0);
#endif //ANDROID
	      ssd_widget_add (title,text);
	      if ( btn != NULL )
	      {
	         ssd_widget_set_click_offsets_ext( btn, -20, -20, 70, 10 );
	         ssd_widget_set_flags( btn, SSD_ALIGN_VCENTER|SSD_ALIGN_RIGHT );
	         ssd_widget_add( title, btn );
	      }
	   }
	   else
	   {
         SsdWidget btn2 =             ssd_button_new ("right_title_button", "", back_buttons, 2,
                  SSD_ALIGN_VCENTER|SSD_ALIGN_RIGHT, NULL );
         ssd_widget_set_click_offsets_ext( btn2, -40, -20, 20, 10 );
         ssd_widget_hide(btn2);
         if ( btn != NULL )
         {
            ssd_widget_set_click_offsets_ext( btn, -20, -20, 70, 10 );
            ssd_widget_add( title, btn );
         }
#ifdef ANDROID
         ssd_dialog_add_hspace (title, 10, 0);
#endif //ANDROID
         ssd_widget_add (title,text);
         ssd_widget_add( title, btn2 );
	   }

	}
   else
   {
	   ssd_widget_add ( title, text );
   }
#else
   ssd_widget_add ( title, text );
#endif

   ssd_widget_add (w, title);
}
Пример #5
0
static void create_ssd_dialog (void) {

   const char *left_icon[] = {"left_side"};
   const char *right_icon[] = {"right_side"};
   SsdWidget left;
   SsdWidget right;
   SsdWidget box;
   SsdWidget text;
   int align = 0;

   SsdWidget dialog = ssd_dialog_new ("Update house number",
                  roadmap_lang_get ("Update house number"),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", "#ffffffdd");

   /* Labels */
   box = ssd_container_new ("labels_box", NULL, -1, -1, SSD_WIDGET_SPACE);
   ssd_widget_set_color (box, "#000000", NULL);

   ssd_widget_add (box,
      ssd_text_new ("street_label", roadmap_lang_get (STREET_PREFIX),
                    14, SSD_TEXT_LABEL|SSD_END_ROW));

   ssd_widget_add (box,
      ssd_text_new ("city_label", roadmap_lang_get (CITY_PREFIX),
                    14, SSD_TEXT_LABEL|SSD_END_ROW));

   ssd_widget_add (dialog, box);

   /* Values */
   box = ssd_container_new ("values_box", NULL, -1, -1, SSD_END_ROW);
   ssd_widget_set_color (box, "#000000", NULL);

   ssd_widget_add (box,
      ssd_text_new (STREET_PREFIX, "", 14, SSD_END_ROW));

   ssd_widget_add (box,
      ssd_text_new (CITY_PREFIX, "", 14, SSD_END_ROW));

   ssd_widget_add (dialog, box);

   /* Spacer */
   ssd_widget_add (dialog,
      ssd_container_new ("spacer1", NULL, 0, 16, SSD_END_ROW));

   /* Left side */
   if (ssd_widget_rtl (NULL)) {
      align = SSD_ALIGN_RIGHT;
   }

   left = ssd_container_new ("left", NULL, -1, -1, align|SSD_WS_TABSTOP);
   ssd_widget_set_color (left, "#000000", NULL);
   ssd_widget_set_offset (left, 2, 0);

   box = ssd_container_new ("left_box", NULL, 50, 20,
                            SSD_ALIGN_CENTER|SSD_END_ROW);
   ssd_widget_set_color (box, "#000000", NULL);

   ssd_widget_add (box,
      ssd_text_new ("estimated_left", "", 16, SSD_END_ROW|SSD_ALIGN_CENTER));
   ssd_widget_add (left, box);

   ssd_widget_add (left,
         ssd_button_new ("left_button", "", left_icon, 1,
                         SSD_ALIGN_CENTER|SSD_END_ROW, button_callback));

   text = ssd_text_new (UPDATE_LEFT, "", 15, SSD_END_ROW|SSD_ALIGN_CENTER);
   ssd_widget_set_color (text, "#ff0000", 0);
   ssd_widget_add (left, text);

   /* Right side */
   if (ssd_widget_rtl (NULL)) align = 0;
   else align = SSD_ALIGN_RIGHT;

   right = ssd_container_new ("right", NULL, -1, -1, align|SSD_WS_TABSTOP);
   ssd_widget_set_offset (right, 2, 0);
   ssd_widget_set_color (right, "#000000", NULL);
   box = ssd_container_new ("right_box", NULL, 50, 20,
                            SSD_ALIGN_CENTER|SSD_END_ROW);
   ssd_widget_set_color (box, "#000000", NULL);

   ssd_widget_add (box,
      ssd_text_new ("estimated_right", "", 16, SSD_END_ROW|SSD_ALIGN_CENTER));
   ssd_widget_add (right, box);

   ssd_widget_add (right,
         ssd_button_new ("right_button", "", right_icon, 1,
                         SSD_ALIGN_CENTER|SSD_END_ROW, button_callback));

   text = ssd_text_new (UPDATE_RIGHT, "", 15, SSD_END_ROW);
   ssd_widget_set_color (text, "#ff0000", 0);
   ssd_widget_add (right, text);

   if (ssd_widget_rtl (NULL)) {
      ssd_widget_add (dialog, right);
      ssd_widget_add (dialog, left);
   } else {
      ssd_widget_add (dialog, left);
      ssd_widget_add (dialog, right);
   }

   ssd_widget_add (dialog,
      ssd_button_label ("OK", roadmap_lang_get ("Ok"),
                        SSD_ALIGN_CENTER|SSD_START_NEW_ROW|SSD_WS_TABSTOP, button_callback));

}
Пример #6
0
SsdWidget navigate_res_ETA_widget(int iRouteDistance, int iRouteLenght, const char *via, BOOL showDistance, BOOL showAltBtn, SsdCallback callback){
   SsdWidget ETA_container, inner_container, button, text;
   char *icon[3];
   int inner_width;
   int font_size;
   int alt_route_button_w = 60;
   int width = SSD_MAX_SIZE;
   int factor = 10;
   int num_spaces = 7;
   if (roadmap_screen_is_hd_screen())
      alt_route_button_w = 90;
#ifdef IPHONE_NATIVE
   width = 280;
#else
   width = roadmap_canvas_width() - 40;
   if (roadmap_canvas_height() < roadmap_canvas_width())
      width = roadmap_canvas_height() - 40;
#endif

#ifndef TOUCH_SCREEN
   alt_route_button_w = 0;
#endif   
   ETA_container = ssd_container_new ("eta container", NULL, width, SSD_MIN_SIZE,
                  SSD_WIDGET_SPACE | SSD_ALIGN_CENTER | SSD_END_ROW  );
   ssd_widget_set_color(ETA_container, NULL, NULL);

   if (roadmap_canvas_width() > roadmap_canvas_height()){
      inner_width = roadmap_canvas_height() - alt_route_button_w - 40;
   }else{
      inner_width = roadmap_canvas_width() - alt_route_button_w - 40;
   }
   inner_container = ssd_container_new ("inner container", NULL, inner_width, SSD_MIN_SIZE,
                  SSD_WIDGET_SPACE | SSD_END_ROW  );
   ssd_widget_set_color(inner_container, NULL, NULL);
   
   // Add Alternatives buttons
#ifdef TOUCH_SCREEN   
   if (roadmap_alternative_feature_enabled() && RealTimeLoginState () && showAltBtn){
      icon[0] = "alternative_button";
      icon[1] = "alternative_button_s";
      icon[2] = NULL;
      button = ssd_button_new("Alt_button", "Alt",(const char**) &icon[0], 2, SSD_ALIGN_RIGHT|SSD_WS_TABSTOP, callback);
      ssd_widget_add(ETA_container, button);
   }
#endif   
 
#ifdef IPHONE_NATIVE
//   ssd_widget_add (inner_container, space (7));
#endif
   font_size = 30;
#ifdef RIMAPI
   font_size = 22;
#endif
   text = ssd_text_new ("ETA_W_Minutes_Text", "", font_size, 0);
   ssd_text_set_color(text,"#ffffff");
   ssd_widget_add (inner_container, text);
   ssd_dialog_add_hspace(inner_container, 3, 0);
   font_size = 24;
#ifdef RIMAPI
   ssd_widget_set_offset(text, 0, 4);
   font_size = 16;
#endif

   text = ssd_text_new ("ETA__W_Min_text", roadmap_lang_get ("min."), font_size, 0);
   ssd_text_set_color(text,"#ffffff");
#ifndef RIMAPI
   ssd_widget_set_offset(text, 0, 6);
#else
   ssd_widget_set_offset(text, 0, 13);
#endif
   ssd_widget_add (inner_container, text);

   if (showDistance){
#ifndef RIMAPI
      ssd_dialog_add_hspace(inner_container, 5, 0);
#else
      ssd_dialog_add_hspace(inner_container, 3, 0);
#endif
      text = ssd_text_new ("ETA_W_Distance_Text", "", 18, SSD_TEXT_NORMAL_FONT);
      ssd_text_set_color(text,"#ffffff");
      ssd_widget_add (inner_container, text);

//#ifndef IPHONE_NATIVE 
#ifdef RIMAPI
      ssd_dialog_add_hspace(inner_container, 1, 0);
      ssd_widget_set_offset(text, 0, 11);
#else
      ssd_dialog_add_hspace(inner_container, 3, 0);
      ssd_widget_set_offset(text, 0, 14);
#endif
//#endif      
      text = ssd_text_new ("ETA_W_Distance_Unit_Text", "", 16, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
      ssd_text_set_color(text,"#ffffff");
      ssd_widget_add (inner_container, text);
//#ifndef IPHONE_NATIVE 
#ifdef RIMAPI
      ssd_widget_set_offset(text, 0, 13);
#else
      ssd_widget_set_offset(text, 0, 15);
#endif
//#endif   
  }
   
#ifdef RIMAPI
   num_spaces = 2;
#endif
   ssd_widget_add (inner_container, space (num_spaces));
   

   text = ssd_text_new ("ETA_Text", "", 18, SSD_TEXT_NORMAL_FONT);
   ssd_text_set_color(text,"#ffffff");
   ssd_widget_add (inner_container, text);
   ssd_dialog_add_hspace(inner_container, 3, 0);
   
   text = ssd_text_new ("ETA_W_ETA_TIME_Text", "", 18, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
   ssd_text_set_color(text,"#ffffff");
   ssd_widget_add (inner_container, text);
   ssd_widget_add (inner_container, space (2));


   // VIA Text
#ifndef RIMAPI
   text = ssd_text_new ("ETA_W_VIA_Text", "", 16, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
#else
   text = ssd_text_new ("ETA_W_VIA_Text", "", 13, SSD_END_ROW|SSD_TEXT_NORMAL_FONT);
#endif
   ssd_text_set_color(text,"#ffffff");
   ssd_widget_add (inner_container, text);
   
   ssd_widget_add(ETA_container, inner_container);
   navigate_res_update_ETA_widget(ETA_container, iRouteDistance, iRouteLenght, via, showDistance);
   return ETA_container;
   
}
Пример #7
0
SsdWidget ssd_confirmed_entry_new (const char *name,
                                   const char *value,
                                   int entry_flags,
                                   int text_flags,
                                   int width,
                                   int height,
                                   const char *messagebox_text,
                                   const char *background_text) {

    const char *edit_button[] = {"edit_right", "edit_left"};
    SsdWidget button;
    SsdWidget space;
    SsdWidget bg_text;
    SsdWidget entry;
    SsdWidget text_box;
    int tab_st = 0;
    int txt_box_height = 40;
    SsdEntryContext*  ctx = (SsdEntryContext*) calloc( 1, sizeof( SsdEntryContext ) );
#ifndef TOUCH_SCREEN
    txt_box_height = 23;
#endif

#ifdef OPENGL
    if ( height > 0 )
        txt_box_height = height;
#endif


    entry_ctx_init( ctx );

    if (entry_flags & SSD_WS_TABSTOP) {
        entry_flags &= ~SSD_WS_TABSTOP;
        tab_st = SSD_WS_TABSTOP;
    }

    entry =
        ssd_container_new (name, NULL, SSD_MIN_SIZE, SSD_MIN_SIZE, entry_flags);

    text_box =
        ssd_container_new ("text_box", NULL, width,
                           txt_box_height, SSD_CONTAINER_TXT_BOX|SSD_ALIGN_VCENTER|tab_st);

    ssd_widget_set_pointer_force_click( text_box );
    entry->get_value = get_value;
    entry->set_value = set_value;

    entry->bg_color = NULL;

    text_box->callback = confirmed_edit_callback;
    text_box->bg_color = NULL;


    space = ssd_container_new("Space", NULL,5, SSD_MIN_SIZE, SSD_WIDGET_SPACE);
    ssd_widget_set_color(space, NULL, NULL);
    ssd_widget_add(text_box, space);
    ssd_widget_add (text_box, ssd_text_new ("Text", value, -1, text_flags|SSD_ALIGN_VCENTER));
    if (background_text == NULL)
        bg_text = ssd_text_new ("BgText", "", -1, SSD_ALIGN_VCENTER);
    else
        bg_text = ssd_text_new ("BgText", background_text, -1, SSD_ALIGN_VCENTER);
    ssd_widget_set_color(bg_text, "#C0C0C0",NULL);
    ssd_widget_add (text_box, bg_text);
#ifdef TOUCH_SCREEN
    if (!ssd_widget_rtl(NULL))
        button = ssd_button_new ("edit_button", "", &edit_button[0], 1,
                                 SSD_ALIGN_VCENTER|SSD_ALIGN_RIGHT, edit_callback);
    else
        button = ssd_button_new ("edit_button", "", &edit_button[1], 1,
                                 SSD_ALIGN_VCENTER|SSD_ALIGN_RIGHT, edit_callback);

    if (!ssd_widget_rtl(NULL))
        ssd_widget_set_offset(button, 10, 0);
    else
        ssd_widget_set_offset(button, -11, 0);
#endif
    ctx->mb_text = (void *)strdup(messagebox_text);

    entry->context = ctx;

    if ((value != NULL) && (value[0] != 0))
        ssd_widget_hide(bg_text);

    ssd_widget_add (entry, text_box);

    /* Default keyboard params */
    ssd_entry_set_kb_params( entry, name, NULL, NULL, NULL, 0 );

    return entry;
}
Пример #8
0
static void create_dialog (void) {
   SsdWidget dialog;
   SsdWidget box, driving, space, text;
   char *icon[2];
   int i = 0;
   BOOL checked = FALSE;
   int container_height = 24;
   int tab_flag = SSD_WS_TABSTOP;

#ifdef TOUCH_SCREEN
  container_height = ssd_container_get_row_height();
#endif


   dialog = ssd_dialog_new (PRIVACY_DIALOG, roadmap_lang_get (
            PRIVACY_TITLE), on_close_dialog, SSD_CONTAINER_TITLE);

#ifdef TOUCH_SCREEN
   space = ssd_container_new ("spacer", NULL, SSD_MAX_SIZE, 5, SSD_WIDGET_SPACE
            | SSD_END_ROW);
   ssd_widget_set_color (space, NULL, NULL);
   ssd_widget_add (dialog, space);

#endif
   box = ssd_container_new ("Privacy Heading group", NULL, SSD_MIN_SIZE, SSD_MIN_SIZE,
            SSD_WIDGET_SPACE | SSD_END_ROW);

   text = ssd_text_new ("privacy_heading_label",
         roadmap_lang_get ("Display my location on waze mobile and web maps as follows:"), SSD_HEADER_TEXT_SIZE,
         SSD_TEXT_NORMAL_FONT|SSD_TEXT_LABEL | SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE);
   ssd_text_set_color(text, SSD_CONTAINER_TEXT_COLOR);
   ssd_widget_add (box, text);
   ssd_widget_set_color (box, NULL, NULL);


   ssd_widget_set_color (box, NULL, NULL);

   //////////////////////////////////////////////////
   // * Driving
   //////////////////////////////////////////////////
   driving = ssd_container_new ("Report privacy", NULL, ssd_container_get_width(),
            SSD_MIN_SIZE, SSD_WIDGET_SPACE | SSD_CONTAINER_FLAGS | SSD_POINTER_NONE
                     | SSD_CONTAINER_BORDER | SSD_ALIGN_CENTER);
   ssd_widget_add (driving, box);
   box = ssd_container_new ("Driving Heading group", NULL, SSD_MIN_SIZE, SSD_MIN_SIZE,
            SSD_WIDGET_SPACE | SSD_END_ROW);

   text = ssd_text_new ("driving_heading_label",
         roadmap_lang_get ("When driving"), SSD_HEADER_TEXT_SIZE, SSD_TEXT_NORMAL_FONT|SSD_TEXT_LABEL
                  | SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE | SSD_END_ROW);
   ssd_text_set_color(text, SSD_CONTAINER_TEXT_COLOR);
   ssd_widget_add (box, text);

   ssd_widget_add (box, ssd_separator_new ("separator", SSD_ALIGN_BOTTOM));
   ssd_widget_set_color (box, NULL, NULL);
   ssd_widget_add (driving, box);

   //////////////////////////////////////////////////
   // * Nickname
   //////////////////////////////////////////////////
   box = ssd_container_new ("Nickname group", NULL, SSD_MAX_SIZE,
                  container_height, SSD_WIDGET_SPACE | SSD_END_ROW | tab_flag);

   if (gState == VisGrp_NickName)
      checked = TRUE;
   else
      checked = FALSE;

   CheckboxDriving[i] = ssd_checkbox_new (RT_CFG_PRM_VISGRP_Nickname, checked,
            SSD_ALIGN_VCENTER | SSD_ALIGN_RIGHT, checkbox_callback, NULL, NULL,
            CHECKBOX_STYLE_V);
   ssd_widget_add (box, CheckboxDriving[i]);
   i++;

   icon[0] = "privacy_nickname";
   icon[1] = NULL;

   ssd_widget_add (box, ssd_button_new ("privacy_nickname", "privacy_nickname",
            (const char **) &icon[0], 1, SSD_ALIGN_VCENTER, NULL));
   ssd_widget_set_color (box, NULL, NULL);

   text = ssd_text_new ("Nickname", roadmap_lang_get (
         "Nickname"), SSD_MAIN_TEXT_SIZE, SSD_TEXT_NORMAL_FONT | SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE);
   ssd_text_set_color(text, SSD_CONTAINER_TEXT_COLOR);
   ssd_widget_add (box, text);

   ssd_widget_add (box, ssd_bitmap_new ("On_map_nickname", "On_map_nickname",
            SSD_ALIGN_VCENTER));

   ssd_widget_add (driving, box);
   ssd_widget_add (driving, ssd_separator_new ("separator", SSD_END_ROW));

   //////////////////////////////////////////////////
   // * Anonymous
   //////////////////////////////////////////////////
   box = ssd_container_new ("Anonymous group", NULL, SSD_MAX_SIZE,
                  container_height, SSD_WIDGET_SPACE | SSD_END_ROW | tab_flag);

   if (gState == VisGrp_Anonymous)
      checked = TRUE;
   else
      checked = FALSE;

   CheckboxDriving[i] = ssd_checkbox_new (RT_CFG_PRM_VISGRP_Anonymous, checked,
            SSD_ALIGN_VCENTER | SSD_ALIGN_RIGHT, checkbox_callback, NULL, NULL,
            CHECKBOX_STYLE_V);
   ssd_widget_add (box, CheckboxDriving[i]);
   i++;
   icon[0] = "privacy_anonymous";
   icon[1] = NULL;

   ssd_widget_add (box, ssd_button_new ("privacy_anonymous",
            "privacy_anonymous", (const char **) &icon[0], 1,
            SSD_ALIGN_VCENTER, NULL));

   text = ssd_text_new ("Anonymous text", roadmap_lang_get (
         "Anonymous"), SSD_MAIN_TEXT_SIZE, SSD_TEXT_NORMAL_FONT | SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE);
   ssd_text_set_color(text, SSD_CONTAINER_TEXT_COLOR);
   ssd_widget_add (box, text);
   ssd_widget_add (box, ssd_bitmap_new ("On_map_anonymous", "On_map_anonymous",
            SSD_ALIGN_VCENTER));

   ssd_widget_set_color (box, NULL, NULL);
   ssd_widget_add (driving, box);
   /*
   //////////////////////////////////////////////////
   // * Invisible
   //////////////////////////////////////////////////

   box = ssd_container_new ("Invisible Group", NULL, SSD_MAX_SIZE,
                  container_height, SSD_WIDGET_SPACE | SSD_END_ROW | tab_flag);
   if (gState == VisGrp_Invisible)
      checked = TRUE;
   else
      checked = FALSE;

   CheckboxDriving[i] = ssd_checkbox_new (RT_CFG_PRM_VISGRP_Invisible, checked,
            SSD_ALIGN_VCENTER, checkbox_callback, NULL, NULL,
            CHECKBOX_STYLE_ROUNDED);
   ssd_widget_add (box, CheckboxDriving[i]);
   i++;
   icon[0] = "privacy_invisible";
   icon[1] = NULL;

   ssd_widget_add (box, ssd_button_new ("privacy_invisible",
            "privacy_invisible", (const char **) &icon[0], 1,
            SSD_ALIGN_VCENTER, NULL));
   ssd_widget_add (box, ssd_text_new ("Invisible Text", roadmap_lang_get (
            "Don't show me"), 14, SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE
            | SSD_END_ROW));

   ssd_widget_set_color (box, NULL, NULL);
   ssd_widget_add (driving, box);
*/
   ssd_widget_add (dialog, driving);
/*
   //////////////////////////////////////////////////
   // * Report
   //////////////////////////////////////////////////

   report = ssd_container_new ("Report privacy", NULL, SSD_MIN_SIZE,
            SSD_MIN_SIZE, SSD_START_NEW_ROW | SSD_WIDGET_SPACE | SSD_END_ROW
                     | SSD_ROUNDED_CORNERS | SSD_ROUNDED_WHITE
                     | SSD_POINTER_NONE | SSD_CONTAINER_BORDER);

   box = ssd_container_new ("Reporting Heading group", NULL, SSD_MIN_SIZE,
                  container_height, SSD_WIDGET_SPACE | SSD_END_ROW);
   ssd_widget_add (box, ssd_text_new ("reporting_heading_label",
            roadmap_lang_get ("When reporting"), 14, SSD_TEXT_LABEL
                     | SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE | SSD_END_ROW));

   ssd_widget_add (box, ssd_separator_new ("separator", SSD_ALIGN_BOTTOM));
   ssd_widget_set_color (box, NULL, NULL);
   ssd_widget_add (report, box);

   i = 0;
   //////////////////////////////////////////////////
   // * Report Nickname
   //////////////////////////////////////////////////
   box = ssd_container_new ("Report Nickname Group", NULL, SSD_MIN_SIZE,
                  container_height, SSD_WIDGET_SPACE | SSD_END_ROW | tab_flag);
   if (gReportState == VisRep_NickName)
      checked = TRUE;
   else
      checked = FALSE;

   CheckboxReporting[i] = ssd_checkbox_new (RT_CFG_PRM_VISREP_Nickname,
            checked, SSD_ALIGN_VCENTER, rep_checkbox_callback, NULL, NULL,
            CHECKBOX_STYLE_ROUNDED);
   ssd_widget_add (box, CheckboxReporting[i]);
   i++;

   space = ssd_container_new ("spacer1", NULL, 10, 14, 0);
   ssd_widget_set_color (space, NULL, NULL);
   ssd_widget_add (box, space);

   ssd_widget_add (box, ssd_text_new ("Report Nickname", roadmap_lang_get (
            "Nickname"), 14, SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE
            | SSD_END_ROW));

   ssd_widget_add (box, ssd_separator_new ("separator", SSD_ALIGN_BOTTOM));
   ssd_widget_set_color (box, NULL, NULL);
   ssd_widget_add (report, box);

   //////////////////////////////////////////////////
   // * Report Anonymous
   //////////////////////////////////////////////////
   box = ssd_container_new ("Report Anonymous Group", NULL, SSD_MAX_SIZE,
                  container_height, SSD_WIDGET_SPACE | SSD_END_ROW | tab_flag);
   if (gReportState == VisRep_Anonymous)
      checked = TRUE;
   else
      checked = FALSE;

   CheckboxReporting[i] = ssd_checkbox_new (RT_CFG_PRM_VISREP_Anonymous,
            checked, SSD_ALIGN_VCENTER, rep_checkbox_callback, NULL, NULL,
            CHECKBOX_STYLE_ROUNDED);
   ssd_widget_add (box, CheckboxReporting[i]);
   i++;

   space = ssd_container_new ("spacer1", NULL, 10, 14, 0);
   ssd_widget_set_color (space, NULL, NULL);
   ssd_widget_add (box, space);

   ssd_widget_add (box, ssd_text_new ("Report Anonymous", roadmap_lang_get (
            "Anonymous"), 14, SSD_ALIGN_VCENTER | SSD_WIDGET_SPACE));

   ssd_widget_set_color (box, NULL, NULL);
   ssd_widget_add (report, box);

   ssd_widget_add (dialog, report);
   */
#ifndef TOUCH_SCREEN
   set_softkeys(dialog);
#endif
}
Пример #9
0
void show_alert_dialog(){
   SsdWidget box;
   SsdWidget title;
   SsdWidget bitmap, text;
   char TextStr[200];
   int 	alertId;
   BOOL is_cancelable;
   BOOL can_send_thumbs_up;
   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, on_popup_close, SSD_MAX_SIZE, SSD_MIN_SIZE,NULL, SSD_PERSISTENT|SSD_ROUNDED_BLACK, DIALOG_ANIMATION_FROM_TOP);

   title = ssd_widget_get(dialog, "popuup_text");
   if (title)
      ssd_widget_set_color(title,"#f6a201", "#f6a201");

   box = ssd_container_new ("box", NULL, SSD_MIN_SIZE,SSD_MIN_SIZE,SSD_WIDGET_SPACE);
   if (box){
         ssd_widget_set_color(box, NULL, NULL);
         ssd_widget_add (box, space(1));
   }

   if (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_additional_string != NULL){
      const  char *additional_text = (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->get_additional_string)) (alertId);
      if (additional_text){
         text = ssd_text_new ("AdditionalText", additional_text, 16,SSD_END_ROW);
         ssd_widget_set_color(text, "#ffffff", "#ffffff");
         ssd_widget_add (box, text);
         ssd_widget_add (box, space(1));
      }
   }

   if ((RoadMapAlertProviders.provider[the_active_alert.alert_provider]->show_distance != NULL) && ((*(RoadMapAlertProviders.provider[the_active_alert.alert_provider]->show_distance))(alertId)))
      sprintf(TextStr,"%s %d %s", roadmap_lang_get("In"), (the_active_alert.distance_to_alert/10)*10, roadmap_lang_get(roadmap_math_distance_unit()));

   text = ssd_text_new ("Distance", TextStr, 16,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_ALIGN_VCENTER);
   ssd_widget_set_offset(bitmap, 0, -20);
   ssd_widget_add (box, bitmap);

   is_cancelable = (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->is_cancelable) && (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->is_cancelable)) (alertId);

   can_send_thumbs_up = (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->can_send_thumbs_up) && (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->can_send_thumbs_up)) (alertId);

#ifdef TOUCH_SCREEN
   ssd_widget_add (dialog,
         ssd_button_label ("Close", roadmap_lang_get ("Close"),
            SSD_WS_TABSTOP|SSD_ALIGN_CENTER, alert_dialog_buttons_callback));

   if (can_send_thumbs_up){
      char *icon[3];
      SsdWidget button;
      icon[0] = "thumbs_up_button";
      icon[1] = "thumbs_up_button_down";
      icon[2] = NULL;
      button = ssd_button_new( "ThumbsUp", "Thumbs up", (const char**) &icon[0], 2, SSD_ALIGN_CENTER, alert_dialog_buttons_callback );
      ssd_widget_add(dialog, button);
   }

   if (is_cancelable){
      ssd_widget_add (dialog,
            ssd_button_label ("Irrelevant", roadmap_lang_get ("Not there"),
               SSD_WS_TABSTOP|SSD_ALIGN_CENTER|SSD_END_ROW, alert_dialog_buttons_callback));
   }

   if (can_send_thumbs_up){
      SsdWidget text;
      text = ssd_text_new("ThumbsUpText",roadmap_lang_get("Thanks sent to user"), -1, SSD_ALIGN_CENTER);
      ssd_text_set_color(text, "#f6a201");
      ssd_widget_hide(text);
      ssd_widget_add(dialog, text);
   }

#else
   if (is_cancelable)
      set_softkey();
#endif
   ssd_dialog_activate ("Alert_Dlg", NULL);

   if (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->on_alerter_start != NULL)
      (* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->on_alerter_start))(the_active_alert.active_alert_id);

}