/** * Displays a menu for editing the trigger settings. */ bool rectrigger(void) { int exit_request = false; enum trigger_menu_option selected = TRIGGER_MODE; bool retval = false; int old_x_margin, old_y_margin; #define TRIGGER_MODE_COUNT 3 static const unsigned char *trigger_modes[] = { ID2P(LANG_OFF), ID2P(LANG_RECORD_TRIG_NOREARM), ID2P(LANG_RECORD_TRIG_REARM) }; #define PRERECORD_TIMES_COUNT 31 static const unsigned char *prerecord_times[] = { ID2P(LANG_OFF),"1s","2s", "3s", "4s", "5s", "6s", "7s", "8s", "9s", "10s", "11s", "12s", "13s", "14s", "15s", "16s", "17s", "18s", "19s", "20s", "21s", "22s", "23s", "24s", "25s", "26s", "27s", "28s", "29s", "30s" }; static const unsigned char *option_name[] = { [TRIGGER_MODE] = ID2P(LANG_RECORD_TRIGGER_MODE), [PRERECORD_TIME] = ID2P(LANG_RECORD_PRERECORD_TIME), [START_THRESHOLD] = ID2P(LANG_RECORD_START_THRESHOLD), [START_DURATION] = ID2P(LANG_RECORD_MIN_DURATION), [STOP_THRESHOLD] = ID2P(LANG_RECORD_STOP_THRESHOLD), [STOP_POSTREC] = ID2P(LANG_RECORD_STOP_POSTREC), [STOP_GAP] = ID2P(LANG_RECORD_STOP_GAP) };
/* Start playback of a playlist, checking for bookmark autoload, modified * playlists, etc., as required. Returns false if playback wasn't started, * or started via bookmark autoload, true otherwise. * * Pointers to both the full pathname and the separated parts needed to * avoid allocating yet another path buffer on the stack (and save some * code; the caller typically needs to create the full pathname anyway)... */ bool ft_play_playlist(char* pathname, char* dirname, char* filename) { if (global_settings.party_mode && audio_status()) { splash(HZ, ID2P(LANG_PARTY_MODE)); return false; } if (bookmark_autoload(pathname)) { return false; } splash(0, ID2P(LANG_WAIT)); /* about to create a new current playlist... allow user to cancel the operation */ if (!warn_on_pl_erase()) return false; if (playlist_create(dirname, filename) != -1) { if (global_settings.playlist_shuffle) { playlist_shuffle(current_tick, -1); } playlist_start(0, 0); return true; } return false; }
static void ft_load_font(char *file) { int current_font_id; enum screen_type screen = SCREEN_MAIN; #if NB_SCREENS > 1 MENUITEM_STRINGLIST(menu, ID2P(LANG_CUSTOM_FONT), NULL, ID2P(LANG_MAIN_SCREEN), ID2P(LANG_REMOTE_SCREEN)) switch (do_menu(&menu, NULL, NULL, false)) { case 0: /* main lcd */ screen = SCREEN_MAIN; set_file(file, (char *)global_settings.font_file, MAX_FILENAME); break; case 1: /* remote */ screen = SCREEN_REMOTE; set_file(file, (char *)global_settings.remote_font_file, MAX_FILENAME); break; } #else set_file(file, (char *)global_settings.font_file, MAX_FILENAME); #endif splash(0, ID2P(LANG_WAIT)); current_font_id = global_status.font_id[screen]; if (current_font_id >= 0) font_unload(current_font_id); current_font_id = font_load(file); if(screen==SCREEN_MAIN) font_set_ui(current_font_id); global_status.font_id[screen] = current_font_id; viewportmanager_theme_changed(THEME_UI_VIEWPORT); }
static char *get_wps_item_name(int selected_item, void * data, char *buffer) { (void)selected_item; (void)data; (void)buffer; if (audio_status()) return ID2P(LANG_NOW_PLAYING); return ID2P(LANG_RESUME_PLAYBACK); }
static bool lcd_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { #ifdef CONFIG_BACKLIGHT { ID2P(LANG_BACKLIGHT), backlight_timer }, #ifdef HAVE_CHARGING { ID2P(LANG_BACKLIGHT_ON_WHEN_CHARGING), backlight_on_when_charging }, #endif { ID2P(LANG_CAPTION_BACKLIGHT), caption_backlight }, #if CONFIG_BACKLIGHT == BL_IRIVER { ID2P(LANG_BACKLIGHT_FADE_IN), backlight_fade_in }, { ID2P(LANG_BACKLIGHT_FADE_OUT), backlight_fade_out }, #endif #endif /* CONFIG_BACKLIGHT */ { ID2P(LANG_CONTRAST), contrast }, #ifdef HAVE_LCD_BITMAP { ID2P(LANG_INVERT), invert }, { ID2P(LANG_FLIP_DISPLAY), flip_display }, { ID2P(LANG_INVERT_CURSOR), invert_cursor }, #endif }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static bool system_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_BATTERY_MENU), battery_settings_menu }, #ifndef HAVE_MMC { ID2P(LANG_DISK_MENU), disk_settings_menu }, #endif #ifdef HAVE_RTC { ID2P(LANG_TIME_MENU), time_settings_menu }, #endif { ID2P(LANG_POWEROFF_IDLE), poweroff_idle_timer }, { ID2P(LANG_SLEEP_TIMER), sleeptimer_screen }, #ifdef HAVE_ALARM_MOD { ID2P(LANG_ALARM_MOD_ALARM_MENU), alarm_screen }, #endif { ID2P(LANG_LIMITS_MENU), limits_settings_menu }, #if CONFIG_CODEC == MAS3507D { ID2P(LANG_LINE_IN), line_in }, #endif #ifdef HAVE_CHARGING { ID2P(LANG_CAR_ADAPTER_MODE), car_adapter_mode }, #endif }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
/* ----------------------------------------------------------------------- */ bool bookmark_autobookmark(bool prompt_ok) { char* bookmark; bool update; if (!bookmark_is_bookmarkable_state()) return false; audio_pause(); /* first pause playback */ update = (global_settings.autoupdatebookmark && bookmark_exists()); bookmark = create_bookmark(); #if CONFIG_CODEC != SWCODEC /* Workaround for inability to speak when paused: all callers will just do audio_stop() when we return, so we can do it right away. This makes it possible to speak the "Create a Bookmark?" prompt and the "Bookmark Created" splash. */ audio_stop(); #endif if (update) return write_bookmark(true, bookmark); switch (global_settings.autocreatebookmark) { case BOOKMARK_YES: return write_bookmark(true, bookmark); case BOOKMARK_NO: return false; case BOOKMARK_RECENT_ONLY_YES: return write_bookmark(false, bookmark); } #ifdef HAVE_LCD_BITMAP const char *lines[]={ID2P(LANG_AUTO_BOOKMARK_QUERY)}; const struct text_message message={lines, 1}; #else const char *lines[]={ID2P(LANG_AUTO_BOOKMARK_QUERY), str(LANG_CONFIRM_WITH_BUTTON)}; const struct text_message message={lines, 2}; #endif if(prompt_ok && gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES) { if (global_settings.autocreatebookmark == BOOKMARK_RECENT_ONLY_ASK) return write_bookmark(false, bookmark); else return write_bookmark(true, bookmark); } return false; }
static bool display_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { #ifdef HAVE_LCD_BITMAP { ID2P(LANG_CUSTOM_FONT), font_browse }, #endif { ID2P(LANG_WHILE_PLAYING), custom_wps_browse }, { ID2P(LANG_LCD_MENU), lcd_settings_menu }, #ifdef HAVE_REMOTE_LCD { ID2P(LANG_LCD_REMOTE_MENU), lcd_remote_settings_menu }, #endif { ID2P(LANG_SCROLL_MENU), scroll_settings_menu }, #ifdef HAVE_LCD_BITMAP { ID2P(LANG_BARS_MENU), bars_settings_menu }, { ID2P(LANG_PM_MENU), peak_meter_menu }, { ID2P(LANG_BIDI_SUPPORT), bidi_support }, #endif }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
bool settings_save_config(int options) { char filename[MAX_PATH]; char *folder, *namebase; switch (options) { case SETTINGS_SAVE_THEME: folder = THEME_DIR; namebase = "theme"; break; #ifdef HAVE_RECORDING case SETTINGS_SAVE_RECPRESETS: folder = RECPRESETS_DIR; namebase = "recording"; break; #endif #if CONFIG_CODEC == SWCODEC case SETTINGS_SAVE_EQPRESET: folder = EQS_DIR; namebase = "eq"; break; #endif case SETTINGS_SAVE_SOUND: folder = ROCKBOX_DIR; namebase = "sound"; break; default: folder = ROCKBOX_DIR; namebase = "config"; break; } create_numbered_filename(filename, folder, namebase, ".cfg", 2 IF_CNFN_NUM_(, NULL)); /* allow user to modify filename */ while (true) { if (!kbd_input(filename, sizeof filename)) { break; } else { return false; } } if (settings_write_config(filename, options)) splash(HZ, ID2P(LANG_SETTINGS_SAVED)); else splash(HZ, ID2P(LANG_FAILED)); return true; }
static int dirs_to_scan(void) { if (folder_select(global_settings.tagcache_scan_paths, sizeof(global_settings.tagcache_scan_paths))) { static const char *lines[] = {ID2P(LANG_TAGCACHE_BUSY), ID2P(LANG_TAGCACHE_FORCE_UPDATE)}; static const struct text_message message = {lines, 2}; if (gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES) tagcache_rebuild_with_splash(); } return 0; }
static int clear_start_directory(void) { strcpy(global_settings.start_directory, "/"); settings_save(); splash(HZ, ID2P(LANG_RESET_DONE_CLEAR)); return false; }
static bool limits_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_MAX_FILES_IN_DIR), max_files_in_dir }, { ID2P(LANG_MAX_FILES_IN_PLAYLIST), max_files_in_playlist }, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static bool time_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_TIME), timedate_set }, { ID2P(LANG_TIMEFORMAT), timeformat_set }, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static int wpsscrn(void* param) { int ret_val = GO_TO_PREVIOUS; (void)param; if (audio_status()) { talk_shutup(); ret_val = gui_wps_show(); } else if ( global_status.resume_index != -1 ) { DEBUGF("Resume index %X offset %lX\n", global_status.resume_index, (unsigned long)global_status.resume_offset); if (playlist_resume() != -1) { playlist_start(global_status.resume_index, global_status.resume_offset); ret_val = gui_wps_show(); } } else { splash(HZ*2, ID2P(LANG_NOTHING_TO_RESUME)); } return ret_val; }
static int volume_limit_callback(int action,const struct menu_item_ex *this_item) { (void)this_item; static struct int_setting volume_limit_int_setting; volume_limit_int_setting.option_callback = NULL; volume_limit_int_setting.unit = UNIT_DB; volume_limit_int_setting.min = sound_min(SOUND_VOLUME); volume_limit_int_setting.max = sound_max(SOUND_VOLUME); volume_limit_int_setting.step = sound_steps(SOUND_VOLUME); volume_limit_int_setting.formatter = NULL; volume_limit_int_setting.get_talk_id = get_dec_talkid; struct settings_list setting; setting.flags = F_BANFROMQS|F_INT_SETTING|F_T_INT|F_NO_WRAP; setting.lang_id = LANG_VOLUME_LIMIT; setting.default_val.int_ = sound_max(SOUND_VOLUME); setting.int_setting = &volume_limit_int_setting; switch (action) { case ACTION_ENTER_MENUITEM: setting.setting = &global_settings.volume_limit; option_screen(&setting, NULL, false, ID2P(LANG_VOLUME_LIMIT)); case ACTION_EXIT_MENUITEM: /* on exit */ setvol(); break; } return action; }
static int wpsscrn(void* param) { int ret_val = GO_TO_PREVIOUS; (void)param; push_current_activity(ACTIVITY_WPS); if (audio_status()) { talk_shutup(); ret_val = gui_wps_show(); } else if ( global_status.resume_index != -1 ) { DEBUGF("Resume index %X crc32 %lX offset %lX\n", global_status.resume_index, (unsigned long)global_status.resume_crc32, (unsigned long)global_status.resume_offset); if (playlist_resume() != -1) { playlist_resume_track(global_status.resume_index, global_status.resume_crc32, global_status.resume_elapsed, global_status.resume_offset); ret_val = gui_wps_show(); } } else { splash(HZ*2, ID2P(LANG_NOTHING_TO_RESUME)); } pop_current_activity(); return ret_val; }
static void gui_quickscreen_draw(const struct gui_quickscreen *qs, struct screen *display, struct viewport *parent, struct viewport vps[QUICKSCREEN_ITEM_COUNT], struct viewport *vp_icons) { int i; char buf[MAX_PATH]; unsigned const char *title, *value; void *setting; int temp; display->set_viewport(parent); display->clear_viewport(); for (i = 0; i < QUICKSCREEN_ITEM_COUNT; i++) { struct viewport *vp = &vps[i]; if (!qs->items[i]) continue; display->set_viewport(vp); display->scroll_stop(vp); title = P2STR(ID2P(qs->items[i]->lang_id)); setting = qs->items[i]->setting; temp = option_value_as_int(qs->items[i]); value = option_get_valuestring(qs->items[i], buf, MAX_PATH, temp); if (viewport_get_nb_lines(vp) < 2) { char text[MAX_PATH]; snprintf(text, MAX_PATH, "%s: %s", title, value); display->puts_scroll(0, 0, text); } else { display->puts_scroll(0, 0, title); display->puts_scroll(0, 1, value); } display->update_viewport(); } /* draw the icons */ display->set_viewport(vp_icons); display->mono_bitmap(bitmap_icons_7x8[Icon_UpArrow], (vp_icons->width/2) - 4, 0, 7, 8); display->mono_bitmap(bitmap_icons_7x8[Icon_FastForward], vp_icons->width - 8, (vp_icons->height/2) - 4, 7, 8); display->mono_bitmap(bitmap_icons_7x8[Icon_FastBackward], 0, (vp_icons->height/2) - 4, 7, 8); display->mono_bitmap(bitmap_icons_7x8[Icon_DownArrow], (vp_icons->width/2) - 4, vp_icons->height - 8, 7, 8); display->set_viewport(parent); display->update_viewport(); display->set_viewport(NULL); }
static int autoresume_callback(int action, const struct menu_item_ex *this_item) { (void)this_item; if (action == ACTION_EXIT_MENUITEM /* on exit */ && global_settings.autoresume_enable && !tagcache_is_usable()) { static const char *lines[] = {ID2P(LANG_TAGCACHE_BUSY), ID2P(LANG_TAGCACHE_FORCE_UPDATE)}; static const struct text_message message = {lines, 2}; if (gui_syncyesno_run(&message, NULL, NULL) == YESNO_YES) tagcache_rebuild_with_splash(); } return action; }
static bool ff_rewind_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_FFRW_STEP), ff_rewind_min_step }, { ID2P(LANG_FFRW_ACCEL), ff_rewind_accel }, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static bool voice_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_VOICE_MENU), voice_menus }, { ID2P(LANG_VOICE_DIR), voice_dirs }, { ID2P(LANG_VOICE_FILE), voice_files } }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
bool manage_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_CUSTOM_CFG), custom_cfg_browse }, { ID2P(LANG_FIRMWARE), firmware_browse }, { ID2P(LANG_RESET), reset_settings }, { ID2P(LANG_SAVE_SETTINGS), settings_save_config }, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static bool disk_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_SPINDOWN), spindown }, #ifdef HAVE_ATA_POWER_OFF { ID2P(LANG_POWEROFF), poweroff }, #endif }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static bool lcd_remote_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_BACKLIGHT), remote_backlight_timer }, { ID2P(LANG_CONTRAST), remote_contrast }, { ID2P(LANG_INVERT), remote_invert }, { ID2P(LANG_FLIP_DISPLAY), remote_flip_display }, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static bool replaygain_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_REPLAYGAIN_ENABLE), replaygain }, { ID2P(LANG_REPLAYGAIN_NOCLIP), replaygain_noclip }, { ID2P(LANG_REPLAYGAIN_MODE), replaygain_mode }, { ID2P(LANG_REPLAYGAIN_PREAMP), replaygain_preamp }, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
/* helper function to remove a non-empty directory */ static int remove_dir(char* dirname, int len) { int result = 0; DIR* dir; int dirlen = strlen(dirname); dir = opendir(dirname); if (!dir) return -1; /* open error */ while(true) { struct dirent* entry; /* walk through the directory content */ entry = readdir(dir); if (!entry) break; struct dirinfo info = dir_get_info(dir, entry); dirname[dirlen] ='\0'; /* inform the user which dir we're deleting */ splash(0, dirname); /* append name to current directory */ snprintf(dirname+dirlen, len-dirlen, "/%s", entry->d_name); if (info.attribute & ATTR_DIRECTORY) { /* remove a subdirectory */ if (!strcmp((char *)entry->d_name, ".") || !strcmp((char *)entry->d_name, "..")) continue; /* skip these */ result = remove_dir(dirname, len); /* recursion */ if (result) break; /* or better continue, delete what we can? */ } else { /* remove a file */ draw_slider(); result = remove(dirname); } if(ACTION_STD_CANCEL == get_action(CONTEXT_STD,TIMEOUT_NOBLOCK)) { splash(HZ, ID2P(LANG_CANCEL)); result = -1; break; } } closedir(dir); if (!result) { /* remove the now empty directory */ dirname[dirlen] = '\0'; /* terminate to original length */ result = rmdir(dirname); } return result; }
static bool bookmark_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_BOOKMARK_SETTINGS_AUTOCREATE), autocreatebookmark}, { ID2P(LANG_BOOKMARK_SETTINGS_AUTOLOAD), autoloadbookmark}, { ID2P(LANG_BOOKMARK_SETTINGS_MAINTAIN_RECENT_BOOKMARKS), useMRB}, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static bool bars_settings_menu(void) { int m; bool result; static const struct menu_item items[] = { { ID2P(LANG_SCROLL_BAR), scroll_bar }, { ID2P(LANG_STATUS_BAR), status_bar }, #if CONFIG_KEYPAD == RECORDER_PAD { ID2P(LANG_BUTTON_BAR), button_bar }, #endif { ID2P(LANG_VOLUME_DISPLAY), volume_type }, { ID2P(LANG_BATTERY_DISPLAY), battery_display }, }; m=menu_init( items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL); result = menu_run(m); menu_exit(m); return result; }
static int timestretch_callback(int action,const struct menu_item_ex *this_item) { switch (action) { case ACTION_EXIT_MENUITEM: /* on exit */ if (global_settings.timestretch_enabled && !dsp_timestretch_available()) splash(HZ*2, ID2P(LANG_PLEASE_REBOOT)); break; } lowlatency_callback(action, this_item); return action; }
/* share code for file and directory deletion, saves space */ static bool delete_file_dir(void) { char file_to_delete[MAX_PATH]; strcpy(file_to_delete, selected_file); const char *lines[]={ ID2P(LANG_REALLY_DELETE), file_to_delete }; const char *yes_lines[]={ ID2P(LANG_DELETING), file_to_delete }; const struct text_message message={lines, 2}; const struct text_message yes_message={yes_lines, 2}; if(gui_syncyesno_run(&message, &yes_message, NULL)!=YESNO_YES) return false; splash(0, str(LANG_DELETING)); int res; if (selected_file_attr & ATTR_DIRECTORY) /* true if directory */ { char pathname[MAX_PATH]; /* space to go deep */ cpu_boost(true); strlcpy(pathname, file_to_delete, sizeof(pathname)); res = remove_dir(pathname, sizeof(pathname)); cpu_boost(false); } else res = remove(file_to_delete); if (!res) onplay_result = ONPLAY_RELOAD_DIR; return (res == 0); }
static int set_rating_inline(void) { struct mp3entry* id3 = audio_current_track(); if (id3 && id3->tagcache_idx && global_settings.runtimedb) { set_int_ex(str(LANG_MENU_SET_RATING), "", UNIT_INT, (void*)(&id3->rating), NULL, 1, 0, 10, NULL, NULL); tagcache_update_numeric(id3->tagcache_idx-1, tag_rating, id3->rating); } else splash(HZ*2, ID2P(LANG_ID3_NO_INFO)); return 0; }