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 BOOL on_kb_closed( int exit_code,
const char* value,
void* context)
{
SsdWidget w = context;
SsdEntryContext* ctx = ( SsdEntryContext* ) w->context;
BOOL retVal = TRUE;
if( dec_ok == exit_code)
{
w->set_value( w, value);
if( value && value[0])
ssd_widget_hide( ssd_widget_get( w, "BgText"));
else
ssd_widget_show( ssd_widget_get( w, "BgText"));
}
if ( ctx->kb_post_done_cb )
{
retVal = ctx->kb_post_done_cb( exit_code, value, context );
}
return retVal;
}
static int set_value (SsdWidget widget, const char *value) {
if ((value != NULL) && (value[0] != 0))
ssd_widget_hide(ssd_widget_get(widget, "BgText"));
else
ssd_widget_show(ssd_widget_get(widget, "BgText"));
return ssd_widget_set_value (widget, "Text", value);
}
static int reminder_add_dlg_buttons_callback (SsdWidget widget, const char *new_value) {
SsdWidget container = widget->parent;
const char *argv[reminder_hi__count];
char temp[15];
if (!strcmp(widget->name, "Save")){
const char *title_txt = ssd_widget_get_value(ssd_widget_get(container, "TitleEntry"),"TitleEntry");
const char *description = ssd_widget_get_value(ssd_widget_get(container, "DescriptionEntry"),"DescriptionEntry");
const char *distance = (const char *)ssd_dialog_get_data("distance");
const char *repeat = (const char *)ssd_dialog_get_data("repeat");
const char *add_reminder = ssd_dialog_get_data("add_reminder");
ssd_dialog_hide_all(dec_close);
argv[reminder_hi_house_number] = strdup(gContext.properties.address);
argv[reminder_hi_street] = strdup(gContext.properties.street);
argv[reminder_hi_city] = strdup(gContext.properties.city);
argv[reminder_state] = ""; //state
sprintf(temp, "%d", gContext.position.latitude);
argv[reminder_hi_latitude] = strdup(temp);
sprintf(temp, "%d", gContext.position.longitude);
argv[reminder_hi_longtitude] = strdup(temp);
argv[reminder_hi_title] = strdup(title_txt);
if (add_reminder && !strcmp( add_reminder, "yes" )){
argv[reminder_hi_add_reminder] = "1";
argv[reminder_hi_distance] = strdup(distance);
argv[reminder_hi_description] = strdup(description);
argv[reminder_hi_repeat] = strdup(repeat);
}
else{
argv[reminder_hi_add_reminder] = "0";
argv[reminder_hi_distance] = strdup("");
argv[reminder_hi_description] = strdup("");
argv[reminder_hi_repeat] = strdup("");
}
roadmap_reminder_add_entry (argv, add_reminder && !strcmp( add_reminder, "yes" ));
free((void *)argv[reminder_hi_house_number]);
free((void *)argv[reminder_hi_street]);
free((void *)argv[reminder_hi_city]);
free((void *)argv[reminder_hi_latitude]);
free((void *)argv[reminder_hi_longtitude]);
free((void *)argv[reminder_hi_distance]);
free((void *)argv[reminder_hi_description]);
free((void *)argv[reminder_hi_repeat]);
}
else{
ssd_dialog_hide_current(dec_close);
}
return 1;
}
const void *ssd_widget_get_data (const SsdWidget widget, const char *name) {
SsdWidget w = ssd_widget_get (widget, name);
if (!w) return NULL;
if (w->get_data) return w->get_data (w);
else return NULL;
}
static void move_down(){
menu_list_data *data;
int i;
//div_t n;
int relative_index;
data = (menu_list_data *) ssd_dialog_get_current_data();
//n = div (data->CurrentIndex, data->num_rows);
relative_index = data->CurrentIndex % data->num_rows;
if (((data->CurrentIndex == data->num_rows -1) || (relative_index == data->num_rows -1) || (data->CurrentIndex == data->num_items -1)) && (data->num_items > data->num_rows)){
int index;
for (i=0; i<data->num_items;i++)
ssd_widget_hide(data->MenuWidgets[i]);
if (data->CurrentIndex == data->num_items -1)
index = 0;
else
index = data->CurrentIndex +1;
for (i=index; i<index+data->num_rows;i++)
if (i < data->num_items)
ssd_widget_show(data->MenuWidgets[i]);
}
if (data->CurrentIndex < data->num_items-1)
data->CurrentIndex++;
else
data->CurrentIndex = 0;
ssd_dialog_resort_tab_order();
ssd_dialog_set_focus(ssd_widget_get(data->MenuWidgets[data->CurrentIndex],"button"));
}
// Draw the warning on the screen
void roadmap_alerter_display(void){
if (alert_should_be_visible) {
if (the_active_alert.active_alert_id == -1){
return;
}
if ((!alert_active) || (prev_alert.active_alert_id != the_active_alert.active_alert_id)){
if (alert_active)
hide_alert_dialog();
kill_timer();
prev_alert.active_alert_id = the_active_alert.active_alert_id;
show_alert_dialog();
if (the_active_alert.alert_type == ALERT)
roadmap_alerter_audio();
alert_active = TRUE;
}
else{
update_alert();
}
} else {
if (alert_active && !alert_should_be_visible) {
if (AlerterTimerCallback == NULL){
SsdWidget text = ssd_widget_get(dialog, "Distance");
ssd_text_set_text(text, " ");
g_seconds = 5;
AlerterTimerCallback = hide_alert_timeout;
roadmap_main_set_periodic (1000, AlerterTimerCallback);
}
}
}
}
void ssd_generic_icon_list_dialog_show(
const char* title,
int count,
const char** labels,
const void** values,
const char** icons,
const int* flags,
PFN_ON_ITEM_SELECTED on_item_selected,
PFN_ON_ITEM_SELECTED on_item_deleted,
void* context,
const char* left_softkey_text,
SsdSoftKeyCallback left_softkey_callback,
int list_height,
int dialog_flags,
BOOL add_next_button)
{
static SsdListContext list_context;
SsdWidget list;
int list_flags = 0;
#if defined (OPENGL)
/*
* Borders are fast in OPENGL
*/
list_flags |= SSD_ALIGN_CENTER|SSD_CONTAINER_BORDER|SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE;
#endif // OPENGL
list_context.on_item_selected= on_item_selected;
list_context.on_item_deleted = on_item_deleted;
list_context.context = context;
list_context.left_softkey_callback = left_softkey_callback;
if ( !ssd_dialog_exists( SSD_GEN_LIST_DLG_NAME ) )
{
GenericList = ssd_dialog_new ( SSD_GEN_LIST_DLG_NAME, "", on_dialog_closed, SSD_CONTAINER_TITLE|dialog_flags);
list = ssd_list_new ("list", SSD_MAX_SIZE, SSD_MAX_SIZE, inputtype_none, 0, NULL);
ssd_widget_add (GenericList, list);
}
else{
GenericList->flags &= ~SSD_HEADER_BLACK;
GenericList->flags |= dialog_flags;
}
ssd_widget_set_offset(GenericList,0,0);
list = ssd_widget_get (GenericList, "list");
GenericList->set_value (GenericList->parent, title);
ssd_widget_set_context (GenericList, &list_context);
ssd_widget_reset_cache (list->parent);
ssd_widget_reset_position(GenericList);
ssd_list_resize ( list, list_height );
ssd_list_populate (list, count, labels, values,icons,flags, list_callback, del_callback, add_next_button);
ssd_widget_set_left_softkey_text(GenericList, left_softkey_text);
if (left_softkey_callback != NULL)
ssd_widget_set_left_softkey_callback(GenericList, list_left_softkey_callback);
ssd_dialog_activate (SSD_GEN_LIST_DLG_NAME, NULL);
ssd_dialog_draw();
}
int ssd_widget_set_data (const SsdWidget widget, const char *name,
const void *value) {
SsdWidget w = ssd_widget_get (widget, name);
if (!w || !w->set_data) return -1;
return w->set_data(w, value);
}
void ssd_confirm_dialog_custom (const char *title, const char *text, BOOL default_yes, ConfirmDialogCallback callback, void *context,const char *textYes, const char *textNo) {
SsdWidget dialog;
confirm_dialog_context *data =
(confirm_dialog_context *)calloc (1, sizeof(*data));
data->default_yes = default_yes;
dialog = ssd_dialog_activate ("confirm_dialog", NULL);
title = roadmap_lang_get (title);
text = roadmap_lang_get (text);
if (!dialog) {
create_confirm_dialog (default_yes,textYes,textNo);
dialog = ssd_dialog_activate ("confirm_dialog", NULL);
}
else{
#ifdef TOUCH_SCREEN
//set button text & softkeys
SsdWidget buttonYes;
SsdWidget buttonNo;
buttonYes = ssd_widget_get(dialog, roadmap_lang_get ("Yes")); // change the buttons to custom text
ssd_button_change_text(buttonYes, textYes);
buttonNo = ssd_widget_get(dialog, roadmap_lang_get ("No"));
ssd_button_change_text(buttonNo, textNo);
#else //Non touch
set_soft_keys(dialog, textYes, textNo); // change softkeys text to custom text
ssd_dialog_refresh_current_softkeys();
#endif
}
if (title[0] == 0){
ssd_widget_hide(ssd_widget_get(dialog, "title_bar"));
}
else{
ssd_widget_show(ssd_widget_get(dialog, "title_bar"));
}
data->callback = callback;
data->context = context;
dialog->set_value (dialog, title);
ssd_widget_set_value (dialog, "text", text);
dialog->context = data;
ssd_dialog_draw ();
}
void navigate_res_show_ETA_widget(SsdWidget container){
SsdWidget ETA_widget;
if (container == NULL)
return;
ETA_widget = ssd_widget_get(container,"eta container");
if (ETA_widget)
ssd_widget_show(ETA_widget);
}
BOOL ssd_dialog_set_dialog_focus( SsdDialog dialog, SsdWidget new_focus)
{
SsdWidget last_focus;
SsdWidget w;
if( new_focus && !new_focus->tab_stop)
{
//assert( 0 && "ssd_dialog_set_dialog_focus() - Invalid input");
return FALSE;
}
w = ssd_widget_get(new_focus,"focus_image");
if( w != NULL)
ssd_widget_show( w->children);
// Setting the same one twice...
if( dialog->in_focus == new_focus){
if (new_focus && !new_focus->in_focus)
ssd_widget_set_focus(new_focus);
return TRUE;
}
if( new_focus && (dialog != new_focus->parent_dialog))
{
/*/[BOOKMARK]:[NOTE]:[PAZ] - If 'new_focus->parent_dialog' is NULL:
Maybe 'ssd_dialog_sort_tab_order()' was called before 'ssd_dialog_draw'?
Note that 'ssd_dialog_draw' will call 'ssd_dialog_sort_tab_order()',
thus no need to call it directly. */
assert( 0 && "ssd_dialog_set_dialog_focus() - widget does not belong to this dialog");
return FALSE;
}
last_focus = dialog->in_focus;
if (dialog->in_focus)
{
ssd_widget_loose_focus(dialog->in_focus);
dialog->in_focus = NULL;
}
if( !new_focus)
return TRUE;
if( !ssd_widget_set_focus(new_focus))
{
assert(0);
if( ssd_widget_set_focus( last_focus))
dialog->in_focus = last_focus;
return FALSE;
}
dialog->in_focus = new_focus;
ssd_dialog_allign_focus();
return TRUE;
}
const char *ssd_widget_get_value (const SsdWidget widget, const char *name) {
SsdWidget w = widget;
if (name) w = ssd_widget_get (w, name);
if (!w) return "";
if (w->get_value) return w->get_value (w);
return w->value;
}
void ssd_generic_list_dialog_show(const char* title,
int count,
const char** labels,
const void** values,
PFN_ON_ITEM_SELECTED on_item_selected,
PFN_ON_ITEM_SELECTED on_item_deleted,
void* context,
int list_height )
{
static SsdListContext list_context;
SsdWidget list;
int flags = 0;
#if defined (OPENGL)
/*
* Borders are fast in OPENGL
*/
flags |= SSD_ALIGN_CENTER|SSD_CONTAINER_BORDER|SSD_ROUNDED_CORNERS|SSD_ROUNDED_WHITE;
#endif // OPENGL
list_context.on_item_selected= on_item_selected;
list_context.on_item_deleted = on_item_deleted;
list_context.context = context;
list_context.left_softkey_callback = NULL;
if (!GenericList)
{
GenericList = ssd_dialog_new ( SSD_GEN_LIST_DLG_NAME, "", on_dialog_closed,
SSD_CONTAINER_TITLE);
ssd_dialog_add_vspace (GenericList, 5, 0);
list = ssd_list_new ("list", ssd_container_get_width(), SSD_MAX_SIZE, inputtype_none, flags, NULL);
ssd_widget_add (GenericList, list);
}
list = ssd_widget_get (GenericList, "list");
ssd_widget_set_offset(GenericList,0,0);
ssd_widget_set_left_softkey_text(GenericList, roadmap_lang_get("Exit_key"));
ssd_widget_set_left_softkey_callback(GenericList, NULL);
GenericList->set_value (GenericList->parent, title);
ssd_widget_set_context (GenericList, &list_context);
ssd_widget_reset_cache (list->parent);
ssd_widget_reset_position(GenericList);
ssd_list_resize ( list, list_height );
ssd_list_populate (list, count, labels, values, NULL, NULL, list_callback, del_callback, FALSE);
ssd_dialog_activate ( SSD_GEN_LIST_DLG_NAME, NULL );
ssd_dialog_draw();
}
static int get_selected_list_item()
{
SsdWidget list;
SsdWidget dlg;
if( generic_search_dlg_is_1st(search_address))
return -1;
dlg = generic_search_dlg_get_search_dlg(search_address);
list = ssd_widget_get( dlg, ASD_RC_LIST_NAME);
assert(list);
return (int)ssd_list_selected_value( list);
}
void ssd_dialog_allign_focus(void){
SsdSize size;
int height;
int min;
SsdWidget title;
title = ssd_widget_get (RoadMapDialogCurrent->container, "title_bar");
if (title)
min = title->cached_size.height;
else
min = 0;
#ifndef TOUCH_SCREEN
if (!is_screen_wide())
min += roadmap_bar_top_height();
if( SSD_TAB_CONTROL & RoadMapDialogCurrent->container->flags)
min += ssd_tabcontrol_get_height();
#endif
#ifdef TOUCH_SCREEN
height = roadmap_canvas_height();
#else
height = roadmap_canvas_height() - roadmap_bar_bottom_height();
#endif
if (RoadMapDialogCurrent->in_focus && RoadMapDialogCurrent->scroll_container){
if ((RoadMapDialogCurrent->in_focus->position.y == -1) || (RoadMapDialogCurrent->in_focus->position.x == -1 )){
RoadMapDialogCurrent->in_focus->position.y = 0;
RoadMapDialogCurrent->scroll_container->offset_y +=20;
}
ssd_widget_get_size(RoadMapDialogCurrent->in_focus, &size, NULL);
if (( RoadMapDialogCurrent->in_focus->position.y == 0) || ((size.height + RoadMapDialogCurrent->in_focus->position.y) > height)){
while (( RoadMapDialogCurrent->in_focus->position.y == 0) || ((size.height + RoadMapDialogCurrent->in_focus->position.y) > height)) {
ssd_widget_set_offset(RoadMapDialogCurrent->scroll_container, 0, RoadMapDialogCurrent->scroll_container->offset_y-20);
ssd_dialog_draw();
}
while (RoadMapDialogCurrent->in_focus->position.y < min){
ssd_widget_set_offset(RoadMapDialogCurrent->scroll_container, 0, RoadMapDialogCurrent->scroll_container->offset_y+20);
ssd_dialog_draw();
}
}
else{
while (RoadMapDialogCurrent->in_focus->position.y < min){
ssd_widget_set_offset(RoadMapDialogCurrent->scroll_container, 0, RoadMapDialogCurrent->scroll_container->offset_y+20);
ssd_dialog_draw();
}
}
}
}
void 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);
}
}
static void move_up(){
menu_list_data *data;
int i;
int n_quot;
int relative_index;
data = (menu_list_data *) ssd_dialog_get_current_data();
n_quot = data->CurrentIndex / data->num_rows;
relative_index = data->CurrentIndex % data->num_rows;
if (((data->CurrentIndex == 0) || (relative_index == 0) || (data->CurrentIndex == data->num_rows )) && (data->num_items > data->num_rows)){
int index;
for (i=0; i<data->num_items;i++)
ssd_widget_hide(data->MenuWidgets[i]);
if (relative_index == 0)
if (n_quot == 0){
//div_t n2;
int n2_rem = data->num_items % data->num_rows;
int n2_quot = data->num_items / data->num_rows;
if (n2_rem == 0)
index = (n2_quot -1) * data->num_rows;
else
index = n2_quot * data->num_rows ;
}
else
index = (n_quot -1) * data->num_rows;
else
index =0;
for (i=index; i<index+data->num_rows;i++)
if (i < data->num_items)
ssd_widget_show(data->MenuWidgets[i]);
}
if (data->CurrentIndex > 0)
data->CurrentIndex--;
else
data->CurrentIndex = data->num_items -1;
ssd_dialog_resort_tab_order();
ssd_dialog_set_focus(ssd_widget_get(data->MenuWidgets[data->CurrentIndex],"button"));
}
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 edit_callback (SsdWidget widget, const char *new_value) {
const char *value;
SsdEntryContext* ctx;
/* Get the entry widget */
widget = widget->parent;
ctx = ( SsdEntryContext* ) widget->context;
value = widget->get_value (widget);
#if ((defined(__SYMBIAN32__) && !defined(TOUCH_SCREEN)) || defined(IPHONE) || defined( ANDROID ))
{
SsdWidget text = ssd_widget_get(widget->children, "Text");
if ( text && (text->flags & SSD_TEXT_PASSWORD) )
{
if (!ctx->editbox_title)
ShowEditbox( ctx->kb_title, value, on_kb_closed, widget, EEditBoxPassword );
else
ShowEditbox( ctx->editbox_title, value, on_kb_closed, widget, EEditBoxPassword );
}
else
{
if (!ctx->editbox_title)
ShowEditbox( ctx->kb_title, value, on_kb_closed, widget, EEditBoxStandard );
else
ShowEditbox( ctx->editbox_title, value, on_kb_closed, widget, EEditBoxStandard );
}
}
#else
ssd_show_keyboard_dialog_ext( ctx->editbox_title ? ctx->editbox_title : ctx->kb_title,
value,
ctx->kb_label,
ctx->kb_note,
on_kb_closed,
widget,
ctx->kb_flags );
#endif
return 1;
}
// Get child by ID (name)
// Can return child child...
SsdWidget ssd_widget_get (SsdWidget child, const char *name) {
if (!name) return child;
while (child != NULL) {
if (0 == strcmp (child->name, name)) {
return child;
}
if (child->children != NULL) {
SsdWidget w = ssd_widget_get (child->children, name);
if (w) return w;
}
child = child->next;
}
return NULL;
}
/***********************************************************
* Name : ssd_progress_msg_dialog_show
*
* Purpose : Shows the dialog with the given name. Creates the new one if not exists
*
* Params : [in] dlg_text - the text to be displayed in message
* :
* :
* Returns : void
*/
void ssd_progress_msg_dialog_show( const char* dlg_text )
{
if ( !gProgressMsgDlg )
{
// Create the dialog. Return in case of failure
if ( !( gProgressMsgDlg = ssd_progress_msg_dialog_new() ) )
return;
}
#ifdef TOUCH_SCREEN
ssd_widget_show(ssd_widget_get(gProgressMsgDlg, "Hide Button" ));
#endif
ssd_dialog_activate( SSD_PROGRESS_MSG_DLG_NAME, NULL );
ssd_dialog_set_value( SSD_PROGRESS_MSG_TEXT_FLD, dlg_text );
ssd_dialog_draw();
}
static int alert_dialog_buttons_callback (SsdWidget widget, const char *new_value) {
if (!strcmp(widget->name, "Irrelevant")){
hide_alert_dialog();
report_irrelevant(NULL, NULL, NULL);
}
else if (!strcmp(widget->name, "Close")){
hide_alert_dialog();
}
else if (!strcmp(widget->name, "ThumbsUp")){
SsdWidget text;
text = ssd_widget_get(widget->parent, "ThumbsUpText");
if (text)
ssd_widget_show(text);
(* (RoadMapAlertProviders.provider[the_active_alert.alert_provider]->thumbs_up))(the_active_alert.active_alert_id);
ssd_widget_hide(widget);
}
return 1;
}
static void move_to_start(){
menu_list_data *data;
int i;
int num_items;
data = (menu_list_data *) ssd_dialog_get_current_data();
for (i=0; i<data->num_items;i++)
ssd_widget_hide(data->MenuWidgets[i]);
if (data->num_items < data->num_rows)
num_items = data->num_items;
else
num_items = data->num_rows;
for (i=0; i<num_items;i++)
ssd_widget_show(data->MenuWidgets[i]);
ssd_dialog_resort_tab_order();
ssd_dialog_set_focus(ssd_widget_get(data->MenuWidgets[0],"button"));
data->CurrentIndex = 0;
}
// Get child by ID (name)
// Can return child child...
SsdWidget ssd_widget_get (SsdWidget child, const char *name) {
int index, hash;
if (!name) return child;
// hash = roadmap_hash_string (name);
// index = roadmap_hash_get_first (widget_cache, hash);
// if (index >= 0)
// {
////roadmap_log(ROADMAP_ERROR,"mt - found widget %s", name);
// return roadmap_hash_get_value(widget_cache, index);
// }
// else
// {
//roadmap_log(ROADMAP_ERROR,"mt - did not find widget %s", name);
// return NULL;
// }
while (child != NULL) {
if (0 == strcmp (child->name, name)) {
return child;
}
if (child->children != NULL) {
SsdWidget w = ssd_widget_get (child->children, name);
if (w) return w;
}
child = child->next;
}
return NULL;
}
int on_checkbox_selected (SsdWidget widget, const char *new_value){
SsdWidget container = widget->parent->parent;
const char *add_reminder = ssd_dialog_get_data("add_reminder");
if (!container)
return 0;
if (!strcmp( add_reminder, "no" )){
ssd_widget_hide(ssd_widget_get(container,"DescriptionEntry"));
ssd_widget_hide(ssd_widget_get(container,"Repeat"));
ssd_widget_hide(ssd_widget_get(container,"Distance"));
}
else{
ssd_widget_show(ssd_widget_get(container,"DescriptionEntry"));
ssd_widget_show(ssd_widget_get(container,"Repeat"));
ssd_widget_show(ssd_widget_get(container,"Distance"));
}
ssd_dialog_draw();
return 1;
}
static void create_confirm_dialog (BOOL default_yes, const char * textYes, const char *textNo) {
SsdWidget text;
SsdWidget dialog,widget_title;
SsdWidget text_con;
SsdSize dlg_size;
// const char *question_icon[] = {"question"};
#ifndef TOUCH_SCREEN
int yes_flags = 0;
int no_flags = 0;
if(default_yes)
yes_flags|= SSD_WS_DEFWIDGET;
else
no_flags |= SSD_WS_DEFWIDGET;
#endif
dialog = ssd_dialog_new ("confirm_dialog", "", NULL,
SSD_CONTAINER_BORDER|SSD_DIALOG_FLOAT|
SSD_ALIGN_CENTER|SSD_CONTAINER_TITLE|SSD_ALIGN_VCENTER|SSD_ROUNDED_CORNERS|SSD_POINTER_NONE);
ssd_widget_set_color (dialog, "#000000", "#ff0000000");
ssd_widget_get_size( dialog, &dlg_size, NULL );
/* Spacer */
ssd_widget_add (dialog,
ssd_container_new ("spacer1", NULL, 0, 15, SSD_END_ROW));
/*
image_container = ssd_container_new ("image_container", NULL,
SSD_MIN_SIZE,
SSD_MIN_SIZE,
SSD_ALIGN_RIGHT);
ssd_widget_set_color (image_container, "#000000", "#ff0000000");
ssd_widget_add (image_container,
ssd_button_new ("question", "question", question_icon , 1,
SSD_ALIGN_CENTER|SSD_ALIGN_VCENTER ,
NULL));
// Image container
ssd_widget_add (dialog,image_container);
*/
text_con = ssd_container_new ("text_container", NULL,
( dlg_size.width * 9 )/10, /* 90% of dialog width */
SSD_MIN_SIZE,
SSD_END_ROW|SSD_ALIGN_CENTER );
ssd_widget_set_color (text_con, "#000000", "#ff0000000");
// Text box
text = ssd_text_new ("text", "", 16, SSD_END_ROW|SSD_WIDGET_SPACE);
ssd_widget_add (text_con,text);
ssd_widget_add(dialog, text_con);
widget_title = ssd_widget_get( dialog, "title_text" );
ssd_text_set_font_size( widget_title, 20 );
#ifdef TOUCH_SCREEN
ssd_dialog_add_vspace( dialog, 10, SSD_START_NEW_ROW );
ssd_widget_add (dialog,
ssd_button_label (roadmap_lang_get ("Yes"), textYes,
SSD_ALIGN_CENTER| SSD_WS_TABSTOP,
yes_button_callback));
ssd_widget_add (dialog,
ssd_button_label (roadmap_lang_get ("No"), textNo,
SSD_ALIGN_CENTER| SSD_WS_TABSTOP,
no_button_callback));
#else
set_soft_keys(dialog, textYes, textNo);
#endif
ssd_widget_add (dialog,
ssd_container_new ("spacer2", NULL, 0, 10, SSD_START_NEW_ROW|SSD_WIDGET_SPACE));
}
static void draw (SsdWidget widget, RoadMapGuiRect *rect, int flags) {
RoadMapGuiPoint points[5];
int count = 5;
#ifdef OPENGL
RoadMapGuiPoint position;
RoadMapGuiPoint sign_bottom, sign_top;
static RoadMapImage focus_image;
#endif
const char* background = widget->bg_color;
if (!(flags & SSD_GET_SIZE)) {
if (widget->in_focus && widget->focus_highlight )
background = "#b0d504";
else if (widget->background_focus)
background = "#8a8a8a";
if (background) {
if (widget->flags & SSD_ROUNDED_CORNERS){
RoadMapGuiRect erase_rect;
erase_rect.minx = rect->minx + SSD_ROUNDED_CORNER_WIDTH;
erase_rect.miny = rect->miny + SSD_ROUNDED_CORNER_HEIGHT;
erase_rect.maxx = rect->maxx - SSD_ROUNDED_CORNER_WIDTH;
erase_rect.maxy = rect->maxy - SSD_ROUNDED_CORNER_HEIGHT;
roadmap_canvas_select_pen (bg);
roadmap_canvas_set_foreground (background);
//roadmap_canvas_erase_area (&erase_rect);
}
else{
if (!(widget->flags & SSD_DIALOG_TRANSPARENT)){
roadmap_canvas_select_pen (bg);
roadmap_canvas_set_foreground (background);
if ((widget->flags & SSD_CONTAINER_TXT_BOX) || (widget->flags & SSD_CONTAINER_SEARCH_BOX)){
rect->minx += 10;
rect->maxx -= 10;
}
else
roadmap_canvas_erase_area (rect);
#if defined(OPENGL) && !defined(_WIN32)
if (widget->in_focus && widget->focus_highlight ){
if (!focus_image)
focus_image = roadmap_res_get( RES_BITMAP, RES_SKIN, "focus" );
if (focus_image){
sign_top.x = rect->minx;
sign_top.y = rect->miny;
position.x = roadmap_canvas_image_width(focus_image)/2;
position.y = roadmap_canvas_image_height(focus_image) / 2;
sign_bottom.x = rect->maxx;
sign_bottom.y = rect->maxy;
roadmap_canvas_draw_image_stretch( focus_image, &sign_top, &sign_bottom, &position, 0, IMAGE_NORMAL );
}
}
#endif
}
}
}
if ((widget->flags & SSD_SHADOW_BG) )
{
draw_shadow_bg();
}
if ((widget->flags & SSD_CONTAINER_TITLE) &&
!(widget->flags & SSD_DIALOG_FLOAT) &&
!(widget->flags & SSD_DIALOG_TRANSPARENT) )
{
draw_bg(rect);
}
}
if (widget->flags & SSD_CONTAINER_BORDER) {
points[0].x = rect->minx + 1;
#ifndef TOUCH_SCREEN
points[0].y = rect->miny + 1;
points[1].y = rect->miny + 1;
points[4].y = rect->miny + 1;
#else
points[0].y = rect->miny;
points[1].y = rect->miny;
points[4].y = rect->miny ;
#endif
points[1].x = rect->maxx - 0;
points[2].x = rect->maxx - 0;
points[2].y = rect->maxy - 0;
points[3].x = rect->minx + 1;
points[3].y = rect->maxy - 0;
points[4].x = rect->minx + 1;
if (!(flags & SSD_GET_SIZE)) {
const char *color = default_fg;
RoadMapPosition *position = NULL;
roadmap_canvas_select_pen (border);
if (widget->fg_color) color = widget->fg_color;
roadmap_canvas_set_foreground (color);
if (widget->flags & SSD_ROUNDED_CORNERS){
int pointer_type = POINTER_NONE;
int header_type = HEADER_NONE;
int style = STYLE_NORMAL;
int position_offset = widget->offset_y;
#ifdef TOUCH_SCREEN
widget->flags &= ~SSD_POINTER_MENU;
#endif
if (widget->flags & SSD_POINTER_MENU){
pointer_type = POINTER_MENU;
#ifndef OPENGL
points[2].y -= 17;
#endif
}
else if (widget->flags & SSD_POINTER_COMMENT){
pointer_type = POINTER_COMMENT;
#ifdef OPENGL
points[2].y += 20; /* The height of the pointer */
#else
points[2].y -= 7;
#endif
}
else if (widget->flags & SSD_POINTER_NONE){
pointer_type = POINTER_NONE;
if (!((widget->flags & SSD_ROUNDED_WHITE) || (widget->flags & SSD_ROUNDED_BLACK)))
points[2].y -= 10;
}
if (widget->in_focus && widget->focus_highlight )
background = "#b0d504";
else if ((widget->flags & SSD_POINTER_COMMENT) | (widget->flags & SSD_POINTER_MENU) | (widget->flags & SSD_POINTER_NONE))
background = "#e4f1f9";
else
background = "#f3f3f5";
background = "#d2dfef";
header_type = HEADER_NONE;
if (widget->flags & SSD_ROUNDED_WHITE){
style = STYLE_WHITE;
if (widget->in_focus && widget->focus_highlight )
background = "#b0d504";
else
background = "#ffffff";
}
if (widget->flags & SSD_ROUNDED_BLACK){
style = STYLE_BLACK;
if (widget->in_focus && widget->focus_highlight )
background = "#b0d504";
else
background = "#000000";
}
if (widget->flags & SSD_POINTER_LOCATION){
if (widget->context != NULL){
pointer_type = POINTER_POSITION;
position = (RoadMapPosition *)widget->context;
//position_offset = ADJ_SCALE(-40);
}
}
if (widget->flags & SSD_POINTER_FIXED_LOCATION){
if (widget->context != NULL){
pointer_type = POINTER_FIXED_POSITION;
position = (RoadMapPosition *)widget->context;
}
}
roadmap_display_border(style, header_type, pointer_type, &points[2], &points[0], background, position, position_offset);
}
else
roadmap_canvas_draw_multiple_lines (1, &count, points, 1);
}
if (widget->flags & SSD_ROUNDED_CORNERS){
if (widget->flags & SSD_ROUNDED_WHITE){
rect->minx += 4;
rect->miny += 4;
rect->maxx -= 4;
rect->maxy -= 4;
}
else{
rect->minx += 10;
if ((widget->flags & SSD_CONTAINER_TITLE) || (widget->flags & SSD_POINTER_MENU) || (widget->flags & SSD_POINTER_NONE))
rect->miny += 10;
else
rect->miny += 4;
rect->maxx -= 10;
rect->maxy -= 10;
}
}
else{
rect->minx += 2;
rect->miny += 2;
rect->maxx -= 2;
rect->maxy -= 2;
}
}
if (widget->flags & SSD_CONTAINER_TXT_BOX){
if (!(flags & SSD_GET_SIZE)){
if (background){
rect->minx -= 10;
rect->maxx += 10;
}
draw_text_box(widget, rect);
}
rect->minx += 20;
rect->miny += 10;
rect->maxx -= 20;
rect->maxy -= 10;
}
if (widget->flags & SSD_CONTAINER_SEARCH_BOX){
if (!(flags & SSD_GET_SIZE)){
if (background){
rect->minx -= 10;
rect->maxx += 10;
}
draw_search_box(widget, rect);
}
rect->minx += 20;
rect->miny += 10;
rect->maxx -= 20;
rect->maxy -= 10;
}
if (widget->flags & SSD_CONTAINER_TITLE){
ssd_widget_set_left_softkey_text(widget, widget->left_softkey);
ssd_widget_set_right_softkey_text(widget, widget->right_softkey);
}
if ((flags & SSD_GET_CONTAINER_SIZE) &&
(widget->flags & SSD_CONTAINER_TITLE)) {
SsdWidget title;
title = ssd_widget_get (widget, "title_bar");
if (title) {
SsdSize title_size;
SsdSize max_size;
max_size.width = rect->maxx - rect->minx + 1;
max_size.height = rect->maxy - rect->miny + 1;
ssd_widget_get_size (title, &title_size, &max_size);
rect->miny += title_size.height;
}
}
}
static void on_address_resolved( void* context,
address_candidate* array,
int size,
roadmap_result rc)
{
static const char* results[ADSR_MAX_RESULTS+1];
static void* indexes[ADSR_MAX_RESULTS+1];
static const char* icons[ADSR_MAX_RESULTS+1];
SsdWidget list_cont = (SsdWidget)context;
SsdWidget list;
int i;
s_searching = FALSE;
/* Close the progress message */
ssd_progress_msg_dialog_hide();
roadmap_main_set_cursor( ROADMAP_CURSOR_NORMAL);
assert(list_cont);
list = ssd_widget_get( list_cont, ASD_RC_LIST_NAME);
if( succeeded != rc)
{
if( is_network_error( rc))
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Search requires internet connection.\r\nPlease make sure you are connected."), on_search_error_message );
else if( err_as_could_not_find_matches == rc)
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Sorry, no results were found for this search"), on_search_error_message );
else
{
char msg[128];
snprintf( msg, sizeof(msg), "%s\n%s",roadmap_lang_get("Sorry we were unable to complete the search"), roadmap_lang_get("Please try again later"));
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"), msg, on_search_error_message );
}
roadmap_log(ROADMAP_ERROR,
"address_search_dlg::on_address_resolved() - Resolve process failed with error '%s' (%d)",
roadmap_result_string( rc), rc);
return;
}
if( !size)
{
roadmap_log(ROADMAP_DEBUG,
"address_search_dlg::on_address_resolved() - NO RESULTS for the address-resolve process");
return;
}
assert( size <= ADSR_MAX_RESULTS);
if (size == 1 && s_auto_start_nav) {
s_auto_start_nav = FALSE;
generic_search_dlg_switch_gui();
ssd_dialog_hide_all( dec_close);
navigate(1);
return;
}
for( i=0; i<size; i++)
{
results[i] = array[i].address;
indexes[i] = (void*)i;
icons[i] = "search_address";
}
results[i] = roadmap_lang_get(COULDNT_FIND_ADDRESS_TEXT);
indexes[i] = (void*)COULDNT_FIND_INDEX;
icons[i] = "submit_logs";
if ( roadmap_native_keyboard_enabled() )
{
roadmap_native_keyboard_hide();
}
ssd_list_populate(list,
size+1,
results,
(const void **)indexes,
icons,
0,
on_list_item_selected,
NULL,
FALSE);
generic_search_dlg_switch_gui();
}
static void on_address_resolved( void* context,
address_candidate* array,
int size,
roadmap_result rc)
{
static const char* results[ADSR_MAX_RESULTS+1];
static void* indexes[ADSR_MAX_RESULTS+1];
static const char* icons[ADSR_MAX_RESULTS+1];
const char* provider_icon = NULL;
SsdWidget list_cont = (SsdWidget)context;
SsdWidget list;
SsdWidget bmp_logo = NULL;
int i;
s_searching = FALSE;
/* Close the progress message */
ssd_progress_msg_dialog_hide();
roadmap_main_set_cursor( ROADMAP_CURSOR_NORMAL);
assert(list_cont);
list = ssd_widget_get( list_cont, LSD_RC_LIST_NAME);
if( succeeded != rc)
{
if( is_network_error( rc))
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Search requires internet connection.\r\n"
"Please make sure you are connected."), on_search_error_message );
else if( err_as_could_not_find_matches == rc)
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Sorry, no results were found for this search"), on_search_error_message );
else
{
char msg[128];
snprintf( msg, sizeof(msg), "%s\n%s",roadmap_lang_get("Sorry we were unable to complete the search"), roadmap_lang_get("Please try again later"));
roadmap_messagebox_cb ( roadmap_lang_get( "Search location"), msg, on_search_error_message );
}
roadmap_log(ROADMAP_ERROR,
"local_search_dlg::on_address_resolved() - Resolve process failed with error '%s' (%d)",
roadmap_result_string( rc), rc);
return;
}
if( !size)
{
roadmap_log(ROADMAP_DEBUG,
"local_search_dlg::on_address_resolved() - NO RESULTS for the address-resolve process");
return;
}
assert( size <= ADSR_MAX_RESULTS);
provider_icon = local_search_get_icon_name();
for( i=0; i<size; i++)
{
results[i] = array[i].address;
indexes[i] = (void*)i;
icons[i] = provider_icon;
}
if ( roadmap_native_keyboard_enabled() )
{
roadmap_native_keyboard_hide();
}
/*
* Update the results container logo
* dynamically according to the current provider
*/
bmp_logo = ssd_widget_get( s_result_container, "local search icon" );
ssd_bitmap_update( bmp_logo, local_search_get_logo_name() );
ssd_list_populate(list,
size,
results,
(const void **)indexes,
icons,
0,
on_list_item_selected,
NULL,
FALSE);
generic_search_dlg_switch_gui();
}
