settings_menu.c

编译后直接运行的ＭＰ３播放器全部Ｃ语言源代码 一个包含FAT文件系统、系统引导 Boot、FLASH Driver等内容的

    return set_bool( str(LANG_SCROLL_BAR), &global_settings.scrollbar );
}

static bool status_bar(void)
{
    return set_bool( str(LANG_STATUS_BAR), &global_settings.statusbar );
}
#endif

static bool ff_rewind_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_FFRW_STEP), ff_rewind_min_step },
        { str(LANG_FFRW_ACCEL), ff_rewind_accel },
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);

    return result;
}

static bool playback_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_SHUFFLE), shuffle },
        { str(LANG_REPEAT), repeat_mode },
        { str(LANG_PLAY_SELECTED), play_selected },
        { str(LANG_RESUME), resume },
        { str(LANG_WIND_MENU), ff_rewind_settings_menu },
        { str(LANG_MP3BUFFER_MARGIN), buffer_margin },
        { str(LANG_FADE_ON_STOP), set_fade_on_stop },
    };

    bool old_shuffle = global_settings.playlist_shuffle;

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);

    if (old_shuffle != global_settings.playlist_shuffle)
    {
        if (global_settings.playlist_shuffle)
        {
            playlist_randomise(NULL, current_tick, true);
        }
        else
        {
            playlist_sort(NULL, true);
        }
    }
    return result;
}

static bool bookmark_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_BOOKMARK_SETTINGS_AUTOCREATE), autocreatebookmark},
        { str(LANG_BOOKMARK_SETTINGS_AUTOLOAD), autoloadbookmark},
        { str(LANG_BOOKMARK_SETTINGS_MAINTAIN_RECENT_BOOKMARKS), useMRB},
    };

    m=menu_init( items, sizeof items / sizeof(struct menu_items) );
    result = menu_run(m);
    menu_exit(m);

    return result;
}
static bool reset_settings(void)
{
    bool done=false;
    int line;
 
    lcd_clear_display();

#ifdef HAVE_LCD_CHARCELLS
    line = 0;
#else
    line = 1;
    lcd_puts(0,0,str(LANG_RESET_ASK_RECORDER));
#endif
    lcd_puts(0,line,str(LANG_RESET_CONFIRM));
    lcd_puts(0,line+1,str(LANG_RESET_CANCEL));

    lcd_update();
     
    while(!done) {
        switch(button_get(true)) {
        case BUTTON_PLAY:
            settings_reset();
            settings_apply();
            lcd_clear_display();
            lcd_puts(0,1,str(LANG_RESET_DONE_CLEAR));
            done = true;
            break;

#ifdef HAVE_RECORDER_KEYPAD
        case BUTTON_OFF:
#else
        case BUTTON_STOP:
#endif
            lcd_clear_display();
            lcd_puts(0,1,str(LANG_RESET_DONE_CANCEL));
            done = true;
            break;

        case SYS_USB_CONNECTED:
            usb_screen();
            return true;
        }
    }

    lcd_puts(0,0,str(LANG_RESET_DONE_SETTING));
    lcd_update();
    sleep(HZ);
    return false;
}

static bool fileview_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_CASE_MENU),    sort_case           },
        { str(LANG_FILTER),       dir_filter          },
        { str(LANG_FOLLOW),       browse_current      },
        { str(LANG_SHOW_ICONS),   show_icons          },
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}


static bool scroll_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_SCROLL_SPEED),     scroll_speed    },
        { str(LANG_SCROLL_DELAY),    scroll_delay    },  
#ifdef HAVE_LCD_BITMAP
        { str(LANG_SCROLL_STEP),     scroll_step     },  
#endif
        { str(LANG_BIDIR_SCROLL),    bidir_limit    },
#ifdef HAVE_LCD_CHARCELLS
        { str(LANG_JUMP_SCROLL),    jump_scroll    },
        { str(LANG_JUMP_SCROLL_DELAY),    jump_scroll_delay    },
#endif
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}

static bool lcd_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_BACKLIGHT),       backlight_timer },
        { str(LANG_BACKLIGHT_ON_WHEN_CHARGING), backlight_on_when_charging },
        { str(LANG_CAPTION_BACKLIGHT), caption_backlight },
        { str(LANG_CONTRAST),        contrast },
#ifdef HAVE_LCD_BITMAP
        { str(LANG_INVERT),          invert },
        { str(LANG_FLIP_DISPLAY),    flip_display },
        { str(LANG_INVERT_CURSOR),   invert_cursor },
#endif
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}

#ifdef HAVE_LCD_BITMAP
static bool bars_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_SCROLL_BAR),      scroll_bar },
        { str(LANG_STATUS_BAR),      status_bar },
        { str(LANG_VOLUME_DISPLAY),  volume_type },
        { str(LANG_BATTERY_DISPLAY), battery_type },
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}
#endif


static bool display_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
#ifdef HAVE_LCD_BITMAP
        { str(LANG_CUSTOM_FONT),     font_browse },
#endif
        { str(LANG_WHILE_PLAYING),   custom_wps_browse },
        { str(LANG_LCD_MENU),        lcd_settings_menu },
        { str(LANG_SCROLL_MENU),     scroll_settings_menu },
#ifdef HAVE_LCD_BITMAP
        { str(LANG_BARS_MENU),       bars_settings_menu },
        { str(LANG_PM_MENU),         peak_meter_menu },
#endif
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}


static bool firmware_browse(void)
{
    return rockbox_browse(ROCKBOX_DIR, SHOW_MOD);
}

static bool battery_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
#ifdef HAVE_CHARGE_CTRL
        { str(LANG_DISCHARGE),        deep_discharge   },
        { str(LANG_TRICKLE_CHARGE),   trickle_charge   },
#endif
#ifndef SIMULATOR
        { str(LANG_BATTERY_CAPACITY), battery_capacity },
#endif
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}

static bool disk_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_SPINDOWN),    spindown        },
#ifdef HAVE_ATA_POWER_OFF
        { str(LANG_POWEROFF),    poweroff        },
#endif
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}

#ifdef HAVE_LCD_BITMAP
static bool time_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_TIME),        timedate_set    },
        { str(LANG_TIMEFORMAT),  timeformat_set  },
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}
#endif

static bool manage_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_CUSTOM_CFG),      custom_cfg_browse },
        { str(LANG_FIRMWARE),        firmware_browse },
        { str(LANG_RESET),           reset_settings },
        { str(LANG_SAVE_SETTINGS),   settings_save_config },
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}

static bool limits_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_MAX_FILES_IN_DIR),    max_files_in_dir        },
        { str(LANG_MAX_FILES_IN_PLAYLIST),    max_files_in_playlist        },
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}


static bool system_settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_BATTERY_MENU),     battery_settings_menu },
        { str(LANG_DISK_MENU),        disk_settings_menu     },
#ifdef HAVE_RTC
        { str(LANG_TIME_MENU),        time_settings_menu     },
#endif
        { str(LANG_POWEROFF_IDLE),    poweroff_idle_timer    },
        { str(LANG_SLEEP_TIMER),      sleeptimer_screen      },
#ifdef HAVE_ALARM_MOD
        { str(LANG_ALARM_MOD_ALARM_MENU), alarm_screen       },
#endif
        { str(LANG_LIMITS_MENU),      limits_settings_menu   },
#ifdef HAVE_MAS3507D
        { str(LANG_LINE_IN),          line_in                },
#endif
        { str(LANG_CAR_ADAPTER_MODE), car_adapter_mode       },
        { str(LANG_MANAGE_MENU),      manage_settings_menu   },
    };

    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}

bool settings_menu(void)
{
    int m;
    bool result;

    struct menu_items items[] = {
        { str(LANG_PLAYBACK),         playback_settings_menu },
        { str(LANG_FILE),             fileview_settings_menu },
        { str(LANG_DISPLAY),          display_settings_menu  },
        { str(LANG_SYSTEM),           system_settings_menu   },
        { str(LANG_BOOKMARK_SETTINGS),bookmark_settings_menu },
        { str(LANG_LANGUAGE),         language_browse        },
    };
    
    m=menu_init( items, sizeof(items) / sizeof(*items) );
    result = menu_run(m);
    menu_exit(m);
    return result;
}