static int sig_autosave(void)
{
char *fname, *str;
if (!settings_get_bool("settings_autosave") ||
config_last_modifycounter == mainconfig->modifycounter)
return 1;
if (!irssi_config_is_changed(NULL))
settings_save(NULL, TRUE);
else {
fname = g_strconcat(mainconfig->fname, ".autosave", NULL);
str = g_strdup_printf("Configuration file was modified "
"while irssi was running. Saving "
"configuration to file '%s' instead. "
"Use /SAVE or /RELOAD to get rid of "
"this message.", fname);
signal_emit("gui dialog", 2, "warning", str);
g_free(str);
settings_save(fname, TRUE);
g_free(fname);
}
return 1;
}
void settings_default()
{
timer.setDefault();
strcpy((char*)conf.sysName, " ");
conf.warnTime = 2;
conf.mirrorTime = 2;
conf.lcdColor = 0;
conf.settingsVersion = SETTINGS_VERSION;
conf.shutterVersion = SHUTTER_VERSION;
conf.lcdBacklightTime = 3;
conf.sysOffTime = 12;
conf.flashlightOffTime = 3;
conf.devMode = 0;
conf.auxPort = AUX_MODE_DISABLED;
conf.btMode = BT_MODE_SLEEP;
conf.brampMode = BRAMP_MODE_BULB_ISO;
conf.autoRun = AUTO_RUN_OFF;
conf.dollyPulse = 100;
conf.dollyPulse2 = 100;
conf.lcdContrast = 3;
conf.lcdCoefficent = 0x7;
conf.lcdBias = 0x3;
conf.isoMax = 10;
conf.apertureMax = 31;
conf.apertureMin = 2;
conf.debugEnabled = 0;
conf.arbitraryBulb = 0;
conf.menuWrap = 1;
conf.extendedRamp = 0;
strcpy((char*)conf.test, "Test ");
conf.lightIntegrationMinutes = 5;
conf.pFactor = 10;
conf.iFactor = 12;
conf.dFactor = 12;
conf.errorAlert = 0;
conf.lightThreshold = 20;
conf.linearInterpolation = 0;
conf.camera.cameraFPS = 33;
conf.camera.nikonUSB = 0;
conf.camera.bulbEndOffset = 8;
conf.camera.bulbMin = 56;
conf.camera.bulbOffset = 75;
conf.camera.negBulbOffset = 0;
conf.camera.interface = INTERFACE_AUTO;
conf.camera.cameraMake = CANON;
conf.camera.bulbMode = 0;
conf.camera.halfPress = HALF_PRESS_ENABLED;
conf.camera.modeSwitch = USB_CHANGE_MODE_DISABLED;
conf.camera.brampGap = 6;
for(uint8_t i = 0; i < MAX_CAMERAS_SETTINGS; i++)
{
camera_settings_t cs;
memset((void*)&cs, 0, sizeof(camera_settings_t));
eeprom_write_block((const void*)&cs, &camera_settings_eep[i], sizeof(camera_settings_t));
}
settings_save();
settings_load();
}
void settings_default()
{
timer.setDefault();
strcpy((char*)conf.sysName, " ");
conf.warnTime = 2;
conf.mirrorTime = 2;
conf.cameraFPS = 33;
conf.bulbMode = 0;
conf.lcdColor = 0;
conf.cameraMake = CANON;
conf.settingsVersion = SETTINGS_VERSION;
conf.shutterVersion = SHUTTER_VERSION;
conf.lcdBacklightTime = 3;
conf.sysOffTime = 12;
conf.flashlightOffTime = 3;
conf.devMode = 0;
conf.auxPort = AUX_MODE_DISABLED;
conf.btMode = BT_MODE_SLEEP;
conf.halfPress = HALF_PRESS_ENABLED;
conf.bulbOffset = 75;
conf.interface = INTERFACE_AUTO;
conf.brampMode = BRAMP_MODE_BULB_ISO;
conf.autoRun = AUTO_RUN_OFF;
conf.modeSwitch = USB_CHANGE_MODE_DISABLED;
conf.dollyPulse = 100;
conf.lcdContrast = 0xf;
conf.lcdCoefficent = 0x7;
conf.lcdBias = 0x4;
conf.bulbMin = 56;
conf.isoMax = 10;
conf.apertureMax = 31;
conf.apertureMin = 2;
settings_save();
settings_load();
}
static gboolean callback_apply(GtkWidget *widget, gpointer data)
{
new_settings.gravity = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(wg_gravity));
new_settings.n_blobs = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_n_blobs));
new_settings.blob_size = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_blob_size));
new_settings.blob_falloff = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_blob_falloff));
new_settings.blob_presence = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_blob_presence));
new_settings.border_size = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_border_size));
new_settings.border_falloff = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_border_falloff));
new_settings.border_presence = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_border_presence));
new_settings.multiplication = gtk_spin_button_get_value_as_int(
GTK_SPIN_BUTTON(wg_multiplication));
/* the color informations are already in new_settings */
apply_settings(&new_settings);
settings_save();
return(TRUE);
}
static int clear_start_directory(void)
{
strcpy(global_settings.start_directory, "/");
settings_save();
splash(HZ, ID2P(LANG_RESET_DONE_CLEAR));
return false;
}
void
state_changed()
{
hotkey_t hk;
REFRESH_KEY_SETTING(trigger);
settings_set(TRIGGER_KEY, &hk);
REFRESH_KEY_SETTING(english);
settings_set(ENG_KEY, &hk);
varchar colorstr;
REFRESH_COLOR_SETTING(background_color_btn);
settings_set(PREEDIT_COLOR, colorstr);
REFRESH_COLOR_SETTING(font_color_btn);
settings_set(PREEDIT_FONT_COLOR, colorstr);
/* font and size information */
settings_set(PREEDIT_FONT, (void*) gtk_font_button_get_font_name(font_btn));
/* font color information */
double scale = gtk_adjustment_get_value(opacity_value);
settings_set(PREEDIT_OPACITY, &scale);
int ncandi = gtk_adjustment_get_value(ncandidates);
settings_set(CANDIDATES_SIZE, &ncandi);
settings_save();
/* notify all running xsunpinyin with this user */
char cmd[256];
snprintf(cmd, 256, "/usr/bin/pkill -10 '^xsunpinyin$' -u %d", getuid());
system(cmd);
}
void _event(state_stack* stack, SDL_Event *sdlEvent) {
state_desc *top = (state_desc*) table_ind(stack, stack->m_len-1);
_settings_menu *data = (_settings_menu*) top->m_pData;
menu *pMenu = (menu*) data->m_menu;
settings *pSettings = (settings*) data->m_settings;
if (sdlEvent->type == SDL_QUIT) {
state_stack_kill(stack);
return;
}
switch (menu_input(pMenu, sdlEvent)) {
case 0:
// Controls
top->m_fnPushChild = &_controls_push;
break;
case 1:
// (empty)
break;
case 2:
// < Save Settings
settings_save(pSettings, settings_file_path);
top->m_isDead = true;
break;
case 3:
// < Discard Settings
settings_load(pSettings, settings_file_path);
top->m_isDead = true;
break;
default:
break;
}
}
static bool set_recdir(void)
{
strlcpy(global_settings.rec_directory, selected_file,
sizeof(global_settings.rec_directory));
settings_save();
return false;
}
static int bookmark_menu_callback(int action,
const struct menu_item_ex *this_item)
{
switch (action)
{
case ACTION_REQUEST_MENUITEM:
if (this_item == &bookmark_load_menu_item)
{
if (!bookmark_exists())
return ACTION_EXIT_MENUITEM;
}
/* hide the bookmark menu if there is no playback */
else if ((audio_status() & AUDIO_STATUS_PLAY) == 0)
return ACTION_EXIT_MENUITEM;
break;
#ifdef HAVE_LCD_CHARCELLS
case ACTION_ENTER_MENUITEM:
status_set_param(true);
break;
#endif
case ACTION_EXIT_MENUITEM:
#ifdef HAVE_LCD_CHARCELLS
status_set_param(false);
#endif
settings_save();
break;
}
return action;
}
void OS_quit()
{
SceneManager_destroy();
SceneManager_eventsDestroy(evts);
hasQuit = 1;
if (audioInitialized)
{
if (Mix_PlayingMusic())
Mix_FadeOutMusic(200);
if (music_theme)
Mix_FreeMusic(music_theme);
if (music_success)
Mix_FreeMusic(music_success);
if (music_failure)
Mix_FreeMusic(music_failure);
Mix_CloseAudio();
}
SDL_Quit();
settings_save();
settings_clear();
}
static void settings_save_fe(const char *fname)
{
if (settings_save(fname, FALSE /* not autosaved */)) {
printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE,
TXT_CONFIG_SAVED, fname);
}
}
void TB_SaveSelect::Run_Input()
{
int start;
if (justpushed(DOWNKEY))
{
start = fCurSel;
for(;;)
{
fCurSel++;
if (fCurSel >= fNumFiles) fCurSel = 0;
if (fSaving) break;
if (fHaveProfile[fCurSel]) break;
if (fCurSel == start) break;
}
sound(SND_MENU_MOVE);
fPicXOffset = -24;
}
if (justpushed(UPKEY))
{
start = fCurSel;
for(;;)
{
fCurSel--;
if (fCurSel < 0) fCurSel = fNumFiles - 1;
if (fSaving) break;
if (fHaveProfile[fCurSel]) break;
if (fCurSel == start) break;
}
sound(SND_MENU_MOVE);
fPicXOffset = -24;
}
if (buttonjustpushed())
{
// when shown in a replay, the box is shown and everything just like what was done
// originally, but we won't actually overwrite any save files.
if (!Replay::IsPlaying())
{
if (fSaving)
game_save(fCurSel);
settings->last_save_slot = fCurSel;
settings_save(); // record new save/load slot
}
SetVisible(false);
// when the script hit the <SVP, it froze itself in an artifical <WAI9999
// waiting for us to complete. Now unfreeze it so can say "Game saved.",
// or for loading, just end.
ScriptInstance *s = GetCurrentScriptInstance();
if (s) s->delaytimer = 0;
}
}
/*
* Takes filename, removes the directory and the extension,
* and then copies the basename into setting, unless the basename exceeds maxlen
**/
void set_file(const char* filename, char* setting, const int maxlen)
{
const char* fptr = strrchr(filename,'/');
const char* extptr;
int len;
int extlen = 0;
if (!fptr)
return;
fptr++;
extptr = strrchr(fptr, '.');
if (!extptr || extptr < fptr)
extlen = 0;
else
extlen = strlen(extptr);
len = strlen(fptr) - extlen + 1;
/* error if filename isn't in ROCKBOX_DIR */
if (len > maxlen)
return;
strlcpy(setting, fptr, len);
settings_save();
}
static int reset_settings(void)
{
static const char *lines[]= {ID2P(LANG_RESET_ASK)};
static const char *yes_lines[]= {
ID2P(LANG_SETTINGS),
ID2P(LANG_RESET_DONE_CLEAR)
};
static const char *no_lines[]= {
ID2P(LANG_SETTINGS),
ID2P(LANG_CANCEL)
};
static const struct text_message message= {lines, 1};
static const struct text_message yes_message= {yes_lines, 2};
static const struct text_message no_message= {no_lines, 2};
switch(gui_syncyesno_run(&message, &yes_message, &no_message))
{
case YESNO_YES:
settings_reset();
settings_save();
settings_apply(true);
settings_apply_skins();
break;
case YESNO_NO:
break;
case YESNO_USB:
return 1;
}
return 0;
}
char * settings_update(const char *name, const char *value)
{
int ii;
for (ii = 0;
settings_display_list[ii].fmt != NULL;
ii++)
{
struct settings_display *disp = &settings_display_list[ii];
if (strcmp(name, disp->name) == 0)
{
if (disp->type == FLOAT)
{
*((float *)disp->value) = atof(value);
sprintf(update_message, disp->fmt, *((float *)disp->value));
}
else if (disp->type == UINT8)
{
*((uint8_t *)disp->value) = atoi(value);
sprintf(update_message, disp->fmt, *((uint8_t *)disp->value));
}
settings_save();
return update_message;
}
}
return "Setting not found.";
}
void set_file(const char* filename, char* setting, int maxlen)
{
const char* fptr = strrchr(filename,'/');
int len;
int extlen = 0;
const char* ptr;
if (!fptr)
return;
fptr++;
len = strlen(fptr);
ptr = fptr + len;
while ((*ptr != '.') && (ptr != fptr)) {
extlen++;
ptr--;
}
if(ptr == fptr) extlen = 0;
if (strncasecmp(ROCKBOX_DIR, filename, strlen(ROCKBOX_DIR)) ||
(len-extlen > maxlen))
return;
strlcpy(setting, fptr, len-extlen+1);
settings_save();
}
static bool set_backdrop(void)
{
strlcpy(global_settings.backdrop_file, selected_file,
sizeof(global_settings.backdrop_file));
settings_save();
skin_backdrop_load_setting();
return true;
}
static bool set_startdir(void)
{
snprintf(global_settings.start_directory,
sizeof(global_settings.start_directory),
"%s/", selected_file);
settings_save();
return false;
}
//------------------------------------------------------------------------------
int set(int argc, char** argv)
{
int ret;
// Check we're running from a Clink session.
extern int g_in_clink_context;
if (!g_in_clink_context)
{
puts("ERROR: The 'set' verb must be run from a process with Clink present");
return 1;
}
// Get the path where Clink's storing its settings.
get_config_dir(g_settings_path, sizeof_array(g_settings_path));
str_cat(g_settings_path, "/settings", sizeof_array(g_settings_path));
// Load Clink's settings.
g_settings = initialise_clink_settings();
if (g_settings == NULL)
{
printf("ERROR: Failed to load Clink's settings from '%s'.", g_settings_path);
return 1;
}
// List or set Clink's settings.
ret = 0;
switch (argc)
{
case 0:
case 1:
ret = print_keys();
break;
case 2:
if (_stricmp(argv[1], "--help") == 0 ||
_stricmp(argv[1], "-h") == 0)
{
ret = 1;
print_usage();
}
else
{
ret = print_value(argv[1]);
}
break;
default:
ret = set_value(argv[1], argv[2]);
if (!ret)
{
settings_save(g_settings, g_settings_path);
}
break;
}
settings_shutdown(g_settings);
return ret;
}
unsigned int setup_code(void){
switch(setup_code_state){
case 0: setup_code_code_1=ui_input_code();
if(setup_code_code_1==-1){//code insert canceled
setup_code_state=0;
return 0;
}
if(setup_code_code_1==-2){//code still entered
}else if(setup_code_code_1>=0){//code entered
setup_code_state=1;
}
break;
case 1: setup_code_code_2=ui_input_code();
if(setup_code_code_2==-1){//code insert canceled
setup_code_state=0;
return 0;
}
if(setup_code_code_2==-2){//code still entered
}else if(setup_code_code_2>=0){//code entered
if(setup_code_code_1==setup_code_code_2){
if(setup_code_code_1==0){
setup_code_code_1=-1;
}
ui_menues_set_code(setup_code_code_1);
settings_save(SETTINGS_UI_MENUES_CODE_32,ui_menues_get_code()>>8);
settings_save(SETTINGS_UI_MENUES_CODE_10,ui_menues_get_code()&0xFF);
if(ui_menues_get_code()<0){
setup_code_state=3;
}else{
setup_code_state=4;
}
clock_stop_stop_watch();clock_start_stop_watch();
}else{
setup_code_state=2;clock_stop_stop_watch();clock_start_stop_watch();
}
}
break;
case 2:if(clock_get_stop_watch()*4>2000){//2seconds waiting
setup_code_state=0;
return 0;
}
display_set_text("Err ");
break;
case 3:if(clock_get_stop_watch()*4>2000){//2seconds waiting
setup_code_state=0;
return 0;
}
display_set_text("off ");
break;
case 4:if(clock_get_stop_watch()*4>2000){//2seconds waiting
setup_code_state=0;
return 0;
}
display_set_text("ok ");
break;
}
/**
* Menu to clear the backdrop image
*/
static int clear_main_backdrop(void)
{
global_settings.backdrop_file[0] = '-';
global_settings.backdrop_file[1] = '\0';
skin_backdrop_load_setting();
viewportmanager_theme_enable(SCREEN_MAIN, false, NULL);
viewportmanager_theme_undo(SCREEN_MAIN, true);
settings_save();
return 0;
}
void settings_display(int init)
{
if (init)
{
lcd_text(0, 0, " Settings");
settings_display_menu();
}
else
{
settings_save();
}
}
//TODO -implement me
static bool cmd_settings_symbol(Serial* pSer, char* value, size_t len) {
if(len >= 2) {
settings_set(SETTINGS_SYMBOL,value,2);
settings_save();
}
uint8_t symbol[2];
uint8_t bufLen = 2;
settings_get(SETTINGS_SYMBOL,symbol,&bufLen);
SERIAL_PRINTF_P(pSer,PSTR("SYMBOL: %c%c\r\n"),symbol[0],symbol[1]);
return true;
}
static
void settings_post(struct mg_connection* conn) {
int rc;
int len;
char buf[256];
settings_load();
len = mg_get_var(conn, BRIGHTNESS, buf, sizeof(buf));
if (len > 0) {
settings.brightness = strtol(buf, NULL, 10);
}
len = mg_get_var(conn, MANUAL_TICK, buf, sizeof(buf));
if (len > 0) {
settings.manual_tick = strtol(buf, NULL, 10);
}
len = mg_get_var(conn, IDLE_INTERVAL, buf, sizeof(buf));
if (len > 0) {
settings.idle_interval = strtol(buf, NULL, 10);
}
len = mg_get_var(conn, MANUAL_TOGGLE, buf, sizeof(buf));
if (len > 0) {
settings.manual_toggle = strtol(buf, NULL, 10);
}
len = mg_get_var(conn, SCREEN_SAVER_TOGGLE, buf, sizeof(buf));
if (len > 0) {
settings.screen_saver_toggle = strtol(buf, NULL, 10);
}
len = mg_get_var(conn, ALPHA, buf, sizeof(buf));
if (len > 0) {
settings.alpha = strtol(buf, NULL, 10);
}
rc = settings_save();
if (rc) {
mg_printf_data(conn, "Could not save " SETTINGS_FILE);
mg_send_status(conn, 500);
return;
}
len = settings_json(work_buf, sizeof(work_buf));
mg_send_header(conn, CONTENT_TYPE, CONTENT_TYPE_JSON);
mg_send_status(conn, 200);
mg_send_data(conn, work_buf, len);
}
static bool cmd_settings_beacon_interval(Serial* pSer, char* value, size_t valueLen) {
uint16_t i = 0;
if(valueLen > 0) {
i = atoi((const char*) value) & 0xffff;
settings_set(SETTINGS_BEACON_INTERVAL,&i,2);
settings_save();
}
uint8_t bufLen = 2;
settings_get(SETTINGS_BEACON_INTERVAL,&i,&bufLen);
SERIAL_PRINTF_P(pSer,PSTR("Beacon Interval: %d seconds\r\n"),i);
return true;
}
//------------------------------------------------------------------------------
void* initialise_clink_settings()
{
char settings_file[MAX_PATH];
get_settings_file(settings_file, sizeof_array(settings_file));
g_settings = settings_init(g_settings_decl, sizeof_array(g_settings_decl));
if (!settings_load(g_settings, settings_file))
{
settings_save(g_settings, settings_file);
}
return g_settings;
}
int save_settings()
{
Settings *s = settings_new_from_gui();
if (!is_dir(s->csv_dir)) {
message_box("CSV Directory doesn't exist.");
return FALSE;
}
if (!is_dir(s->output_dir)) {
message_box("Output Directory doesn't exist.");
return FALSE;
}
settings_save(s);
settings_free(s);
return TRUE;
}
bool quick_screen_f3(int button_enter)
{
struct gui_quickscreen qs;
qs.items[QUICKSCREEN_LEFT] =
find_setting(&global_settings.scrollbar, NULL);
qs.items[QUICKSCREEN_RIGHT] =
find_setting(&global_settings.statusbar, NULL);
qs.items[QUICKSCREEN_BOTTOM] =
find_setting(&global_settings.flip_display, NULL);
qs.callback = NULL;
if (gui_syncquickscreen_run(&qs, button_enter))
{
settings_save();
settings_apply(false);
}
return(0);
}
static void
on_app_sig(int sig)
{
if (sig == SIGUSR1) {
/* reload the settings */
settings_load();
preedit_reload();
} else {
preedit_finalize();
icmgr_finalize();
settings_save();
settings_destroy();
exit(0);
}
}
void settings_init(void)
{
lion_t *conf_file;
settings_defaults();
settings_initialising = 1;
// Using lion to read a config file, well, well...
conf_file = lion_open(".FXP.One.settings", O_RDONLY, 0600,
LION_FLAG_NONE, NULL);
if (conf_file) lion_set_handler(conf_file, settings_handler);
else settings_save();
}
