apps/menus/settings_menu.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2007 Jonathan Gordon
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdbool.h>
  23 #include <stddef.h>
  24 #include <limits.h>
  25 #include <string.h>
  26 #include "config.h"
  27 #include "lang.h"
  28 #include "action.h"
  29 #include "settings.h"
  30 #include "menu.h"
  31 #include "keyboard.h"
  32 #include "sound_menu.h"
  33 #include "exported_menus.h"
  34 #include "tree.h"
  35 #include "tagtree.h"
  36 #include "usb.h"
  37 #include "splash.h"
  38 #include "yesno.h"
  39 #include "talk.h"
  40 #include "powermgmt.h"
  41 #if CONFIG_CODEC == SWCODEC
  42 #include "playback.h"
  43 #endif
  44 #if CONFIG_RTC
  45 #include "screens.h"
  46 #endif
  47 #include "quickscreen.h"
  48 #ifdef HAVE_DIRCACHE
  49 #include "dircache.h"
  50 #endif
  51
  52 /***********************************/
  53 /*    TAGCACHE MENU                */
  54 #ifdef HAVE_TAGCACHE
  55
  56 static void tagcache_rebuild_with_splash(void)
  57 {
  58     tagcache_rebuild();
  59     splash(HZ*2, ID2P(LANG_TAGCACHE_FORCE_UPDATE_SPLASH));
  60 }
  61
  62 static void tagcache_update_with_splash(void)
  63 {
  64     tagcache_update();
  65     splash(HZ*2, ID2P(LANG_TAGCACHE_FORCE_UPDATE_SPLASH));
  66 }
  67
  68 #ifdef HAVE_TC_RAMCACHE
  69 MENUITEM_SETTING(tagcache_ram, &global_settings.tagcache_ram, NULL);
  70 #endif
  71 MENUITEM_SETTING(tagcache_autoupdate, &global_settings.tagcache_autoupdate, NULL);
  72 MENUITEM_FUNCTION(tc_init, 0, ID2P(LANG_TAGCACHE_FORCE_UPDATE),
  73                     (int(*)(void))tagcache_rebuild_with_splash,
  74                     NULL, NULL, Icon_NOICON);
  75 MENUITEM_FUNCTION(tc_update, 0, ID2P(LANG_TAGCACHE_UPDATE),
  76                     (int(*)(void))tagcache_update_with_splash,
  77                     NULL, NULL, Icon_NOICON);
  78 MENUITEM_SETTING(runtimedb, &global_settings.runtimedb, NULL);
  79 MENUITEM_FUNCTION(tc_export, 0, ID2P(LANG_TAGCACHE_EXPORT),
  80                     (int(*)(void))tagtree_export, NULL,
  81                     NULL, Icon_NOICON);
  82 MENUITEM_FUNCTION(tc_import, 0, ID2P(LANG_TAGCACHE_IMPORT),
  83                     (int(*)(void))tagtree_import, NULL,
  84                     NULL, Icon_NOICON);
  85 MAKE_MENU(tagcache_menu, ID2P(LANG_TAGCACHE), 0, Icon_NOICON,
  86 #ifdef HAVE_TC_RAMCACHE
  87                 &tagcache_ram,
  88 #endif
  89                 &tagcache_autoupdate, &tc_init, &tc_update, &runtimedb,
  90                 &tc_export, &tc_import);
  91 #endif /* HAVE_TAGCACHE */
  92 /*    TAGCACHE MENU                */
  93 /***********************************/
  94
  95 /***********************************/
  96 /*    FILE VIEW MENU               */
  97 static int fileview_callback(int action,const struct menu_item_ex *this_item);
  98 MENUITEM_SETTING(sort_case, &global_settings.sort_case, NULL);
  99 MENUITEM_SETTING(sort_dir, &global_settings.sort_dir, fileview_callback);
 100 MENUITEM_SETTING(sort_file, &global_settings.sort_file, fileview_callback);
 101 MENUITEM_SETTING(interpret_numbers, &global_settings.interpret_numbers, fileview_callback);
 102 MENUITEM_SETTING(dirfilter, &global_settings.dirfilter, NULL);
 103 MENUITEM_SETTING(show_filename_ext, &global_settings.show_filename_ext, NULL);
 104 MENUITEM_SETTING(browse_current, &global_settings.browse_current, NULL);
 105 #ifdef HAVE_LCD_BITMAP
 106 MENUITEM_SETTING(show_path_in_browser, &global_settings.show_path_in_browser, NULL);
 107 #endif
 108 static int clear_start_directory(void)
 109 {
 110     strcpy(global_settings.start_directory, "/");
 111     settings_save();
 112     splash(HZ, ID2P(LANG_RESET_DONE_CLEAR));
 113     return false;
 114 }
 115 MENUITEM_FUNCTION(clear_start_directory_item, 0, ID2P(LANG_RESET_START_DIR),
 116                   clear_start_directory, NULL, NULL, Icon_file_view_menu);
 117 static int fileview_callback(int action,const struct menu_item_ex *this_item)
 118 {
 119     static int oldval;
 120     int *variable = this_item->variable;
 121     switch (action)
 122     {
 123         case ACTION_ENTER_MENUITEM: /* on entering an item */
 124             oldval = *variable;
 125             break;
 126         case ACTION_EXIT_MENUITEM: /* on exit */
 127             if (*variable != oldval)
 128                 reload_directory(); /* force reload if this has changed */
 129             break;
 130     }
 131     return action;
 132 }
 133
 134 MAKE_MENU(file_menu, ID2P(LANG_FILE), 0, Icon_file_view_menu,
 135                 &sort_case, &sort_dir, &sort_file, &interpret_numbers,
 136                 &dirfilter, &show_filename_ext, &browse_current,
 137 #ifdef HAVE_LCD_BITMAP
 138                 &show_path_in_browser,
 139 #endif
 140                 &clear_start_directory_item
 141                 );
 142 /*    FILE VIEW MENU               */
 143 /***********************************/
 144
 145
 146 /***********************************/
 147 /*    SYSTEM MENU                  */
 148
 149 /* Battery */
 150 #if BATTERY_CAPACITY_INC > 0
 151 MENUITEM_SETTING(battery_capacity, &global_settings.battery_capacity, NULL);
 152 #endif
 153 #if BATTERY_TYPES_COUNT > 1
 154 MENUITEM_SETTING(battery_type, &global_settings.battery_type, NULL);
 155 #endif
 156 #ifdef HAVE_USB_CHARGING_ENABLE
 157 static int usbcharging_callback(int action,const struct menu_item_ex *this_item)
 158 {
 159     (void)this_item;
 160     switch (action)
 161     {
 162         case ACTION_EXIT_MENUITEM: /* on exit */
 163             usb_charging_enable(global_settings.usb_charging);
 164             break;
 165     }
 166     return action;
 167 }
 168 MENUITEM_SETTING(usb_charging, &global_settings.usb_charging, usbcharging_callback);
 169 #endif /* HAVE_USB_CHARGING_ENABLE */
 170 MAKE_MENU(battery_menu, ID2P(LANG_BATTERY_MENU), 0, Icon_NOICON,
 171 #if defined(BATTERY_CAPACITY_INC) && BATTERY_CAPACITY_INC > 0
 172             &battery_capacity,
 173 #endif
 174 #if BATTERY_TYPES_COUNT > 1
 175             &battery_type,
 176 #endif
 177 #ifdef HAVE_USB_CHARGING_ENABLE
 178             &usb_charging,
 179 #endif
 180          );
 181 /* Disk */
 182 #ifdef HAVE_DISK_STORAGE
 183 MENUITEM_SETTING(disk_spindown, &global_settings.disk_spindown, NULL);
 184 #endif
 185 #ifdef HAVE_DIRCACHE
 186 static int dircache_callback(int action,const struct menu_item_ex *this_item)
 187 {
 188     (void)this_item;
 189     switch (action)
 190     {
 191         case ACTION_EXIT_MENUITEM: /* on exit */
 192             if (global_settings.dircache && !dircache_is_enabled())
 193             {
 194                 if (dircache_build(0) < 0)
 195                     splash(HZ*2, ID2P(LANG_PLEASE_REBOOT));
 196             }
 197             else if (!global_settings.dircache && dircache_is_enabled())
 198             {
 199                 dircache_disable();
 200             }
 201             break;
 202     }
 203     return action;
 204 }
 205 MENUITEM_SETTING(dircache, &global_settings.dircache, dircache_callback);
 206 #endif
 207 #if defined(HAVE_DIRCACHE) || defined(HAVE_DISK_STORAGE)
 208 MAKE_MENU(disk_menu, ID2P(LANG_DISK_MENU), 0, Icon_NOICON,
 209 #ifdef HAVE_DISK_STORAGE
 210           &disk_spindown,
 211 #endif
 212 #ifdef HAVE_DIRCACHE
 213             &dircache,
 214 #endif
 215          );
 216 #endif
 217
 218 /* Limits menu */
 219 MENUITEM_SETTING(max_files_in_dir, &global_settings.max_files_in_dir, NULL);
 220 MENUITEM_SETTING(max_files_in_playlist, &global_settings.max_files_in_playlist, NULL);
 221 #ifdef HAVE_LCD_BITMAP
 222 MENUITEM_SETTING(default_glyphs, &global_settings.glyphs_to_cache, NULL);
 223 #endif
 224 MAKE_MENU(limits_menu, ID2P(LANG_LIMITS_MENU), 0, Icon_NOICON,
 225            &max_files_in_dir, &max_files_in_playlist
 226 #ifdef HAVE_LCD_BITMAP
 227            ,&default_glyphs
 228 #endif
 229            );
 230
 231
 232 /* Keyclick menu */
 233 #if CONFIG_CODEC == SWCODEC
 234 MENUITEM_SETTING(keyclick, &global_settings.keyclick, NULL);
 235 MENUITEM_SETTING(keyclick_repeats, &global_settings.keyclick_repeats, NULL);
 236 #ifdef HAVE_HARDWARE_CLICK
 237 MENUITEM_SETTING(keyclick_hardware, &global_settings.keyclick_hardware, NULL);
 238 MAKE_MENU(keyclick_menu, ID2P(LANG_KEYCLICK), 0, Icon_NOICON,
 239            &keyclick, &keyclick_hardware, &keyclick_repeats);
 240 #else
 241 MAKE_MENU(keyclick_menu, ID2P(LANG_KEYCLICK), 0, Icon_NOICON,
 242            &keyclick, &keyclick_repeats);
 243 #endif
 244 #endif
 245
 246
 247 #if CONFIG_CODEC == MAS3507D
 248 void dac_line_in(bool enable);
 249 static int linein_callback(int action,const struct menu_item_ex *this_item)
 250 {
 251     (void)this_item;
 252     switch (action)
 253     {
 254         case ACTION_EXIT_MENUITEM: /* on exit */
 255 #ifndef SIMULATOR
 256             dac_line_in(global_settings.line_in);
 257 #endif
 258             break;
 259     }
 260     return action;
 261 }
 262 MENUITEM_SETTING(line_in, &global_settings.line_in, linein_callback);
 263 #endif
 264 #if CONFIG_CHARGING
 265 MENUITEM_SETTING(car_adapter_mode, &global_settings.car_adapter_mode, NULL);
 266 #endif
 267 #ifdef IPOD_ACCESSORY_PROTOCOL
 268 MENUITEM_SETTING(serial_bitrate, &global_settings.serial_bitrate, NULL);
 269 #endif
 270 #ifdef HAVE_ACCESSORY_SUPPLY
 271 MENUITEM_SETTING(accessory_supply, &global_settings.accessory_supply, NULL);
 272 #endif
 273 #ifdef HAVE_LINEOUT_POWEROFF
 274 MENUITEM_SETTING(lineout_onoff, &global_settings.lineout_active, NULL);
 275 #endif
 276 #ifdef USB_ENABLE_HID
 277 MENUITEM_SETTING(usb_hid, &global_settings.usb_hid, NULL);
 278 MENUITEM_SETTING(usb_keypad_mode, &global_settings.usb_keypad_mode, NULL);
 279 #endif
 280 #if defined(USB_ENABLE_STORAGE) && defined(HAVE_MULTIDRIVE)
 281 MENUITEM_SETTING(usb_skip_first_drive, &global_settings.usb_skip_first_drive, NULL);
 282 #endif
 283
 284 #ifdef HAVE_MORSE_INPUT
 285 MENUITEM_SETTING(morse_input, &global_settings.morse_input, NULL);
 286 #endif
 287
 288 #ifdef HAVE_BUTTON_LIGHT
 289 MENUITEM_SETTING(buttonlight_timeout, &global_settings.buttonlight_timeout, NULL);
 290 #endif
 291
 292 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 293 MENUITEM_SETTING(buttonlight_brightness, &global_settings.buttonlight_brightness, NULL);
 294 #endif
 295
 296 #ifdef HAVE_TOUCHPAD_SENSITIVITY_SETTING
 297 MENUITEM_SETTING(touchpad_sensitivity, &global_settings.touchpad_sensitivity, NULL);
 298 #endif
 299
 300 MAKE_MENU(system_menu, ID2P(LANG_SYSTEM),
 301           0, Icon_System_menu,
 302 #if (BATTERY_CAPACITY_INC > 0) || (BATTERY_TYPES_COUNT > 1)
 303             &battery_menu,
 304 #endif
 305 #if defined(HAVE_DIRCACHE) || defined(HAVE_DISK_STORAGE)
 306             &disk_menu,
 307 #endif
 308             &limits_menu,
 309 #ifdef HAVE_MORSE_INPUT
 310             &morse_input,
 311 #endif
 312 #if CONFIG_CODEC == MAS3507D
 313             &line_in,
 314 #endif
 315 #if CONFIG_CHARGING
 316             &car_adapter_mode,
 317 #endif
 318 #ifdef IPOD_ACCESSORY_PROTOCOL
 319             &serial_bitrate,
 320 #endif
 321 #ifdef HAVE_ACCESSORY_SUPPLY
 322             &accessory_supply,
 323 #endif
 324 #ifdef HAVE_LINEOUT_POWEROFF
 325             &lineout_onoff,
 326 #endif
 327 #ifdef HAVE_BUTTON_LIGHT
 328             &buttonlight_timeout,
 329 #endif
 330 #ifdef HAVE_BUTTONLIGHT_BRIGHTNESS
 331             &buttonlight_brightness,
 332 #endif
 333 #if CONFIG_CODEC == SWCODEC
 334             &keyclick_menu,
 335 #endif
 336 #ifdef HAVE_TOUCHPAD_SENSITIVITY_SETTING
 337             &touchpad_sensitivity,
 338 #endif
 339 #ifdef USB_ENABLE_HID
 340             &usb_hid,
 341             &usb_keypad_mode,
 342 #endif
 343 #if defined(USB_ENABLE_STORAGE) && defined(HAVE_MULTIDRIVE)
 344             &usb_skip_first_drive,
 345 #endif
 346          );
 347
 348 /*    SYSTEM MENU                  */
 349 /***********************************/
 350
 351 /***********************************/
 352 /*    STARTUP/SHUTDOWN MENU      */
 353
 354 /* sleep timer option */
 355 const char* sleep_timer_formatter(char* buffer, size_t buffer_size,
 356                                          int value, const char* unit)
 357 {
 358     (void) unit;
 359     int minutes, hours;
 360
 361     if (value) {
 362         hours = value / 60;
 363         minutes = value - (hours * 60);
 364         snprintf(buffer, buffer_size, "%d:%02d", hours, minutes);
 365         return buffer;
 366     } else {
 367         return str(LANG_OFF);
 368     }
 369 }
 370
 371 static void sleep_timer_set(int minutes)
 372 {
 373     if (minutes)
 374         global_settings.sleeptimer_duration = minutes;
 375     set_sleep_timer(minutes * 60);
 376 }
 377
 378 static int sleep_timer(void)
 379 {
 380     int minutes = global_settings.sleeptimer_duration;
 381     if (get_sleep_timer())
 382         sleep_timer_set(0);
 383     else
 384         set_int(str(LANG_SLEEP_TIMER), "", UNIT_MIN, &minutes,
 385                 &sleep_timer_set, 5, 0, 300, sleep_timer_formatter);
 386     return 0;
 387 }
 388
 389 static int seconds_to_min(int secs)
 390 {
 391     return (secs + 10) / 60;  /* round up for 50+ seconds */
 392 }
 393
 394 static char* sleep_timer_getname(int selected_item, void * data, char *buffer)
 395 {
 396     (void)selected_item;
 397     (void)data;
 398     int sec = get_sleep_timer();
 399     char timer_buf[10];
 400     /* we have no sprintf, so MAX_PATH is a guess */
 401     if (sec > 0)
 402     {   /* show cancel and countdown if running */
 403         snprintf(buffer, MAX_PATH, "%s (%s)",
 404                  str(LANG_SLEEP_TIMER_CANCEL_CURRENT),
 405                  sleep_timer_formatter(timer_buf, sizeof(timer_buf),
 406                                        seconds_to_min(sec), NULL));
 407     }
 408     else
 409         snprintf(buffer, MAX_PATH, "%s", str(LANG_SLEEP_TIMER));
 410
 411     return buffer;
 412 }
 413
 414 static int sleep_timer_voice(int selected_item, void*data)
 415 {
 416     (void)selected_item;
 417     (void)data;
 418     int seconds = get_sleep_timer();
 419     if (seconds > 0)
 420     {
 421         long talk_ids[] = {
 422             LANG_SLEEP_TIMER_CANCEL_CURRENT,
 423             VOICE_PAUSE,
 424             seconds_to_min(seconds) | UNIT_MIN << UNIT_SHIFT,
 425             TALK_FINAL_ID
 426         };
 427         talk_idarray(talk_ids, true);
 428     }
 429     else
 430         talk_id(LANG_SLEEP_TIMER, true);
 431     return 0;
 432 }
 433
 434 MENUITEM_SETTING(start_screen, &global_settings.start_in_screen, NULL);
 435 MENUITEM_SETTING(poweroff, &global_settings.poweroff, NULL);
 436 MENUITEM_FUNCTION_DYNTEXT(sleep_timer_call, 0, sleep_timer, NULL,
 437                           sleep_timer_getname, sleep_timer_voice, NULL, NULL,
 438                           Icon_Menu_setting);
 439                           /* make it look like a setting to the user */
 440 MENUITEM_SETTING(sleeptimer_on_startup,
 441                  &global_settings.sleeptimer_on_startup, NULL);
 442 MENUITEM_SETTING(keypress_restarts_sleeptimer,
 443                  &global_settings.keypress_restarts_sleeptimer, NULL);
 444
 445 MAKE_MENU(startup_shutdown_menu, ID2P(LANG_STARTUP_SHUTDOWN),
 446           0, Icon_System_menu,
 447             &start_screen,
 448             &poweroff,
 449             &sleep_timer_call,
 450             &sleeptimer_on_startup,
 451             &keypress_restarts_sleeptimer
 452          );
 453
 454 /*    STARTUP/SHUTDOWN MENU      */
 455 /***********************************/
 456
 457 /***********************************/
 458 /*    BOOKMARK MENU                */
 459 static int bmark_callback(int action,const struct menu_item_ex *this_item)
 460 {
 461     (void)this_item;
 462     switch (action)
 463     {
 464         case ACTION_EXIT_MENUITEM: /* on exit */
 465             if(global_settings.autocreatebookmark ==  BOOKMARK_RECENT_ONLY_YES ||
 466                global_settings.autocreatebookmark ==  BOOKMARK_RECENT_ONLY_ASK)
 467             {
 468                 if(global_settings.usemrb == BOOKMARK_NO)
 469                     global_settings.usemrb = BOOKMARK_YES;
 470
 471             }
 472             break;
 473     }
 474     return action;
 475 }
 476 MENUITEM_SETTING(autocreatebookmark,
 477                  &global_settings.autocreatebookmark, bmark_callback);
 478 MENUITEM_SETTING(autoupdatebookmark, &global_settings.autoupdatebookmark, NULL);
 479 MENUITEM_SETTING(autoloadbookmark, &global_settings.autoloadbookmark, NULL);
 480 MENUITEM_SETTING(usemrb, &global_settings.usemrb, NULL);
 481 MAKE_MENU(bookmark_settings_menu, ID2P(LANG_BOOKMARK_SETTINGS), 0,
 482           Icon_Bookmark,
 483           &autocreatebookmark, &autoupdatebookmark, &autoloadbookmark, &usemrb);
 484 /*    BOOKMARK MENU                */
 485 /***********************************/
 486
 487 /***********************************/
 488 /*    AUTORESUME MENU              */
 489 #ifdef HAVE_TAGCACHE
 490 #if CONFIG_CODEC == SWCODEC
 491
 492 static int autoresume_callback(int action, const struct menu_item_ex *this_item)
 493 {
 494     (void)this_item;
 495
 496     if (action == ACTION_EXIT_MENUITEM  /* on exit */
 497         && global_settings.autoresume_enable
 498         && !tagcache_is_usable())
 499     {
 500         static const char *lines[] = {ID2P(LANG_TAGCACHE_BUSY),
 501                                       ID2P(LANG_TAGCACHE_FORCE_UPDATE)};
 502         static const struct text_message message = {lines, 2};
 503
 504         if (gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES)
 505             tagcache_rebuild_with_splash();
 506     }
 507     return action;
 508 }
 509
 510 static int autoresume_nexttrack_callback(int action,
 511                                          const struct menu_item_ex *this_item)
 512 {
 513     (void)this_item;
 514     static int oldval = 0;
 515     switch (action)
 516     {
 517         case ACTION_ENTER_MENUITEM:
 518             oldval = global_settings.autoresume_automatic;
 519             break;
 520         case ACTION_EXIT_MENUITEM:
 521             if (global_settings.autoresume_automatic == AUTORESUME_NEXTTRACK_CUSTOM
 522                 && kbd_input ((char*) &global_settings.autoresume_paths,
 523                               MAX_PATHNAME+1) < 0)
 524             {
 525                 global_settings.autoresume_automatic = oldval;
 526             }
 527     }
 528     return action;
 529 }
 530
 531 MENUITEM_SETTING(autoresume_enable, &global_settings.autoresume_enable,
 532                  autoresume_callback);
 533 MENUITEM_SETTING(autoresume_automatic, &global_settings.autoresume_automatic,
 534                  autoresume_nexttrack_callback);
 535
 536 MAKE_MENU(autoresume_menu, ID2P(LANG_AUTORESUME),
 537           0, Icon_NOICON,
 538           &autoresume_enable, &autoresume_automatic);
 539
 540 #endif /* CONFIG_CODEC == SWCODEC */
 541 #endif /* HAVE_TAGCACHE */
 542 /*    AUTORESUME MENU              */
 543 /***********************************/
 544
 545 /***********************************/
 546 /*    VOICE MENU                   */
 547 static int talk_callback(int action,const struct menu_item_ex *this_item);
 548 MENUITEM_SETTING(talk_menu_item, &global_settings.talk_menu, NULL);
 549 MENUITEM_SETTING(talk_dir_item, &global_settings.talk_dir, NULL);
 550 MENUITEM_SETTING(talk_dir_clip_item, &global_settings.talk_dir_clip, talk_callback);
 551 MENUITEM_SETTING(talk_file_item, &global_settings.talk_file, NULL);
 552 MENUITEM_SETTING(talk_file_clip_item, &global_settings.talk_file_clip, talk_callback);
 553 static int talk_callback(int action,const struct menu_item_ex *this_item)
 554 {
 555     static int oldval = 0;
 556     switch (action)
 557     {
 558         case ACTION_ENTER_MENUITEM:
 559             oldval = global_settings.talk_file_clip;
 560             break;
 561         case ACTION_EXIT_MENUITEM:
 562 #ifdef HAVE_CROSSFADE
 563             audio_set_crossfade(global_settings.crossfade);
 564 #endif
 565             if (this_item == &talk_dir_clip_item)
 566                 break;
 567             if (!oldval && global_settings.talk_file_clip)
 568             {
 569                 /* force reload if newly talking thumbnails,
 570                 because the clip presence is cached only if enabled */
 571                 reload_directory();
 572             }
 573             break;
 574     }
 575     return action;
 576 }
 577 MENUITEM_SETTING(talk_filetype_item, &global_settings.talk_filetype, NULL);
 578 MENUITEM_SETTING(talk_battery_level_item,
 579                  &global_settings.talk_battery_level, NULL);
 580 MAKE_MENU(voice_settings_menu, ID2P(LANG_VOICE), 0, Icon_Voice,
 581           &talk_menu_item, &talk_dir_item, &talk_dir_clip_item,
 582           &talk_file_item, &talk_file_clip_item, &talk_filetype_item,
 583           &talk_battery_level_item);
 584 /*    VOICE MENU                   */
 585 /***********************************/
 586
 587
 588 /***********************************/
 589 /*    HOTKEY MENU                  */
 590 #ifdef HAVE_HOTKEY
 591 MENUITEM_SETTING(hotkey_wps_item, &global_settings.hotkey_wps, NULL);
 592 MENUITEM_SETTING(hotkey_tree_item, &global_settings.hotkey_tree, NULL);
 593 MAKE_MENU(hotkey_menu, ID2P(LANG_HOTKEY), 0, Icon_NOICON,
 594             &hotkey_wps_item, &hotkey_tree_item);
 595 #endif /*have_hotkey */
 596 /*    HOTKEY MENU                  */
 597 /***********************************/
 598
 599
 600 /***********************************/
 601 /*    SETTINGS MENU                */
 602
 603 static struct browse_folder_info langs = { LANG_DIR, SHOW_LNG };
 604
 605 MENUITEM_FUNCTION(browse_langs, MENU_FUNC_USEPARAM, ID2P(LANG_LANGUAGE),
 606                   browse_folder, (void*)&langs, NULL, Icon_Language);
 607
 608 MAKE_MENU(settings_menu_item, ID2P(LANG_GENERAL_SETTINGS), 0,
 609           Icon_General_settings_menu,
 610           &playlist_settings, &file_menu,
 611 #ifdef HAVE_TAGCACHE
 612           &tagcache_menu,
 613 #endif
 614           &display_menu, &system_menu,
 615           &startup_shutdown_menu,
 616           &bookmark_settings_menu,
 617 #ifdef HAVE_TAGCACHE
 618 #if CONFIG_CODEC == SWCODEC
 619           &autoresume_menu,
 620 #endif
 621 #endif
 622           &browse_langs, &voice_settings_menu,
 623 #ifdef HAVE_HOTKEY
 624           &hotkey_menu,
 625 #endif
 626           );
 627 /*    SETTINGS MENU                */
 628 /***********************************/