Beispiel #1
0
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;
}
Beispiel #2
0
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;
}
Beispiel #3
0
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);
}
Beispiel #4
0
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;
}
Beispiel #5
0
static void ssd_widget_draw_one (SsdWidget w, int x, int y, int height) {

   RoadMapGuiRect rect;
   SsdSize size;

   ssd_widget_get_size (w, &size, NULL);

   if (w->flags & SSD_ALIGN_VCENTER) {
      y += (height - size.height) / 2;
   }

   w->position.x = x;
   w->position.y = y;


   if (size.width && size.height) {
      rect.minx = x;
      rect.miny = y;
      rect.maxx = x + size.width - 1;
      rect.maxy = y + size.height - 1;

#if 0
      if (!w->parent) printf("****** start draw ******\n");
      printf("draw - %s:%s x=%d-%d y=%d-%d ofset_x=%d ofset_y=%d \n", w->_typeid, w->name, rect.minx, rect.maxx, rect.miny, rect.maxy, w->offset_x, w->offset_y);
#endif
      if (!RecalculateWidgets && ssd_widget_rect_in_screen(&rect))
           w->draw(w, &rect, 0);

      if (w->children) ssd_widget_draw (w->children, &rect, w->flags);
   }
}
Beispiel #6
0
void ssd_widget_container_size (SsdWidget dialog, SsdSize *size) {

   SsdSize max_size;

   /* Calculate size recurisvely */
   if (dialog->parent) {
      ssd_widget_container_size (dialog->parent, size);
      max_size.width = size->width;
      max_size.height = size->height;

   } else {
      max_size.width = roadmap_canvas_width ();
#ifdef TOUCH_SCREEN
      max_size.height = roadmap_canvas_height ();
#else
      max_size.height = roadmap_canvas_height () - roadmap_bar_bottom_height();
#endif
   }

   ssd_widget_get_size (dialog, size, &max_size);

   if (dialog->draw) {
      RoadMapGuiRect rect;
      rect.minx = 0;
      rect.miny = 0;
      rect.maxx = size->width - 1;
      rect.maxy = size->height - 1;

      dialog->draw (dialog, &rect, SSD_GET_SIZE|SSD_GET_CONTAINER_SIZE);

      size->width = rect.maxx - rect.minx + 1;
      size->height = rect.maxy - rect.miny + 1;
   }
}
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();
}
Beispiel #8
0
void roadmap_messagebox (const char *title, const char *text) {

   SsdWidget dialog = ssd_dialog_activate ("message_box", NULL);
   title = roadmap_lang_get (title);
   text  = roadmap_lang_get (text);

   if (!dialog) {
      create_messagebox ();
      dialog = ssd_dialog_activate ("message_box", NULL);
   }

   dialog->set_value (dialog, title);
   ssd_widget_set_value (dialog, "text", text);

	kill_messagebox_timer ();
   ssd_dialog_draw ();
}
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 ();
}
Beispiel #10
0
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();
 }
Beispiel #11
0
static BOOL ssd_container_on_key_pressed( SsdWidget   widget,
                                          const char* utf8char,
                                          uint32_t      flags)
{
   if( KEY_IS_ENTER && widget->callback)
   {
      widget->callback( widget, SSD_BUTTON_SHORT_CLICK);
      return TRUE;
   }

   return FALSE;
}
Beispiel #12
0
/*******************************************************
 * Deallocates the widget node only
 */
static void ssd_widget_free_node( SsdWidget widget )
{
	/*
	 * Release the widget itself
	 */
   if ( widget->release )
   {
	   widget->release( widget );
   }

   free( (char*) widget->name );
   free( widget );
}
Beispiel #13
0
static BOOL OnKeyPressed (SsdWidget widget, const char* utf8char, uint32_t flags){
   BOOL        key_handled = TRUE;

   if( KEY_IS_ENTER)
   {
      widget->callback(widget, SSD_BUTTON_SHORT_CLICK);
      return TRUE;
   }

    if( KEYBOARD_VIRTUAL_KEY & flags)
   {
      switch( *utf8char) {

         case VK_Arrow_up:
               move_up();
            break;

         case VK_Arrow_down:
            move_down();
            break;

         default:
            key_handled = FALSE;
      }

   }
   else
   {
      assert(utf8char);
      assert(*utf8char);

      // Other special keys:
      if( KEYBOARD_ASCII & flags)
      {
         switch(*utf8char)
         {
            case TAB_KEY:
                move_down();
               break;

            default:
               key_handled = FALSE;
         }
      }
   }

   if( key_handled)
      roadmap_screen_redraw ();

   return key_handled;
}
Beispiel #14
0
int ssd_widget_pointer_up_force_click (SsdWidget widget,
                                    const RoadMapGuiPoint *point) {

   int ret_val = 0;
   int movement = ABS_POINTS_DISTANCE( PressedPointerPoint, *point );
   if ( widget->force_click &&
		ssd_widget_contains_point( widget, point, TRUE ) &&
		(  movement < FORCE_CLICK_MOVEMENT_THRESHOLD ) )
   {
	   if ( widget->long_click && roadmap_pointer_long_click_expired() )
	   {
		   ret_val = widget->long_click( widget, point );
	   }
	   else
	   {
		   if ( widget->short_click )
			   ret_val = widget->short_click( widget, point );
	   }
	   widget->force_click = FALSE;
   }
   // TODO :: Check return value
   return 1;
}
Beispiel #15
0
static BOOL ssd_button_on_key_pressed (SsdWidget button, const char* utf8char, uint32_t flags)
{
   struct ssd_button_data *data = (struct ssd_button_data *) button->data;
   if (data->state == BUTTON_STATE_DISABLED)
      return FALSE;

   if( KEY_IS_ENTER )
   {
      button->callback(button, SSD_BUTTON_SHORT_CLICK);

      return TRUE;
   }

   return FALSE;
}
Beispiel #16
0
static void get_size(SsdWidget w, SsdSize * pack_size, RoadMapGuiRect * max_size){
	if (!(w->flags & SSD_VAR_SIZE) && w->children) {
		RoadMapGuiRect container_rect = *max_size;
		int container_width;
		int container_height;

		w->draw (w, max_size, SSD_GET_SIZE);

		container_width  = max_size->minx - container_rect.minx +
				container_rect.maxx - max_size->maxx;
		container_height = max_size->miny - container_rect.miny +
				container_rect.maxy - max_size->maxy;

		calc_pack_size (w->children, max_size, pack_size);

		pack_size->width  += container_width;
		pack_size->height += container_height;

	} else {
		w->draw (w, max_size, SSD_GET_SIZE);
		pack_size->width  = max_size->maxx - max_size->minx + 1;
		pack_size->height = max_size->maxy - max_size->miny + 1;
	}
}
Beispiel #17
0
/*******************************************************
 * Deallocates the widget node only
 */
static void ssd_widget_free_node( SsdWidget widget )
{
	/*
	 * Release the widget itself
	 */
   if ( widget->release )
   {
	   widget->release( widget );
   }

   //int hash = roadmap_hash_string (widget->name);
   //int index = roadmap_hash_get_first (widget_cache, hash);
   //roadmap_hash_remove(widget_cache, hash, index);

   free( (char*) widget->name );
   free( widget );
}
Beispiel #18
0
BOOL ssd_widget_on_key_pressed( SsdWidget w, const char* utf8char, uint32_t flags)
{
   SsdWidget child;

   if(w->key_pressed && w->key_pressed( w, utf8char, flags))
      return TRUE;

   child =  w->children;
   while( child)
   {
      if( ssd_widget_on_key_pressed( child, utf8char, flags))
         return TRUE;

      child = child->next;
   }

   return FALSE;
}
Beispiel #19
0
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;
}
Beispiel #20
0
static BOOL on_key( void* context, const char* utf8char, uint32_t flags)
{
   SsdWidget editbox = ssd_widget_get( s_dialog, s_editbox_name);
   return editbox->key_pressed( editbox, utf8char, flags);
}
Beispiel #21
0
static void draw_dialog (SsdDialog dialog) {

   if (!dialog) {
      return;

   } else {
      RoadMapGuiRect rect;
      rect.minx = 0;
#ifndef TOUCH_SCREEN
      if (is_screen_wide())
         rect.miny = 1;
      else
         rect.miny = roadmap_bar_top_height()+1;
      rect.maxx = roadmap_canvas_width() -1;
#else
      rect.miny = 1;
      rect.maxx = roadmap_canvas_width() -1;
#endif

#ifdef TOUCH_SCREEN
      rect.maxy = roadmap_canvas_height() - 1;
#else
      rect.maxy = roadmap_canvas_height() - 1 - roadmap_bar_bottom_height() ;
#endif

      ssd_widget_reset_cache (dialog->container);
      ssd_widget_draw (dialog->container, &rect, 0);

      if ((dialog->container->flags & SSD_CONTAINER_TITLE) && (dialog->scroll_container != NULL) && (dialog->scroll_container->offset_y < 0)){
         SsdWidget title;
         SsdSize size;
         title = ssd_widget_get (dialog->container, "title_bar");
         ssd_widget_get_size(title, &size, NULL);
#ifndef TOUCH_SCREEN
        if (!is_screen_wide()){
           rect.miny = roadmap_bar_top_height();
        }
        else{
           rect.miny = 0;
        }
#else
        rect.miny = 1;
#endif
        rect.maxy = rect.miny + size.height-1 ;
        title->draw(title, &rect, 0);
        rect.miny +=1;
        ssd_widget_draw(title->children, &rect, 0);
      }


#ifndef TOUCH_SCREEN
      roadmap_bar_draw_bottom_bar(TRUE);
      if ((dialog->container->flags & SSD_CONTAINER_TITLE) && (dialog->scroll_container != NULL) && (dialog->scroll_container->offset_y < 0))
        if (!is_screen_wide())
           roadmap_bar_draw_top_bar(TRUE);
#endif

      ssd_dialog_sort_tab_order( dialog);
      ssd_dialog_sort_tab_order_by_gui_position();
   }
}
Beispiel #22
0
void ssd_widget_get_size (SsdWidget w, SsdSize *size, const SsdSize *max) {

   SsdSize pack_size = {0, 0};

   RoadMapGuiRect max_size = {0, 0, 0, 0};
   int total_height_below = 0;

   *size = w->size;

   if ((w->size.height >= 0) && (w->size.width >= 0)) {
      return;
   }

   if (!max && (w->cached_size.width < 0)) {
       static SsdSize canvas_size;

       canvas_size.width   = roadmap_canvas_width();
#ifdef TOUCH_SCREEN
 	   canvas_size.height  = roadmap_canvas_height() ;
#else
       canvas_size.height  = roadmap_canvas_height() - roadmap_bar_bottom_height();
#endif
       max = &canvas_size;
   }
   else{
   	if (!max)
   		max = &w->cached_size;
   }



   if ((w->cached_size.width >= 0) && (w->cached_size.height >= 0)) {
      *size = w->cached_size;
      return;
   }
   /* Comment by AGA. THere is no assignment for this flag
   if (size->height == SSD_MAX_SIZE) {
      // Check if other siblings exists and should be placed below this one
      SsdWidget below_w = w->next;


      while (below_w) {

         if (below_w->flags & SSD_ORDER_LAST) {
            SsdSize s;
            ssd_widget_get_size (below_w, &s, max);

            total_height_below += s.height;
         }
         below_w = below_w->next;
      }

   }
   */

   if ((w->flags & SSD_DIALOG_FLOAT) && !(w->flags & SSD_DIALOG_TRANSPARENT)){
      if ((size->width == SSD_MAX_SIZE) && ((max->width >= roadmap_canvas_width()) || (max->width >= roadmap_canvas_height()))){
         if (roadmap_canvas_width() > roadmap_canvas_height())
            size->width = roadmap_canvas_height();
         else
            size->width = roadmap_canvas_width()- ADJ_SCALE(20);
#ifdef IPHONE
         size->width = ADJ_SCALE(320);
#endif

      }else
         if (size->width == SSD_MAX_SIZE) size->width = max->width -ADJ_SCALE(20);
      if (size->height== SSD_MAX_SIZE) size->height= max->height - total_height_below;

   } else {

      if (size->width == SSD_MAX_SIZE) size->width = max->width;
      if (size->height== SSD_MAX_SIZE) size->height= max->height - total_height_below;
   }

#ifdef IPHONE_NATIVE
   if (size->width > ADJ_SCALE(320))
      size->width = ADJ_SCALE(320);
#endif //IPHONE

   if ((size->height >= 0) && (size->width >= 0)) {
      w->cached_size = *size;
      return;
   }

   if (size->width >= 0)  {
      max_size.maxx = size->width - 1;
   } else {
      if (!max){
                static SsdSize canvas_size;
                canvas_size.width = roadmap_canvas_width();
#ifdef TOUCH_SCREEN
				canvas_size.height = roadmap_canvas_height();
#else
                canvas_size.height = roadmap_canvas_height() - roadmap_bar_bottom_height();
#endif
                max = &canvas_size;
      }
      max_size.maxx = max->width - 1;
   }

   if (size->height >= 0) {
      max_size.maxy = size->height - 1;
   } else {
      max_size.maxy = max->height - 1;
   }

   if (!(w->flags & SSD_VAR_SIZE) && w->children) {
      RoadMapGuiRect container_rect = max_size;
      int container_width;
      int container_height;

      w->draw (w, &max_size, SSD_GET_SIZE);

      container_width  = max_size.minx - container_rect.minx +
                         container_rect.maxx - max_size.maxx;
      container_height = max_size.miny - container_rect.miny +
                         container_rect.maxy - max_size.maxy;

      calc_pack_size (w->children, &max_size, &pack_size);

      pack_size.width  += container_width;
      pack_size.height += container_height;

   } else {
      w->draw (w, &max_size, SSD_GET_SIZE);
      pack_size.width  = max_size.maxx - max_size.minx + 1;
      pack_size.height = max_size.maxy - max_size.miny + 1;
   }

   if (size->height< 0) size->height = pack_size.height;
   if (size->width < 0) size->width  = pack_size.width;

   w->cached_size = *size;
}
Beispiel #23
0
static BOOL OnKeyPressed( const char* utf8char, uint32_t flags) {
   BOOL        key_handled = TRUE;
   SsdWidget   in_focus    = NULL;

   if( !RoadMapDialogCurrent)
      return FALSE;

   // Let the control handle the key:
   in_focus = RoadMapDialogCurrent->in_focus;
   if( in_focus && ssd_widget_on_key_pressed (in_focus, utf8char, flags)) {
      roadmap_screen_redraw();
      return TRUE;
   }

   // The control did not handle the key...
   //    Supply general handling for virtual keys:
   if( KEYBOARD_VIRTUAL_KEY & flags)
   {
      SsdWidget container = RoadMapDialogCurrent->container;
      switch( *utf8char) {
         case VK_Back:
            ssd_dialog_hide_current(dec_cancel);
            break;

         case VK_Arrow_left:
            if( SSD_TAB_CONTROL & RoadMapDialogCurrent->container->flags)
               if (RoadMapDialogCurrent->scroll_container)
                  ssd_tabcontrol_move_tab_left( RoadMapDialogCurrent->scroll_container);
               else
                  ssd_tabcontrol_move_tab_left( RoadMapDialogCurrent->container);
            else
               ssd_dialog_move_focus(FOCUS_LEFT);
            break;

         case VK_Arrow_up:
            ssd_dialog_move_focus(FOCUS_UP);
            break;

         case VK_Arrow_right:
            if( SSD_TAB_CONTROL & RoadMapDialogCurrent->container->flags)
               if (RoadMapDialogCurrent->scroll_container)
                  ssd_tabcontrol_move_tab_right( RoadMapDialogCurrent->scroll_container);
               else
                  ssd_tabcontrol_move_tab_right( RoadMapDialogCurrent->container);
            else
               ssd_dialog_move_focus( FOCUS_RIGHT);
            break;

         case VK_Arrow_down:
            ssd_dialog_move_focus(FOCUS_DOWN);
            break;

         case VK_Softkey_right:
            if (RoadMapDialogCurrent->scroll_container && (RoadMapDialogCurrent->scroll_container->right_softkey_callback != NULL))
                     RoadMapDialogCurrent->scroll_container->right_softkey_callback(RoadMapDialogCurrent->scroll_container, RoadMapDialogCurrent->scroll_container->name, RoadMapDialogCurrent->scroll_container->context);
            else if (container->right_softkey_callback != NULL)
               container->right_softkey_callback(container, container->name, container->context);
            else
#ifdef TOUCH_SCREEN
               ssd_dialog_hide_current( dec_ok );
#else
               ssd_dialog_hide_current( dec_cancel );
#endif
            break;

         case VK_Softkey_left:
            if (RoadMapDialogCurrent->scroll_container && (RoadMapDialogCurrent->scroll_container->left_softkey_callback != NULL))
                     RoadMapDialogCurrent->scroll_container->left_softkey_callback(RoadMapDialogCurrent->scroll_container, RoadMapDialogCurrent->scroll_container->name, RoadMapDialogCurrent->scroll_container->context);
            else if (container->left_softkey_callback != NULL)
               container->left_softkey_callback(container, container->name, container->context);
            else
               ssd_dialog_hide_all(dec_cancel);
            break;

         default:
            key_handled = FALSE;
      }

   }
   else
   {
      assert(utf8char);
      assert(*utf8char);

      // Other special keys:
      if( KEYBOARD_ASCII & flags)
      {
         switch(*utf8char)
         {
            case ESCAPE_KEY:
               ssd_dialog_hide_current(dec_cancel);
               break;

            case TAB_KEY:
               ssd_dialog_move_focus(FOCUS_FORWARD);
               break;

            default:
               key_handled = FALSE;
         }
      }
   }

   if( key_handled)
      roadmap_screen_redraw ();

   return key_handled;
}