Convert the Display menu to the new system.

http://forums.rockbox.org/index.php?topic=8703.0 for bugs...


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@12351 a1c6a512-1295-4272-9138-f99709370657

apps/SOURCES

@@ -29,7 +29,6 @@ plugin.c
 screens.c
 settings.c
 settings_list.c
-settings_menu.c
 sound_menu.c
 status.c
 cuesheet.c

apps/menu.c

@@ -560,6 +560,7 @@ int do_menu(const struct menu_item_ex *start_menu)
                         if ((setting->flags&F_BOOL_SETTING) == F_BOOL_SETTING)
                         {
                             bool temp_var, *var;
+                            bool show_icons = global_settings.show_icons;
                             if (setting->flags&F_TEMPVAR)
                             {
                                 temp_var = *(bool*)setting->setting;
@@ -575,6 +576,8 @@ int do_menu(const struct menu_item_ex *start_menu)
                                         setting->bool_setting->option_callback);
                             if (setting->flags&F_TEMPVAR)
                                 *(bool*)setting->setting = temp_var;
+                            if (show_icons != global_settings.show_icons)
+                                init_menu_lists(menu, &lists, 0, true);
                         }
                         else if (setting->flags&F_T_SOUND)
                         {

apps/menus/display_menu.c

@@ -1,4 +1,3 @@
-
 /***************************************************************************
  *             __________               __   ___.
  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
@@ -27,7 +26,537 @@
 #include "settings.h"
 #include "menu.h"
 #include "settings_menu.h"
+#include "tree.h"
+#include "list.h"
+#ifdef HAVE_LCD_BITMAP
+#include "backdrop.h"
+#include "peakmeter.h"
+#endif
+#include "talk.h"
+#include "color_picker.h"
+#include "lcd.h"
+#include "lcd-remote.h"
 
-bool display_settings_menu(void); /* from ../settings_menu.c */
+
-MENUITEM_FUNCTION(display_menu,ID2P(LANG_DISPLAY),
+#ifdef CONFIG_BACKLIGHT
-    (menu_function)display_settings_menu,NULL, bitmap_icons_6x8[Icon_Display_menu]);
+int filterfirstkeypress_callback(int action,const struct menu_item_ex *this_item)
+{
+    (void)this_item;
+    switch (action)
+    {
+        case ACTION_EXIT_MENUITEM:
+            set_backlight_filter_keypress(global_settings.bl_filter_first_keypress);
+#ifdef HAVE_REMOTE_LCD
+            set_remote_backlight_filter_keypress(
+                                global_settings.remote_bl_filter_first_keypress);
+#endif
+        
+            break;
+    }
+    return action;
+}
+#endif
+#ifdef HAVE_LCD_BITMAP
+int flipdisplay_callback(int action,const struct menu_item_ex *this_item)
+{
+    (void)this_item;
+    switch (action)
+    {
+        case ACTION_EXIT_MENUITEM:
+            button_set_flip(global_settings.flip_display);
+            lcd_set_flip(global_settings.flip_display);
+#ifdef HAVE_REMOTE_LCD
+            lcd_remote_set_flip(global_settings.remote_flip_display);
+            lcd_remote_update();
+#endif
+            break;
+    }
+    return action;
+}
+#endif
+
+/***********************************/
+/*    LCD MENU                     */
+#ifdef CONFIG_BACKLIGHT
+MENUITEM_SETTING(backlight_timeout, &global_settings.backlight_timeout, NULL);
+#ifdef CONFIG_CHARGING
+MENUITEM_SETTING(backlight_timeout_plugged, 
+                &global_settings.backlight_timeout_plugged, NULL);
+#endif
+#ifdef HAS_BUTTON_HOLD
+MENUITEM_SETTING(backlight_on_button_hold, 
+                &global_settings.backlight_on_button_hold, NULL);
+#endif
+MENUITEM_SETTING(caption_backlight, &global_settings.caption_backlight, NULL);
+#if defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR)
+MENUITEM_SETTING(backlight_fade_in, &global_settings.backlight_fade_in, NULL);
+MENUITEM_SETTING(backlight_fade_out, &global_settings.backlight_fade_out, NULL);
+#endif
+MENUITEM_SETTING(bl_filter_first_keypress, 
+                    &global_settings.bl_filter_first_keypress, 
+                    filterfirstkeypress_callback);
+#ifdef HAVE_LCD_SLEEP
+MENUITEM_SETTING(lcd_sleep_after_backlight_off,
+                &global_settings.lcd_sleep_after_backlight_off, NULL);
+#endif
+#ifdef HAVE_BACKLIGHT_BRIGHTNESS
+MENUITEM_SETTING(brightness_item, &global_settings.brightness, NULL);
+#endif
+#endif /* CONFIG_BACKLIGHT */
+#ifdef HAVE_LCD_CONTRAST
+MENUITEM_SETTING(contrast, &global_settings.contrast, NULL);
+#endif
+#ifdef HAVE_LCD_BITMAP
+#ifdef HAVE_LCD_INVERT
+MENUITEM_SETTING(invert, &global_settings.invert, NULL);
+#endif
+#ifdef HAVE_LCD_FLIP
+MENUITEM_SETTING(flip_display, &global_settings.flip_display, flipdisplay_callback);
+#endif
+MENUITEM_SETTING(invert_cursor, &global_settings.invert_cursor, NULL);
+#endif /* HAVE_LCD_BITMAP */
+#ifdef HAVE_LCD_COLOR
+/**
+* Menu to clear the backdrop image
+ */
+static int clear_main_backdrop(void)
+{
+    global_settings.backdrop_file[0]=0;
+    unload_main_backdrop();
+    show_main_backdrop();
+    return 0;
+}
+
+/**
+ * Menu for fore/back colors
+ */
+static int set_fg_color(void)
+{
+    int res;
+    res = (int)set_color(&screens[SCREEN_MAIN],str(LANG_FOREGROUND_COLOR),
+                     &global_settings.fg_color,global_settings.bg_color);
+
+    screens[SCREEN_MAIN].set_foreground(global_settings.fg_color);
+    return res;
+}
+
+static int set_bg_color(void)
+{
+    int res;
+    res = (int)set_color(&screens[SCREEN_MAIN],str(LANG_BACKGROUND_COLOR),
+                     &global_settings.bg_color,global_settings.fg_color);
+
+    screens[SCREEN_MAIN].set_background(global_settings.bg_color);
+    return res;
+}
+
+static int reset_color(void)
+{
+    global_settings.fg_color = LCD_DEFAULT_FG;
+    global_settings.bg_color = LCD_DEFAULT_BG;
+
+    screens[SCREEN_MAIN].set_foreground(global_settings.fg_color);
+    screens[SCREEN_MAIN].set_background(global_settings.bg_color);
+    return 0;
+}
+MENUITEM_FUNCTION(clear_main_bd, ID2P(LANG_CLEAR_BACKDROP),
+                    clear_main_backdrop, NULL, NOICON);
+MENUITEM_FUNCTION(set_bg_col, ID2P(LANG_BACKGROUND_COLOR),
+                    set_bg_color, NULL, NOICON);
+MENUITEM_FUNCTION(set_fg_col, ID2P(LANG_FOREGROUND_COLOR),
+                    set_fg_color, NULL, NOICON);
+MENUITEM_FUNCTION(reset_colors, ID2P(LANG_RESET_COLORS),
+                    reset_color, NULL, NOICON);
+#endif
+
+/* now the actual menu */
+MAKE_MENU(lcd_settings,ID2P(LANG_LCD_MENU),
+            NULL, bitmap_icons_6x8[Icon_Display_menu]
+#ifdef CONFIG_BACKLIGHT
+            ,&backlight_timeout
+# ifdef CONFIG_CHARGING
+            ,&backlight_timeout_plugged
+# endif
+# ifdef HAS_BUTTON_HOLD
+            ,&backlight_on_button_hold
+# endif
+            ,&caption_backlight
+# if defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR)
+            ,&backlight_fade_in, &backlight_fade_out
+# endif
+            ,&bl_filter_first_keypress
+# ifdef HAVE_LCD_SLEEP
+            ,&lcd_sleep_after_backlight_off
+# endif
+# ifdef HAVE_BACKLIGHT_BRIGHTNESS
+            ,&brightness_item
+# endif
+#endif /* CONFIG_BACKLIGHT */
+#ifdef HAVE_LCD_CONTRAST
+            ,&contrast
+#endif
+#ifdef HAVE_LCD_BITMAP
+# ifdef HAVE_LCD_INVERT
+            ,&invert
+# endif
+# ifdef HAVE_LCD_FLIP
+            ,&flip_display
+# endif
+            ,&invert_cursor
+#endif /* HAVE_LCD_BITMAP */
+#ifdef HAVE_LCD_COLOR
+            ,&clear_main_bd, &set_bg_col, &set_fg_col, &reset_colors
+#endif
+         );
+/*    LCD MENU                    */
+/***********************************/
+
+
+/********************************/
+/* Remote LCD settings menu     */
+#ifdef HAVE_REMOTE_LCD
+MENUITEM_SETTING(remote_backlight_timeout, 
+                    &global_settings.remote_backlight_timeout, NULL);
+
+#ifdef CONFIG_CHARGING
+MENUITEM_SETTING(remote_backlight_timeout_plugged, 
+                    &global_settings.remote_backlight_timeout_plugged, NULL);
+#endif
+
+#ifdef HAS_REMOTE_BUTTON_HOLD
+MENUITEM_SETTING(remote_backlight_on_button_hold, 
+                    &global_settings.remote_backlight_on_button_hold, NULL);
+#endif
+
+MENUITEM_SETTING(remote_caption_backlight, 
+                    &global_settings.remote_caption_backlight, NULL);
+MENUITEM_SETTING(remote_bl_filter_first_keypress, 
+                    &global_settings.remote_bl_filter_first_keypress, 
+                    filterfirstkeypress_callback);
+MENUITEM_SETTING(remote_contrast, 
+                    &global_settings.remote_contrast, NULL);
+MENUITEM_SETTING(remote_invert, 
+                    &global_settings.remote_invert, NULL);
+                    
+MENUITEM_SETTING(remote_flip_display, 
+                    &global_settings.remote_flip_display, flipdisplay_callback);
+
+#ifdef HAVE_REMOTE_LCD_TICKING
+int ticking_callback(int action,const struct menu_item_ex *this_item)
+{
+    (void)this_item;
+    switch (action)
+    {
+        case ACTION_EXIT_MENUITEM:
+            lcd_remote_emireduce(global_settings.remote_reduce_ticking);
+            break;
+    }
+    return action;
+}
+MENUITEM_SETTING(remote_reduce_ticking, 
+                    &global_settings.remote_reduce_ticking, ticking_callback);
+#endif
+
+MAKE_MENU(lcd_remote_settings, ID2P(LANG_LCD_REMOTE_MENU),
+            NULL, bitmap_icons_6x8[Icon_Remote_Display_menu],
+            &remote_backlight_timeout,
+#ifdef CONFIG_CHARGING
+            &remote_backlight_timeout_plugged,
+#endif
+#ifdef HAS_REMOTE_BUTTON_HOLD
+            &remote_backlight_on_button_hold,
+#endif
+            &remote_caption_backlight, &remote_bl_filter_first_keypress,
+            &remote_contrast, &remote_invert, &remote_flip_display
+#ifdef HAVE_REMOTE_LCD_TICKING
+            ,&remote_reduce_ticking
+#endif
+         );
+
+#endif /* HAVE_REMOTE_LCD */
+/* Remote LCD settings menu     */
+/********************************/
+
+/***********************************/
+/*    SCROLL MENU                  */
+MENUITEM_SETTING(scroll_speed, &global_settings.scroll_speed, NULL);
+MENUITEM_SETTING(scroll_delay, &global_settings.scroll_delay, NULL);
+#ifdef HAVE_LCD_BITMAP
+MENUITEM_SETTING(scroll_step, &global_settings.scroll_step, NULL);
+#endif
+MENUITEM_SETTING(bidir_limit, &global_settings.bidir_limit, NULL);
+#ifdef HAVE_REMOTE_LCD
+MENUITEM_SETTING(remote_scroll_speed, &global_settings.remote_scroll_speed, NULL);
+MENUITEM_SETTING(remote_scroll_delay, &global_settings.remote_scroll_delay, NULL);
+MENUITEM_SETTING(remote_scroll_step, &global_settings.remote_scroll_step, NULL);
+MENUITEM_SETTING(remote_bidir_limit, &global_settings.remote_bidir_limit, NULL);
+MAKE_MENU(remote_scroll_sets, ID2P(LANG_REMOTE_SCROLL_SETS), 0, NOICON,
+          &remote_scroll_speed, &remote_scroll_delay,
+          &remote_scroll_step, &remote_bidir_limit);
+#endif /* HAVE_REMOTE_LCD */
+#ifdef HAVE_LCD_CHARCELLS
+MENUITEM_SETTING(jump_scroll, &global_settings.jump_scroll, NULL);
+MENUITEM_SETTING(jump_scroll_delay, &global_settings.jump_scroll_delay, NULL);
+#endif
+#ifdef HAVE_LCD_BITMAP
+int screenscroll_callback(int action,const struct menu_item_ex *this_item)
+{
+    (void)this_item;
+    switch (action)
+    {
+        case ACTION_EXIT_MENUITEM:
+            gui_list_screen_scroll_out_of_view(global_settings.offset_out_of_view);
+            break;
+    }
+    return action;
+}
+MENUITEM_SETTING(offset_out_of_view, &global_settings.offset_out_of_view,
+                 screenscroll_callback);
+MENUITEM_SETTING(screen_scroll_step, &global_settings.screen_scroll_step, NULL);
+#endif
+MENUITEM_SETTING(scroll_paginated, &global_settings.scroll_paginated, NULL);
+
+MAKE_MENU(scroll_settings_menu, ID2P(LANG_SCROLL_MENU), 0, NOICON,
+          &scroll_speed, &scroll_delay,
+#ifdef HAVE_LCD_BITMAP
+          &scroll_step,
+#endif
+          &bidir_limit,
+#ifdef HAVE_REMOTE_LCD
+          &remote_scroll_sets,
+#endif
+#ifdef HAVE_LCD_CHARCELLS
+          &jump_scroll, &jump_scroll_delay,
+#endif
+#ifdef HAVE_LCD_BITMAP
+          &offset_out_of_view, &screen_scroll_step,
+#endif
+          &scroll_paginated
+          );
+/*    SCROLL MENU                  */
+/***********************************/
+
+/***********************************/
+/*    BARS MENU                    */
+#ifdef HAVE_LCD_BITMAP
+MENUITEM_SETTING(scrollbar_item, &global_settings.scrollbar, NULL);
+MENUITEM_SETTING(statusbar, &global_settings.statusbar, NULL);
+#if CONFIG_KEYPAD == RECORDER_PAD
+MENUITEM_SETTING(buttonbar, &global_settings.buttonbar, NULL);
+#endif
+MENUITEM_SETTING(volume_type, &global_settings.volume_type, NULL);
+MENUITEM_SETTING(battery_display, &global_settings.battery_display, NULL);
+MAKE_MENU(bars_menu, ID2P(LANG_BARS_MENU), 0, NOICON,
+          &scrollbar_item, &statusbar,
+#if CONFIG_KEYPAD == RECORDER_PAD
+          &buttonbar,
+#endif
+          &volume_type, &battery_display);
+#endif /* HAVE_LCD_BITMAP */
+/*    BARS MENU                    */
+/***********************************/
+
+
+/***********************************/
+/*    PEAK METER MENU              */
+
+#ifdef HAVE_LCD_BITMAP
+int peakmeter_callback(int action,const struct menu_item_ex *this_item)
+{
+    (void)this_item;
+    switch (action)
+    {
+        case ACTION_EXIT_MENUITEM:
+            peak_meter_init_times(global_settings.peak_meter_release,
+                                    global_settings.peak_meter_hold,
+                                    global_settings.peak_meter_clip_hold);
+            break;
+    }
+    return action;
+}
+MENUITEM_SETTING(peak_meter_clip_hold, 
+                 &global_settings.peak_meter_clip_hold, peakmeter_callback);
+
+MENUITEM_SETTING(peak_meter_release, 
+                 &global_settings.peak_meter_release, peakmeter_callback);
+/**
+ * Menu to select wether the scale of the meter
+ * displays dBfs of linear values.
+ */
+static int peak_meter_scale(void) {
+    bool retval = false;
+    bool use_dbfs = global_settings.peak_meter_dbfs;
+    retval = set_bool_options(str(LANG_PM_SCALE),
+        &use_dbfs,
+        STR(LANG_PM_DBFS), STR(LANG_PM_LINEAR),
+        NULL);
+
+    /* has the user really changed the scale? */
+    if (use_dbfs != global_settings.peak_meter_dbfs) {
+
+        /* store the change */
+        global_settings.peak_meter_dbfs = use_dbfs;
+        peak_meter_set_use_dbfs(use_dbfs);
+
+        /* If the user changed the scale mode the meaning of
+           peak_meter_min (peak_meter_max) has changed. Thus we have
+           to convert the values stored in global_settings. */
+        if (use_dbfs) {
+
+            /* we only store -dBfs */
+            global_settings.peak_meter_min = -peak_meter_get_min() / 100;
+            global_settings.peak_meter_max = -peak_meter_get_max() / 100;
+        } else {
+            int max;
+
+            /* linear percent */
+            global_settings.peak_meter_min = peak_meter_get_min();
+
+            /* converting dBfs -> percent results in a precision loss.
+               I assume that the user doesn't bother that conversion
+               dBfs <-> percent isn't symmetrical for odd values but that
+               he wants 0 dBfs == 100%. Thus I 'correct' the percent value
+               resulting from dBfs -> percent manually here */
+            max = peak_meter_get_max();
+            global_settings.peak_meter_max = max < 99 ? max : 100;
+        }
+        settings_apply_pm_range();
+    }
+    return retval;
+}
+
+/**
+ * Adjust the min value of the value range that
+ * the peak meter shall visualize.
+ */
+static int peak_meter_min(void) {
+    bool retval = false;
+    if (global_settings.peak_meter_dbfs) {
+
+        /* for dBfs scale */
+        int range_max = -global_settings.peak_meter_max;
+        int min = -global_settings.peak_meter_min;
+
+        retval =  set_int(str(LANG_PM_MIN), str(LANG_PM_DBFS), UNIT_DB,
+            &min, NULL, 1, -89, range_max, NULL);
+
+        global_settings.peak_meter_min = - min;
+    }
+
+    /* for linear scale */
+    else {
+        int min = global_settings.peak_meter_min;
+
+        retval =  set_int(str(LANG_PM_MIN), "%", UNIT_PERCENT,
+            &min, NULL,
+            1, 0, global_settings.peak_meter_max - 1, NULL);
+
+        global_settings.peak_meter_min = (unsigned char)min;
+    }
+
+    settings_apply_pm_range();
+    return retval;
+}
+
+
+/**
+ * Adjust the max value of the value range that
+ * the peak meter shall visualize.
+ */
+static int peak_meter_max(void) {
+    bool retval = false;
+    if (global_settings.peak_meter_dbfs) {
+
+        /* for dBfs scale */
+        int range_min = -global_settings.peak_meter_min;
+        int max = -global_settings.peak_meter_max;;
+
+        retval =  set_int(str(LANG_PM_MAX), str(LANG_PM_DBFS), UNIT_DB,
+            &max, NULL, 1, range_min, 0, NULL);
+
+        global_settings.peak_meter_max = - max;
+
+    }
+
+    /* for linear scale */
+    else {
+        int max = global_settings.peak_meter_max;
+
+        retval =  set_int(str(LANG_PM_MAX), "%", UNIT_PERCENT,
+            &max, NULL,
+            1, global_settings.peak_meter_min + 1, 100, NULL);
+
+        global_settings.peak_meter_max = (unsigned char)max;
+    }
+
+    settings_apply_pm_range();
+    return retval;
+}
+MENUITEM_FUNCTION(peak_meter_scale_item, ID2P(LANG_PM_SCALE),
+                    peak_meter_scale, NULL, NOICON);
+MENUITEM_FUNCTION(peak_meter_min_item, ID2P(LANG_PM_MIN), 
+                    peak_meter_min, NULL, NOICON);
+MENUITEM_FUNCTION(peak_meter_max_item, ID2P(LANG_PM_MAX), 
+                    peak_meter_max, NULL, NOICON);
+MAKE_MENU(peak_meter_menu, ID2P(LANG_PM_MENU), NULL, NOICON, 
+          &peak_meter_clip_hold, &peak_meter_release,
+          &peak_meter_scale_item, &peak_meter_min_item, &peak_meter_max_item);
+#endif /*  HAVE_LCD_BITMAP */
+/*    PEAK METER MENU              */
+/***********************************/
+
+
+
+struct browse_folder_info {
+	const char* dir;
+	int show_options;
+};
+#ifdef HAVE_LCD_BITMAP
+static struct browse_folder_info fonts = {FONT_DIR, SHOW_FONT};
+#endif
+static struct browse_folder_info wps = {WPS_DIR, SHOW_WPS};
+#ifdef HAVE_REMOTE_LCD
+static struct browse_folder_info rwps = {WPS_DIR, SHOW_RWPS};
+#endif
+
+static int browse_folder(void *param)
+{
+	const struct browse_folder_info *info =
+		(const struct browse_folder_info*)param;
+    return rockbox_browse(info->dir, info->show_options);
+}
+
+#ifdef HAVE_LCD_BITMAP
+MENUITEM_FUNCTION_WPARAM(browse_fonts, ID2P(LANG_CUSTOM_FONT), 
+		browse_folder, (void*)&fonts, NULL, NOICON);
+#endif
+MENUITEM_FUNCTION_WPARAM(browse_wps, ID2P(LANG_WHILE_PLAYING), 
+		browse_folder, (void*)&wps, NULL, NOICON);
+#ifdef HAVE_REMOTE_LCD
+MENUITEM_FUNCTION_WPARAM(browse_rwps, ID2P(LANG_REMOTE_WHILE_PLAYING), 
+		browse_folder, (void*)&rwps, NULL, NOICON);
+#endif
+
+MENUITEM_SETTING(show_icons, &global_settings.show_icons, NULL);
+MENUITEM_SETTING(codepage_setting, &global_settings.default_codepage, NULL);
+
+
+MAKE_MENU(display_menu, ID2P(LANG_DISPLAY),
+            NULL, bitmap_icons_6x8[Icon_Display_menu],
+#ifdef HAVE_LCD_BITMAP
+            &browse_fonts,
+#endif
+            &browse_wps,
+#ifdef HAVE_REMOTE_LCD
+            &browse_rwps,
+#endif
+            &lcd_settings,
+#ifdef HAVE_REMOTE_LCD
+            &lcd_remote_settings,
+#endif
+            &show_icons, &scroll_settings_menu,
+#ifdef HAVE_LCD_BITMAP
+            &bars_menu, &peak_meter_menu,
+#endif
+            &codepage_setting,
+            );

apps/menus/main_menu.c

@@ -1,4 +1,3 @@
-
 /***************************************************************************
  *             __________               __   ___.
  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___

apps/menus/playback_menu.c

@@ -188,6 +188,7 @@ MAKE_MENU(playback_menu_item,ID2P(LANG_PLAYBACK),0,
          ,&unplug_menu
 #endif
          );
+         #include "debug.h"
 int playback_callback(int action,const struct menu_item_ex *this_item)
 {
     static bool old_shuffle = false;
@@ -196,6 +197,7 @@ int playback_callback(int action,const struct menu_item_ex *this_item)
     switch (action)
     {
         case ACTION_ENTER_MENUITEM:
+            DEBUGF("boo\n");
             if (this_item == &shuffle_item)
                 old_shuffle = global_settings.playlist_shuffle;
             else if (this_item == &repeat_mode)

apps/menus/settings_menu.c

@@ -73,7 +73,6 @@ MENUITEM_SETTING(sort_dir, &global_settings.sort_dir, fileview_callback);
 MENUITEM_SETTING(sort_file, &global_settings.sort_file, fileview_callback);
 MENUITEM_SETTING(dirfilter, &global_settings.dirfilter, NULL);
 MENUITEM_SETTING(browse_current, &global_settings.browse_current, NULL);
-MENUITEM_SETTING(show_icons, &global_settings.show_icons, NULL);
 MENUITEM_SETTING(show_path_in_browser, &global_settings.show_path_in_browser, NULL);
 static int fileview_callback(int action,const struct menu_item_ex *this_item)
 {
@@ -94,7 +93,7 @@ static int fileview_callback(int action,const struct menu_item_ex *this_item)
 
 MAKE_MENU(file_menu, ID2P(LANG_FILE), 0, NOICON,
                 &sort_case, &sort_dir, &sort_file,
-                &dirfilter, &browse_current, &show_icons, &show_path_in_browser,
+                &dirfilter, &browse_current, &show_path_in_browser,
 #ifdef HAVE_TAGCACHE
                 &tagcache_menu
 #endif

apps/recorder/icons.c

@@ -73,6 +73,7 @@ const unsigned char bitmap_icons_6x8[][6] =
     { 0x1e, 0x22, 0x49, 0x49, 0x22, 0x1e }, /* system menu */
     { 0x7f, 0x7f, 0x3e, 0x1c, 0x08, 0x00 }, /* playback menu */
     { 0x1f, 0x51, 0x71, 0x71, 0x51, 0x1f }, /* display menu */
+    { 0x1e, 0x32, 0x32, 0x32, 0x1e, 0x00 }, /* remote display menu */
     { 0x03, 0x05, 0x7f, 0x05, 0x03, 0x00 }, /* radio */
 };
 

apps/recorder/icons.h

@@ -77,6 +77,7 @@ enum icons_6x8 {
     Icon_System_menu,
     Icon_Playback_menu,
     Icon_Display_menu,
+    Icon_Remote_Display_menu,
     Icon_Radio_screen,
     Icon6x8Last,
 };

apps/settings.c

@@ -1219,16 +1219,20 @@ bool set_int_ex(const unsigned char* string,
 #if CONFIG_KEYPAD != PLAYER_PAD
     struct value_setting_data data = {
         INT,max, step, voice_unit,unit,formatter,get_talk_id,NULL };
-    if (unit == NULL)
+    if (voice_unit < UNIT_LAST)
         data.unit = unit_strings[voice_unit];
+    else 
+        data.unit = str(voice_unit);
     return do_set_setting(string,variable,(max-min)/step + 1,
                           (max-*variable)/step, &data,function);
 #else
     int count = (max-min)/step + 1;
     struct value_setting_data data = {
         INT,min, -step, voice_unit,unit,formatter,get_talk_id,NULL };
-    if (unit == NULL)
+    if (voice_unit < UNIT_LAST)
         data.unit = unit_strings[voice_unit];
+    else 
+        data.unit = str(voice_unit);
     return do_set_setting(string,variable,count,
                           count - ((max-*variable)/step), &data,function);
 #endif

apps/settings_list.c

@@ -24,6 +24,8 @@
 #include "lang.h"
 #include "talk.h"
 #include "lcd.h"
+#include "button.h"
+#include "backlight.h"
 #include "settings.h"
 #include "settings_list.h"
 #include "sound.h"
@@ -33,6 +35,13 @@
 #include "audio.h"
 #include "power.h"
 #include "powermgmt.h"
+#include "kernel.h"
+#include "lcd-remote.h"
+#include "list.h"
+#include "rbunicode.h"
+#ifdef HAVE_LCD_BITMAP
+#include "peakmeter.h"
+#endif
 
 /* some sets of values which are used more than once, to save memory */
 static const char off_on[] = "off,on";
@@ -81,6 +90,27 @@ static const char trig_durations_conf [] =
 #if defined(CONFIG_BACKLIGHT)
 static const char backlight_times_conf [] =
                   "off,on,1,2,3,4,5,6,7,8,9,10,15,20,25,30,45,60,90";
+static const int backlight_times[] = 
+            {-1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 45, 60, 90};
+static void backlight_formatter(char *buffer, int buffer_size, 
+        int val, const char *unit)
+{
+    (void)unit;
+    if (val == 0)
+        strcpy(buffer, str(LANG_OFF));
+    else if (val == 1)
+        strcpy(buffer, str(LANG_ON));
+    else 
+        snprintf(buffer, buffer_size, "%d s", backlight_times[val]);
+}
+static long backlight_getlang(int value)
+{
+    if (value == 0)
+        return LANG_OFF;
+    else if (value == 1)
+        return LANG_ON;
+    return TALK_ID(backlight_times[value], UNIT_SEC);
+}
 #endif
 /* ffwd/rewind and scan acceleration stuff */
 static int ff_rewind_min_stepvals[] = {1,2,3,4,5,6,8,10,15,20,25,30,45,60};
@@ -268,6 +298,58 @@ static void set_superbass(bool value)
 }
 #endif
 
+static void scrolldelay_format(char* buffer, int buffer_size, int value,
+    const char* unit)
+{
+    (void)unit;
+    snprintf(buffer, buffer_size, "%d ms", value* (HZ/100));
+}
+static long scrolldelay_getlang(int value)
+{
+    return TALK_ID(value* (HZ/100), UNIT_MS);
+}
+#ifdef HAVE_LCD_CHARCELLS
+static void jumpscroll_format(char* buffer, int buffer_size, int value,
+    const char* unit)
+{
+    (void)unit;
+    switch (value)
+    {
+        case 0:
+            strcpy(buffer, str(LANG_OFF));
+            break;
+        case 1:
+            strcpy(buffer, str(LANG_ONE_TIME));
+            break;
+        case 2:
+        case 3:
+        case 4:
+            snprintf(buffer, buffer_size, "%d", value);
+            break;
+        case 5:
+            strcpy(buffer, str(LANG_ALWAYS));
+            break;
+    }
+}
+static long jumpscroll_getlang(int value)
+{
+    switch (value)
+    {
+        case 0:
+            return LANG_OFF;
+        case 1:
+            return LANG_ONE_TIME;
+        case 2:
+        case 3:
+        case 4:
+            return TALK_ID(2, UNIT_INT);
+        case 5:
+            return LANG_ALWAYS;
+    }
+    return -1;
+}
+#endif /* HAVE_LCD_CHARCELLS */
+                    
 const struct settings_list settings[] = {
     /* sound settings */
     SOUND_SETTING(0,volume, LANG_VOLUME, "volume", SOUND_VOLUME),
@@ -321,33 +403,43 @@ const struct settings_list settings[] = {
     ), /* CHOICE_SETTING( repeat_mode ) */
     /* LCD */
 #ifdef HAVE_LCD_CONTRAST
+    /* its easier to leave this one un-macro()ed for the time being */
     {F_T_INT|F_DEF_ISFUNC, &global_settings.contrast, LANG_CONTRAST,
          FUNCTYPE(lcd_default_contrast),
-         "contrast", NULL , UNUSED},
+         "contrast", NULL , {.int_setting = (struct int_setting[]){                
+            { lcd_set_contrast, UNIT_INT, MIN_CONTRAST_SETTING,
+                MAX_CONTRAST_SETTING, 1, NULL, NULL}}}},
 #endif
 #ifdef CONFIG_BACKLIGHT
-    {F_T_INT, &global_settings.backlight_timeout, LANG_BACKLIGHT, INT(6),
+    INT_SETTING_W_CFGVALS(0, backlight_timeout, LANG_BACKLIGHT, 6,
-        "backlight timeout",backlight_times_conf , UNUSED},
+        "backlight timeout", backlight_times_conf, UNIT_SEC,
+        0, 18, 1, backlight_formatter, backlight_getlang, 
+        backlight_set_timeout),
 #ifdef CONFIG_CHARGING
-    {F_T_INT, &global_settings.backlight_timeout_plugged, LANG_BACKLIGHT_ON_WHEN_CHARGING,
+    INT_SETTING_W_CFGVALS(0, backlight_timeout_plugged, LANG_BACKLIGHT, 11,
-         INT(11), "backlight timeout plugged",backlight_times_conf , UNUSED},
+        "backlight timeout plugged", backlight_times_conf, UNIT_SEC,
+        0, 18, 1, backlight_formatter, backlight_getlang, 
+        backlight_set_timeout_plugged),
 #endif
 #endif /* CONFIG_BACKLIGHT */
 #ifdef HAVE_LCD_BITMAP
-    OFFON_SETTING(0,invert, LANG_INVERT, false,"invert", NULL),
+    BOOL_SETTING(0, invert, LANG_INVERT, false ,"invert", off_on,
+        LANG_INVERT_LCD_INVERSE, LANG_INVERT_LCD_NORMAL, lcd_set_invert_display),
     OFFON_SETTING(0,flip_display, LANG_FLIP_DISPLAY, false,"flip display", NULL),
     /* display */
-    OFFON_SETTING(0,invert_cursor, LANG_INVERT_CURSOR,
+    BOOL_SETTING(F_TEMPVAR, invert_cursor, LANG_INVERT_CURSOR, true ,"invert cursor", off_on,
-        true,"invert cursor", NULL),
+        LANG_INVERT_CURSOR_BAR, LANG_INVERT_CURSOR_POINTER, lcd_set_invert_display),
     OFFON_SETTING(F_THEMESETTING,statusbar, LANG_STATUS_BAR, true,"statusbar", NULL),
     OFFON_SETTING(0,scrollbar, LANG_SCROLL_BAR, true,"scrollbar", NULL),
 #if CONFIG_KEYPAD == RECORDER_PAD
     OFFON_SETTING(0,buttonbar, LANG_BUTTON_BAR ,true,"buttonbar", NULL),
 #endif
-    {F_T_INT,&global_settings.volume_type,LANG_VOLUME_DISPLAY, INT(0),
+    CHOICE_SETTING(0, volume_type, LANG_VOLUME_DISPLAY, 0,
-        "volume display",graphic_numeric,UNUSED},
+        "volume display", graphic_numeric, NULL, 2,
-    {F_T_INT,&global_settings.battery_display, LANG_BATTERY_DISPLAY, INT(0),
+        ID2P(LANG_DISPLAY_GRAPHIC), ID2P(LANG_DISPLAY_NUMERIC)),
-        "battery display",graphic_numeric,UNUSED},
+    CHOICE_SETTING(0, battery_display, LANG_BATTERY_DISPLAY, 0,
+        "battery display", graphic_numeric, NULL, 2,
+        ID2P(LANG_DISPLAY_GRAPHIC), ID2P(LANG_DISPLAY_NUMERIC)),
     CHOICE_SETTING(0, timeformat, LANG_TIMEFORMAT, 0,
         "time format", "24hour,12hour", NULL, 2,
         ID2P(LANG_24_HOUR_CLOCK), ID2P(LANG_12_HOUR_CLOCK)),
@@ -400,19 +492,22 @@ const struct settings_list settings[] = {
 #endif
 #ifdef HAVE_REMOTE_LCD
     /* remote lcd */
-    {F_T_INT,&global_settings.remote_contrast, LANG_CONTRAST, 
+    INT_SETTING(0, remote_contrast, LANG_CONTRAST, DEFAULT_REMOTE_CONTRAST_SETTING,
-        INT(DEFAULT_REMOTE_CONTRAST_SETTING),
+        "remote contrast", UNIT_INT, MIN_REMOTE_CONTRAST_SETTING, 
-        "remote contrast",NULL,UNUSED},
+        MIN_REMOTE_CONTRAST_SETTING, 1, NULL, NULL, lcd_remote_set_contrast),
-    OFFON_SETTING(0,remote_invert, LANG_INVERT,
+    BOOL_SETTING(0, remote_invert, LANG_INVERT, false ,"remote invert", off_on,
-        false,"remote invert", NULL),
+        LANG_INVERT_LCD_INVERSE, LANG_INVERT_LCD_NORMAL, lcd_remote_set_invert_display),
     OFFON_SETTING(0,remote_flip_display, LANG_FLIP_DISPLAY,
         false,"remote flip display", NULL),
-    {F_T_INT,&global_settings.remote_backlight_timeout, LANG_BACKLIGHT, INT(6),
+    INT_SETTING_W_CFGVALS(0, remote_backlight_timeout, LANG_BACKLIGHT, 6,
-        "remote backlight timeout",backlight_times_conf,UNUSED},
+        "remote backlight timeout", backlight_times_conf, UNIT_SEC,
+        0, 18, 1, backlight_formatter, backlight_getlang, 
+        remote_backlight_set_timeout),
 #ifdef CONFIG_CHARGING
-    {F_T_INT,&global_settings.remote_backlight_timeout_plugged,
+    INT_SETTING_W_CFGVALS(0, remote_backlight_timeout_plugged, LANG_BACKLIGHT, 11,
-        LANG_BACKLIGHT_ON_WHEN_CHARGING, INT(11),
+        "remote backlight timeout plugged", backlight_times_conf, UNIT_SEC,
-        "remote backlight timeout plugged",backlight_times_conf,UNUSED},
+        0, 18, 1, backlight_formatter, backlight_getlang, 
+        remote_backlight_set_timeout_plugged),
 #endif
 #ifdef HAVE_REMOTE_LCD_TICKING
     OFFON_SETTING(0,remote_reduce_ticking, LANG_REDUCE_TICKING,
@@ -442,43 +537,53 @@ const struct settings_list settings[] = {
 #endif
 #endif /* CONFIG_BACKLIGHT */
 #ifdef HAVE_BACKLIGHT_BRIGHTNESS
-    {F_T_INT,&global_settings.brightness,LANG_BRIGHTNESS,
+    INT_SETTING(0, brightness, LANG_BRIGHTNESS, DEFAULT_BRIGHTNESS_SETTING,
-        INT(DEFAULT_BRIGHTNESS_SETTING), "brightness", NULL ,UNUSED},
+        "brightness",UNIT_INT, MIN_BRIGHTNESS_SETTING, MAX_BRIGHTNESS_SETTING, 1,
+        NULL, NULL, backlight_set_brightness),
 #endif
-#ifdef HAVE_BACKLIGHT_PWM_FADING
+#if defined(HAVE_BACKLIGHT_PWM_FADING)  && !defined(SIMULATOR)
     /* backlight fading */
-    {F_T_INT,&global_settings.backlight_fade_in, LANG_BACKLIGHT_FADE_IN, INT(1),
+    STRINGCHOICE_SETTING(0,backlight_fade_in, LANG_BACKLIGHT_FADE_IN, 1,
-        "backlight fade in","off,500ms,1s,2s",UNUSED},
+        "backlight fade in","off,500ms,1s,2s", backlight_set_fade_in, 4,
-    {F_T_INT,&global_settings.backlight_fade_out, LANG_BACKLIGHT_FADE_OUT, INT(1),
+        LANG_OFF, TALK_ID(500, UNIT_MS), 
-        "backlight fade out","off,500ms,1s,2s,3s,4s,5s,10s",UNUSED},
+        TALK_ID(1, UNIT_SEC), TALK_ID(2, UNIT_SEC)),
+    STRINGCHOICE_SETTING(0,backlight_fade_out, LANG_BACKLIGHT_FADE_OUT, 1,
+        "backlight fade out","off,500ms,1s,2s", backlight_set_fade_out, 4,
+        LANG_OFF, TALK_ID(500, UNIT_MS), 
+        TALK_ID(1, UNIT_SEC), TALK_ID(2, UNIT_SEC)),
 #endif
-    {F_T_INT,&global_settings.scroll_speed, LANG_SCROLL_SPEED ,
+    INT_SETTING(0, scroll_speed, LANG_SCROLL_SPEED, 9,"scroll speed",                      
-        INT(9),"scroll speed",NULL,UNUSED},
+                UNIT_INT, 0, 15, 1, NULL, NULL, lcd_scroll_speed),
-    {F_T_INT,&global_settings.scroll_delay, LANG_SCROLL_DELAY, 
+    INT_SETTING(0, scroll_delay, LANG_SCROLL_DELAY, 100, "scroll delay",                      
-        INT(100),"scroll delay",NULL,UNUSED},
+                UNIT_MS, 0, 2500, 100, scrolldelay_format,
-    {F_T_INT,&global_settings.bidir_limit, LANG_BIDIR_SCROLL, 
+                scrolldelay_getlang, lcd_scroll_delay) ,
-        INT(50),"bidir limit",NULL,UNUSED},
+    INT_SETTING(0, bidir_limit, LANG_BIDIR_SCROLL, 50, "bidir limit",                      
+                UNIT_PERCENT, 0, 200, 25, NULL, NULL, lcd_bidir_scroll),
 #ifdef HAVE_REMOTE_LCD
-    {F_T_INT,&global_settings.remote_scroll_speed,LANG_SCROLL_SPEED,INT(9),
+    INT_SETTING(0, remote_scroll_speed, LANG_SCROLL_SPEED, 9, "remote scroll speed",                      
-        "remote scroll speed",NULL,UNUSED},
+                UNIT_INT, 0,15, 1, NULL, NULL, lcd_remote_scroll_speed),
-    {F_T_INT,&global_settings.remote_scroll_step,LANG_SCROLL_STEP,INT(6),
+    INT_SETTING(0, remote_scroll_step, LANG_SCROLL_STEP, 6, "remote scroll step",                      
-        "remote scroll step",NULL,UNUSED},
+                UNIT_PIXEL, 1, LCD_REMOTE_WIDTH, 1, NULL, NULL, lcd_remote_scroll_step),
-    {F_T_INT,&global_settings.remote_scroll_delay,LANG_SCROLL_DELAY,INT(100),
+    INT_SETTING(0, remote_scroll_delay, LANG_SCROLL_DELAY, 100, "remote scroll delay",                      
-        "remote scroll delay",NULL,UNUSED},
+                UNIT_MS, 0, 2500, 100, scrolldelay_format, scrolldelay_getlang, lcd_remote_scroll_delay),
-    {F_T_INT,&global_settings.remote_bidir_limit,LANG_BIDIR_SCROLL,INT(50),
+    INT_SETTING(0, remote_bidir_limit, LANG_BIDIR_SCROLL, 50, "remote bidir limit",                      
-        "remote bidir limit",NULL,UNUSED},
+                UNIT_PERCENT, 0, 200, 25, NULL, NULL, lcd_remote_bidir_scroll),
 #endif
 #ifdef HAVE_LCD_BITMAP
     OFFON_SETTING(0, offset_out_of_view, LANG_SCREEN_SCROLL_VIEW,
                     false, "Screen Scrolls Out Of View", NULL),
-    {F_T_INT,&global_settings.scroll_step,LANG_SCROLL_STEP,INT(6),"scroll step",NULL,UNUSED},
+    INT_SETTING(0, scroll_step, LANG_SCROLL_STEP, 6, "scroll step",                      
-    {F_T_INT,&global_settings.screen_scroll_step,LANG_SCREEN_SCROLL_STEP,
+                    UNIT_PIXEL, 1, LCD_WIDTH, 1, NULL, NULL, lcd_scroll_step),
-        INT(16),"screen scroll step",NULL,UNUSED},
+    INT_SETTING(0, screen_scroll_step, LANG_SCREEN_SCROLL_STEP,
+                    16, "screen scroll step",                      
+                    UNIT_PIXEL, 1, LCD_WIDTH, 1, NULL, NULL, NULL),
 #endif /* HAVE_LCD_BITMAP */
 #ifdef HAVE_LCD_CHARCELLS
-    {F_T_INT,&global_settings.jump_scroll,LANG_JUMP_SCROLL,INT(0),"jump scroll",NULL,UNUSED},
+    INT_SETTING(0, jump_scroll, LANG_JUMP_SCROLL, 0, "jump scroll",                      
-    {F_T_INT,&global_settings.jump_scroll_delay,LANG_JUMP_SCROLL_DELAY,
+                    UNIT_INT, 0, 5, 1, jumpscroll_format, jumpscroll_getlang, lcd_jump_scroll),
-        INT(50),"jump scroll delay",NULL,UNUSED},
+    INT_SETTING(0, jump_scroll_delay, LANG_JUMP_SCROLL_DELAY, 50, "jump scroll delay",                      
+                    UNIT_MS, 0, 2500, 100, scrolldelay_format,
+                    scrolldelay_getlang, lcd_jump_scroll_delay),
 #endif
     OFFON_SETTING(0,scroll_paginated,LANG_SCROLL_PAGINATED,
         false,"scroll paginated",NULL),
@@ -552,15 +657,24 @@ const struct settings_list settings[] = {
         ID2P(LANG_BOOKMARK_SETTINGS_UNIQUE_ONLY)),
 #ifdef HAVE_LCD_BITMAP
     /* peak meter */
-    {F_T_INT, &global_settings.peak_meter_clip_hold, LANG_PM_CLIP_HOLD,
+    STRINGCHOICE_SETTING(0, peak_meter_clip_hold, LANG_PM_CLIP_HOLD, 16,
-        INT(16), "peak meter clip hold",
+        "peak meter clip hold",
         "on,1,2,3,4,5,6,7,8,9,10,15,20,25,30,45,60,90,2min"
-        ",3min,5min,10min,20min,45min,90min", UNUSED},
+        ",3min,5min,10min,20min,45min,90min", peak_meter_set_clip_hold,
+        25, LANG_PM_ETERNAL,
+        TALK_ID(1, UNIT_SEC), TALK_ID(2, UNIT_SEC), TALK_ID(3, UNIT_SEC), 
+        TALK_ID(4, UNIT_SEC), TALK_ID(5, UNIT_SEC), TALK_ID(6, UNIT_SEC), 
+        TALK_ID(7, UNIT_SEC), TALK_ID(8, UNIT_SEC), TALK_ID(9, UNIT_SEC), 
+        TALK_ID(10, UNIT_SEC), TALK_ID(15, UNIT_SEC), TALK_ID(20, UNIT_SEC), 
+        TALK_ID(25, UNIT_SEC), TALK_ID(30, UNIT_SEC), TALK_ID(45, UNIT_SEC), 
+        TALK_ID(60, UNIT_SEC), TALK_ID(90, UNIT_SEC), TALK_ID(2, UNIT_MIN), 
+        TALK_ID(3, UNIT_MIN), TALK_ID(5, UNIT_MIN), TALK_ID(10, UNIT_MIN), 
+        TALK_ID(20, UNIT_MIN), TALK_ID(45, UNIT_MIN), TALK_ID(90, UNIT_MIN)),
     {F_T_INT,&global_settings.peak_meter_hold, LANG_PM_PEAK_HOLD, 
         INT(3),"peak meter hold",
         "off,200ms,300ms,500ms,1,2,3,4,5,6,7,8,9,10,15,20,30,1min",UNUSED},
-    {F_T_INT,&global_settings.peak_meter_release,LANG_PM_RELEASE, 
+    INT_SETTING(0, peak_meter_release, LANG_PM_RELEASE, 8, "peak meter release",                      
-        INT(8),"peak meter release",NULL,UNUSED},
+                    LANG_PM_UNITS_PER_READ, 1, 0x7e1, 1, NULL, NULL,NULL), 
     OFFON_SETTING(0,peak_meter_dbfs,LANG_PM_DBFS,true,"peak meter dbfs",NULL),
     {F_T_INT,&global_settings.peak_meter_min,LANG_PM_MIN,INT(60),"peak meter min",NULL,UNUSED},
     {F_T_INT,&global_settings.peak_meter_max,LANG_PM_MAX,INT(0),"peak meter max",NULL,UNUSED},
@@ -794,11 +908,18 @@ const struct settings_list settings[] = {
     OFFON_SETTING(0,tagcache_autoupdate,
         LANG_TAGCACHE_AUTOUPDATE,false,"tagcache_autoupdate",NULL),
 #endif
-
+    CHOICE_SETTING(0, default_codepage, LANG_DEFAULT_CODEPAGE, 0,
-    {F_T_INT,&global_settings.default_codepage,LANG_DEFAULT_CODEPAGE,
+        "default codepage",
-        INT(0),"default codepage",
         "iso8859-1,iso8859-7,iso8859-8,cp1251,iso8859-11,cp1256,"
-        "iso8859-9,iso8859-2,sjis,gb2312,ksx1001,big5,utf-8,cp1256",UNUSED},
+        "iso8859-9,iso8859-2,sjis,gb2312,ksx1001,big5,utf-8,cp1256",
+        set_codepage, 13,
+        ID2P(LANG_CODEPAGE_LATIN1), ID2P(LANG_CODEPAGE_GREEK),
+        ID2P(LANG_CODEPAGE_HEBREW), ID2P(LANG_CODEPAGE_CYRILLIC),
+        ID2P(LANG_CODEPAGE_THAI), ID2P(LANG_CODEPAGE_ARABIC),
+        ID2P(LANG_CODEPAGE_TURKISH), ID2P(LANG_CODEPAGE_LATIN_EXTENDED),
+        ID2P(LANG_CODEPAGE_JAPANESE), ID2P(LANG_CODEPAGE_SIMPLIFIED),
+        ID2P(LANG_CODEPAGE_KOREAN),
+        ID2P(LANG_CODEPAGE_TRADITIONAL), ID2P(LANG_CODEPAGE_UTF8)),
 
     OFFON_SETTING(0,warnon_erase_dynplaylist,
         LANG_WARN_ERASEDYNPLAYLIST_MENU,false,
@@ -806,15 +927,20 @@ const struct settings_list settings[] = {
 
 #ifdef CONFIG_BACKLIGHT
 #ifdef HAS_BUTTON_HOLD
-    {F_T_INT,&global_settings.backlight_on_button_hold,LANG_BACKLIGHT_ON_BUTTON_HOLD,INT(0),
+    CHOICE_SETTING(0, backlight_on_button_hold,
-        "backlight on button hold","normal,off,on",UNUSED},
+        LANG_BACKLIGHT_ON_BUTTON_HOLD, 0, "backlight on button hold",
+        "normal,off,on", backlight_set_on_button_hold, 3,
+        ID2P(LANG_BACKLIGHT_ON_BUTTON_HOLD_NORMAL), ID2P(LANG_OFF), ID2P(LANG_ON)),
 #endif
 
 #ifdef HAVE_LCD_SLEEP
-    {F_T_INT,&global_settings.lcd_sleep_after_backlight_off,
+    STRINGCHOICE_SETTING(0, lcd_sleep_after_backlight_off,
-        LANG_LCD_SLEEP_AFTER_BACKLIGHT_OFF,INT(3),
+        LANG_LCD_SLEEP_AFTER_BACKLIGHT_OFF, 3,
         "lcd sleep after backlight off",
-        "always,never,5,10,15,20,30,45,60,90",UNUSED},
+        "always,never,5,10,15,20,30,45,60,90", lcd_set_sleep_after_backlight_off,
+        10, LANG_ALWAYS, LANG_NEVER, TALK_ID(5, UNIT_SEC), TALK_ID(10, UNIT_SEC),
+        TALK_ID(15, UNIT_SEC), TALK_ID(20, UNIT_SEC), TALK_ID(30, UNIT_SEC),
+        TALK_ID(45, UNIT_SEC),TALK_ID(60, UNIT_SEC), TALK_ID(90, UNIT_SEC)),
 #endif
 #endif /* CONFIG_BACKLIGHT */
 
@@ -880,9 +1006,10 @@ const struct settings_list settings[] = {
 
 #ifdef HAVE_REMOTE_LCD
 #ifdef HAS_REMOTE_BUTTON_HOLD
-    {F_T_INT,&global_settings.remote_backlight_on_button_hold,
+    CHOICE_SETTING(0, remote_backlight_on_button_hold,
-        LANG_BACKLIGHT_ON_BUTTON_HOLD,INT(0),
+        LANG_BACKLIGHT_ON_BUTTON_HOLD, 0, "remote backlight on button hold",
-        "remote backlight on button hold","normal,off,on",UNUSED},
+        "normal,off,on", remote_backlight_set_on_button_hold, 3,
+        ID2P(LANG_BACKLIGHT_ON_BUTTON_HOLD_NORMAL), ID2P(LANG_OFF), ID2P(LANG_ON)),
 #endif
 #endif
 #ifdef HAVE_HEADPHONE_DETECTION