void
filter_method_from_setting(const char *value)
{
int i;
char methods[256], method_expr[256];
int methods_len = strlen(value);
char *comma;
// If there's a method filter
if (methods_len) {
// Copy value into temporal array
memset(methods, 0, sizeof(methods));
strncpy(methods, value, methods_len);
// Replace all commas with pippes
while ((comma = strchr(methods, ',')))
*comma = '|';
// Create a regular expression
memset(method_expr, 0, sizeof(method_expr));
sprintf(method_expr, "(%s)", methods);
filter_set(FILTER_METHOD, method_expr);
} else {
filter_set(FILTER_METHOD, " ");
}
}
static void
test_filter_matches_differently_after_set(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_int_equal(0, filter_set(&filter, "a123"));
assert_false(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "a123"));
filter_dispose(&filter);
}
static void
test_set_to_empty_is_like_clear(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, ""));
assert_true(filter_is_empty(&filter));
filter_dispose(&filter);
}
int
filter_change(filter_t *filter, const char value[], int case_sensitive)
{
if(case_sensitive)
{
filter->cflags &= ~REG_ICASE;
}
else
{
filter->cflags |= REG_ICASE;
}
return filter_set(filter, value);
}
void
name_filters_restore(view_t *view)
{
if(view->prev_manual_filter[0] == '\0' && view->prev_auto_filter[0] == '\0')
{
return;
}
replace_matcher(&view->manual_filter, view->prev_manual_filter);
(void)filter_set(&view->auto_filter, view->prev_auto_filter);
view->invert = view->prev_invert;
ui_view_schedule_reload(view);
}
static void
test_regexp_is_changed(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_int_equal(0, filter_change(&filter, "a123", 0));
assert_false(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "a123"));
filter_dispose(&filter);
}
static void
test_case_sensitivity_is_changed(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_false(filter_matches(&filter, "aBCd"));
assert_int_equal(0, filter_change(&filter, "abcd", 0));
assert_true(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "aBCd"));
filter_dispose(&filter);
}
static void
test_append_produces_desired_effect(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_set(&filter, "abcd"));
assert_true(filter_matches(&filter, "abcd"));
assert_false(filter_matches(&filter, "efgh"));
assert_int_equal(0, filter_append(&filter, "efgh"));
assert_true(filter_matches(&filter, "abcd"));
assert_true(filter_matches(&filter, "efgh"));
filter_dispose(&filter);
}
void
local_filter_cancel(view_t *view)
{
if(!view->local_filter.in_progress)
{
return;
}
(void)filter_set(&view->local_filter.filter, view->local_filter.saved);
dynarray_free(view->dir_entry);
view->dir_entry = NULL;
view->list_rows = 0;
update_filtering_lists(view, 1, 1);
local_filter_finish(view);
}
int
filter_assign(filter_t *filter, const filter_t *source)
{
filter_t tmp;
if(filter_init(&tmp, !(source->cflags & REG_ICASE)) != 0)
{
return 1;
}
if(filter_set(&tmp, source->raw) != 0)
{
filter_clear(&tmp);
return 1;
}
filter_dispose(filter);
*filter = tmp;
return 0;
}
TEST(symlinks_are_loaded_as_files, IF(not_windows))
{
/* symlink() is not available on Windows, but other code is fine. */
#ifndef _WIN32
assert_success(symlink(TEST_DATA_PATH, SANDBOX_PATH "/link"));
#endif
assert_success(flist_load_tree(&lwin, SANDBOX_PATH));
assert_int_equal(1, lwin.list_rows);
assert_int_equal(0, lwin.filtered);
validate_tree(&lwin);
(void)filter_set(&lwin.local_filter.filter, "a");
assert_success(flist_load_tree(&lwin, SANDBOX_PATH));
assert_int_equal(1, lwin.list_rows);
assert_int_equal(1, lwin.filtered);
validate_tree(&lwin);
assert_success(remove(SANDBOX_PATH "/link"));
}
/* Sets view property specified by the type to the value. */
static void
set_view_property(FileView *view, char type, const char value[])
{
if(type == PROP_TYPE_DOTFILES)
{
const int bool_val = atoi(value);
view->hide_dot = bool_val;
}
else if(type == PROP_TYPE_AUTO_FILTER)
{
if(filter_set(&view->auto_filter, value) != 0)
{
LOG_ERROR_MSG("Error setting auto filename filter to: %s", value);
}
}
else
{
LOG_ERROR_MSG("Unknown view property type (%c) with value: %s", type,
value);
}
}
void
local_filter_apply(view_t *view, const char filter[])
{
if(view->local_filter.in_progress)
{
assert(!view->local_filter.in_progress && "Wrong local filter applying.");
return;
}
(void)filter_set(&view->local_filter.filter, filter);
hists_filter_save(view->local_filter.filter.raw);
if(flist_custom_active(view) && view->custom.type != CV_TREE &&
view->local_filter.entry_count == 0)
{
/* Save unfiltered (by local filter) list for further use so it can be
* restored on changing local filter. */
replace_dir_entries(view, &view->local_filter.entries,
&view->local_filter.entry_count, view->dir_entry, view->list_rows);
}
ui_view_schedule_reload(view);
}
void
filter_payload_from_setting(const char *value)
{
if (value) filter_set(FILTER_PAYLOAD, value);
}
void
read_info_file(int reread)
{
/* TODO: refactor this function read_info_file() */
FILE *fp;
char info_file[PATH_MAX];
char *line = NULL, *line2 = NULL, *line3 = NULL, *line4 = NULL;
snprintf(info_file, sizeof(info_file), "%s/vifminfo", cfg.config_dir);
if((fp = os_fopen(info_file, "r")) == NULL)
return;
while((line = read_vifminfo_line(fp, line)) != NULL)
{
const char type = line[0];
const char *const line_val = line + 1;
if(type == LINE_TYPE_COMMENT || type == '\0')
continue;
if(type == LINE_TYPE_OPTION)
{
if(line_val[0] == '[' || line_val[0] == ']')
{
FileView *v = curr_view;
curr_view = (line_val[0] == '[') ? &lwin : &rwin;
process_set_args(line_val + 1, 1, 1);
curr_view = v;
}
else
{
process_set_args(line_val, 1, 1);
}
}
else if(type == LINE_TYPE_FILETYPE || type == LINE_TYPE_XFILETYPE)
{
if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
char *error;
matcher_t *m;
const int x = (type == LINE_TYPE_XFILETYPE);
/* Prevent loading of old builtin fake associations. */
if(ends_with(line2, "}" VIFM_PSEUDO_CMD))
{
continue;
}
m = matcher_alloc(line_val, 0, 1, &error);
if(m == NULL)
{
/* Ignore error description. */
free(error);
}
else
{
ft_set_programs(m, line2, x,
curr_stats.exec_env_type == EET_EMULATOR_WITH_X);
}
}
}
else if(type == LINE_TYPE_FILEVIEWER)
{
if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
char *error;
matcher_t *const m = matcher_alloc(line_val, 0, 1, &error);
if(m == NULL)
{
/* Ignore error description. */
free(error);
}
else
{
ft_set_viewers(m, line2);
}
}
}
else if(type == LINE_TYPE_COMMAND)
{
if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
char *cmdadd_cmd;
if((cmdadd_cmd = format_str("command %s %s", line_val, line2)) != NULL)
{
exec_commands(cmdadd_cmd, curr_view, CIT_COMMAND);
free(cmdadd_cmd);
}
}
}
else if(type == LINE_TYPE_MARK)
{
if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
if((line3 = read_vifminfo_line(fp, line3)) != NULL)
{
const int timestamp = read_optional_number(fp);
setup_user_mark(line_val[0], line2, line3, timestamp);
}
}
}
else if(type == LINE_TYPE_BOOKMARK)
{
if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
long timestamp;
if((line3 = read_vifminfo_line(fp, line3)) != NULL &&
read_number(line3, ×tamp))
{
(void)bmarks_setup(line_val, line2, (size_t)timestamp);
}
}
}
else if(type == LINE_TYPE_ACTIVE_VIEW)
{
/* Don't change active view on :restart command. */
if(line_val[0] == 'r' && !reread)
{
ui_views_update_titles();
curr_view = &rwin;
other_view = &lwin;
}
}
else if(type == LINE_TYPE_QUICK_VIEW_STATE)
{
const int i = atoi(line_val);
curr_stats.view = (i == 1);
}
else if(type == LINE_TYPE_WIN_COUNT)
{
if(!reread)
{
const int i = atoi(line_val);
curr_stats.number_of_windows = (i == 1) ? 1 : 2;
}
}
else if(type == LINE_TYPE_SPLIT_ORIENTATION)
{
curr_stats.split = (line_val[0] == 'v') ? VSPLIT : HSPLIT;
}
else if(type == LINE_TYPE_SPLIT_POSITION)
{
curr_stats.splitter_pos = atof(line_val);
}
else if(type == LINE_TYPE_LWIN_SORT)
{
get_sort_info(&lwin, line_val);
}
else if(type == LINE_TYPE_RWIN_SORT)
{
get_sort_info(&rwin, line_val);
}
else if(type == LINE_TYPE_LWIN_HIST || type == LINE_TYPE_RWIN_HIST)
{
FileView *const view = (type == LINE_TYPE_LWIN_HIST ) ? &lwin : &rwin;
if(line_val[0] == '\0')
{
if(!reread && view->history_num > 0)
{
copy_str(view->curr_dir, sizeof(view->curr_dir),
view->history[view->history_pos].dir);
}
}
else if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
const int pos = read_optional_number(fp);
get_history(view, reread, line_val, line2, pos);
}
}
else if(type == LINE_TYPE_CMDLINE_HIST)
{
append_to_history(&cfg.cmd_hist, cfg_save_command_history, line_val);
}
else if(type == LINE_TYPE_SEARCH_HIST)
{
append_to_history(&cfg.search_hist, cfg_save_search_history, line_val);
}
else if(type == LINE_TYPE_PROMPT_HIST)
{
append_to_history(&cfg.prompt_hist, cfg_save_prompt_history, line_val);
}
else if(type == LINE_TYPE_FILTER_HIST)
{
append_to_history(&cfg.filter_hist, cfg_save_filter_history, line_val);
}
else if(type == LINE_TYPE_DIR_STACK)
{
if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
if((line3 = read_vifminfo_line(fp, line3)) != NULL)
{
if((line4 = read_vifminfo_line(fp, line4)) != NULL)
{
push_to_dirstack(line_val, line2, line3 + 1, line4);
}
}
}
}
else if(type == LINE_TYPE_TRASH)
{
if((line2 = read_vifminfo_line(fp, line2)) != NULL)
{
char *const trash_name = convert_old_trash_path(line_val);
(void)add_to_trash(line2, trash_name);
free(trash_name);
}
}
else if(type == LINE_TYPE_REG)
{
regs_append(line_val[0], line_val + 1);
}
else if(type == LINE_TYPE_LWIN_FILT)
{
(void)replace_string(&lwin.prev_manual_filter, line_val);
(void)filter_set(&lwin.manual_filter, line_val);
}
else if(type == LINE_TYPE_RWIN_FILT)
{
(void)replace_string(&rwin.prev_manual_filter, line_val);
(void)filter_set(&rwin.manual_filter, line_val);
}
else if(type == LINE_TYPE_LWIN_FILT_INV)
{
const int i = atoi(line_val);
lwin.invert = (i != 0);
}
else if(type == LINE_TYPE_RWIN_FILT_INV)
{
const int i = atoi(line_val);
rwin.invert = (i != 0);
}
else if(type == LINE_TYPE_USE_SCREEN)
{
const int i = atoi(line_val);
cfg_set_use_term_multiplexer(i != 0);
}
else if(type == LINE_TYPE_COLORSCHEME)
{
copy_str(curr_stats.color_scheme, sizeof(curr_stats.color_scheme),
line_val);
}
else if(type == LINE_TYPE_LWIN_SPECIFIC || type == LINE_TYPE_RWIN_SPECIFIC)
{
FileView *view = (type == LINE_TYPE_LWIN_SPECIFIC) ? &lwin : &rwin;
set_view_property(view, line_val[0], line_val + 1);
}
}
free(line);
free(line2);
free(line3);
free(line4);
fclose(fp);
dir_stack_freeze();
}
void
filter_save_options(PANEL *panel)
{
char field_value[30];
char *expr;
int field_id;
char method_expr[256];
// Initialize variables
memset(method_expr, 0, sizeof(method_expr));
// Get panel information
filter_info_t *info = filter_info(panel);
for (field_id = 0; field_id < FLD_FILTER_COUNT; field_id++) {
// Get current field value.
// We trim spaces with sscanf because and empty field is stored as
// space characters
memset(field_value, 0, sizeof(field_value));
strcpy(field_value, field_buffer(info->fields[field_id], 0));
strtrim(field_value);
// Set filter expression
expr = strlen(field_value) ? field_value : NULL;
switch (field_id) {
case FLD_FILTER_SIPFROM:
filter_set(FILTER_SIPFROM, expr);
break;
case FLD_FILTER_SIPTO:
filter_set(FILTER_SIPTO, expr);
break;
case FLD_FILTER_SRC:
filter_set(FILTER_SOURCE, expr);
break;
case FLD_FILTER_DST:
filter_set(FILTER_DESTINATION, expr);
break;
case FLD_FILTER_PAYLOAD:
filter_set(FILTER_PAYLOAD, expr);
break;
case FLD_FILTER_REGISTER:
case FLD_FILTER_INVITE:
case FLD_FILTER_SUBSCRIBE:
case FLD_FILTER_NOTIFY:
case FLD_FILTER_OPTIONS:
case FLD_FILTER_PUBLISH:
case FLD_FILTER_MESSAGE:
if (!strcmp(field_value, "*")) {
if (strlen(method_expr)) {
sprintf(method_expr + strlen(method_expr), ",%s", filter_field_method(field_id));
} else {
strcpy(method_expr, filter_field_method(field_id));
}
}
break;
default:
break;
}
}
// Set Method filter
filter_method_from_setting(method_expr);
// Force filter evaluation
filter_reset_calls();
// TODO FIXME Refresh call list FIXME
call_list_clear(ui_get_panel(ui_find_by_type(PANEL_CALL_LIST)));
}
int
call_list_handle_form_key(PANEL *panel, int key)
{
int field_idx;
char dfilter[256];
int action = -1;
// Get panel information
call_list_info_t *info = call_list_info(panel);
// Get current field id
field_idx = field_index(current_field(info->form));
// Check actions for this key
while ((action = key_find_action(key, action)) != ERR) {
// Check if we handle this action
switch (action) {
case ACTION_PRINTABLE:
// If this is a normal character on input field, print it
form_driver(info->form, key);
break;
case ACTION_PREV_SCREEN:
case ACTION_NEXT_FIELD:
case ACTION_CONFIRM:
case ACTION_SELECT:
case ACTION_UP:
case ACTION_DOWN:
// Activate list
call_list_form_activate(panel, 0);
break;
case ACTION_RIGHT:
form_driver(info->form, REQ_RIGHT_CHAR);
break;
case ACTION_LEFT:
form_driver(info->form, REQ_LEFT_CHAR);
break;
case ACTION_BEGIN:
form_driver(info->form, REQ_BEG_LINE);
break;
case ACTION_END:
form_driver(info->form, REQ_END_LINE);
break;
case ACTION_CLEAR:
form_driver(info->form, REQ_BEG_LINE);
form_driver(info->form, REQ_CLR_EOL);
break;
case ACTION_DELETE:
form_driver(info->form, REQ_DEL_CHAR);
break;
case ACTION_BACKSPACE:
form_driver(info->form, REQ_DEL_PREV);
break;
default:
// Parse next action
continue;
}
// We've handled this key, stop checking actions
break;
}
// Filter has changed, re-apply filter to displayed calls
if (action == ACTION_PRINTABLE || action == ACTION_BACKSPACE ||
action == ACTION_DELETE || action == ACTION_CLEAR) {
// Updated displayed results
call_list_clear(panel);
// Reset filters on each key stroke
filter_reset_calls();
}
// Validate all input data
form_driver(info->form, REQ_VALIDATION);
// Store dfilter input
// We trim spaces with sscanf because and empty field is stored as space characters
memset(dfilter, 0, sizeof(dfilter));
strcpy(dfilter, field_buffer(info->fields[FLD_LIST_FILTER], 0));
strtrim(dfilter);
// Set display filter
filter_set(FILTER_CALL_LIST, strlen(dfilter) ? dfilter : NULL);
// Return if this panel has handled or not the key
return (action == ERR) ? key : 0;
}
/*
====================================================================
Load/delete background and create and link all menus
====================================================================
*/
void manager_create()
{
int i, j;
Item *keys[7];
Item *item;
int filter[SDLK_LAST]; /* key filter */
/* constant contence of switches */
char *str_fps[] = { _("No Limit"), _("100 FPS") };
char *str_anim[] = { _("Off"), _("Low"), _("Medium"), _("High") };
char *str_diff[] = { _("Kids"), _("Easy"), _("Medium"), _("Hard") };
/*
main:
new game:
start game
quick help
---
levelset
difficulty
---
active players
---
player1
player2
player3
player4
controls
graphics
animations
transparency
shadow
---
display
constant frame rate
audio:
sound
volume
advanced options:
convex paddle
ball level
key speed
editor:
set: (list)
edit
delete
yes
no
---
create empty set
set name: (string)
create set
yes
no
---
quit
*/
Menu *_main = 0;
#ifdef _1
Menu *options = 0;
#endif
#ifdef AUDIO_ENABLED
Menu *audio = 0;
#endif
Menu *gfx = 0;
Menu *game = 0;
Menu *cont = 0;
Menu *adv = 0;
Menu *editor = 0;
Menu *confirm_delete = 0;
Menu *theme = 0;
/* load levelset names */
levelsets_load_names();
cb_update_edit_set();
/* hints will be displayed on menu background */
hint_set_bkgnd( mbkgnd );
/* setup filter */
filter_clear( filter );
filter_set( filter, SDLK_a, SDLK_z, 1 );
filter[SDLK_BACKSPACE] = 1;
filter[SDLK_SPACE] = 1;
filter[SDLK_RSHIFT] = 1;
filter[SDLK_LSHIFT] = 1;
filter[SDLK_LALT] = 1;
filter[SDLK_RALT] = 1;
filter[SDLK_LCTRL] = 1;
filter[SDLK_RCTRL] = 1;
filter[SDLK_UP] = 1;
filter[SDLK_DOWN] = 1;
filter[SDLK_LEFT] = 1;
filter[SDLK_RIGHT] = 1;
filter[SDLK_q] = 0;
filter[SDLK_p] = 0;
filter[SDLK_f] = 0;
filter[SDLK_s] = 0;
filter[SDLK_a] = 0;
filter[SDLK_r] = 0;
filter[SDLK_h] = 0;
filter[SDLK_d] = 0;
/* menus are added to this list for deleting later */
menus = list_create( LIST_AUTO_DELETE, menu_delete );
/* create menus */
_main = menu_create( _("Menu"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#ifdef _1
options = menu_create( _("Options"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#endif
gfx = menu_create( _("Graphics"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
game = menu_create( _("Local Game"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
cont = menu_create( _("Controls"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
adv = menu_create( _("Advanced Options"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#ifdef AUDIO_ENABLED
audio = menu_create( _("Audio"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
#endif
editor = menu_create( _("Editor"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
confirm_delete = menu_create( _("Delete Set"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
theme = menu_create( _("Select Theme"), MENU_LAYOUT_CENTERED, menu_x, menu_y, menu_w, menu_h, menu_border, 1 );
/* create items */
/* main menu */
menu_add( _main, item_create_link ( _("Local Game"), HINT_LOCAL, game ) );
#ifdef NETWORK_ENABLED
menu_add( _main, item_create_action ( _("Network Game"), HINT_NETWORK, ACTION_CLIENT ) );
#endif
menu_add( _main, item_create_action ( _("Quick Help"), HINT_, ACTION_QUICK_HELP ) );
// menu_add( _main, item_create_link ( _("Select Theme"), HINT_THEME, theme ) );
menu_add( _main, item_create_separator ( "" ) );
#ifdef _1
menu_add( _main, item_create_link ( _("Options"), options ) );
#endif
menu_add( _main, item_create_link ( _("Controls"), HINT_, cont ) );
menu_add( _main, item_create_link ( _("Graphics"), HINT_, gfx ) );
#ifdef AUDIO_ENABLED
menu_add( _main, item_create_link ( _("Audio"), HINT_,audio ) );
#else
menu_add( _main, item_create_separator ( _("Audio") ) );
#endif
menu_add( _main, item_create_link ( _("Advanced Options"), HINT_, adv ) );
menu_add( _main, item_create_separator ( "" ) );
menu_add( _main, item_create_link ( _("Editor"), HINT_, editor ) );
menu_add( _main, item_create_separator ( "" ) );
menu_add( _main, item_create_action ( _("Quit"), HINT_QUIT, ACTION_QUIT ) );
#ifdef _1
/* options */
menu_add( options, item_create_link( _("Controls"), HINT_, cont ) );
menu_add( options, item_create_link( _("Graphics"), HINT_, gfx ) );
menu_add( options, item_create_link( _("Audio"), HINT_, audio ) );
menu_add( options, item_create_separator( _("Audio") ) );
menu_add( options, item_create_separator( "" ) );
menu_add( options, item_create_link( _("Back"), _main ) );
#endif
/* audio */
#ifdef AUDIO_ENABLED
item = item_create_switch( _("Sound:"), HINT_, &config.sound, _("Off"), _("On") );
item->callback = cb_sound;
menu_add( audio, item );
menu_add( audio, item_create_switch( _("Speech:"), HINT_, &config.speech, _("Off"), _("On") ) );
item = item_create_range( _("Volume:"), HINT_, &config.volume, 1, 8, 1 );
item->callback = cb_volume;
menu_add( audio, item );
menu_add( audio, item_create_separator( "" ) );
menu_add( audio, item_create_link( _("Back"), HINT_, _main ) );
#endif
/* gfx */
menu_add( gfx, item_create_switch_x( _("Animations:"), HINT_ANIM, &config.anim, str_anim, 4 ) );
menu_add( gfx, item_create_switch( _("Bonus Info:"), HINT_BONUS_INFO, &config.bonus_info, _("Off"), _("On") ) );
menu_add( gfx, item_create_separator( "" ) );
item = item_create_switch( _("Display:"), HINT_DISPLAY, &config.fullscreen, _("Window"), _("Fullscreen") );
item->callback = cb_fullscreen;
menu_add( gfx, item );
menu_add( gfx, item_create_switch_x( _("Frame Rate:"), HINT_FPS, &config.fps, str_fps, 2 ) );
menu_add( gfx, item_create_separator( "" ) );
menu_add( gfx, item_create_link( _("Select Theme"), HINT_THEME, theme ) );
menu_add( gfx, item_create_separator( "" ) );
menu_add( gfx, item_create_link( _("Back"), HINT_, _main ) );
/* game */
item_resume_0 = item_create_action( _("Resume Last Game"), "???", ACTION_RESUME_0 );
menu_add( game, item_resume_0 );
slot_update_hint( 0, item_resume_0->hint );
menu_add( game, item_create_action( _("Start Original Set"), HINT_START_LBR, ACTION_PLAY_LBR ) );
menu_add( game, item_create_action( _("Start AddOn"), HINT_START_CUSTOM, ACTION_PLAY_CUSTOM ) );
//menu_add( game, item_create_separator( "" ) );
item_levelset = item_create_switch_x( _("AddOn:"), "", &config.levelset_id_local, levelset_names_local, levelset_count_local );
item_levelset->callback = cb_update_levelset_hint;
cb_update_levelset_hint(); /* initiate first hint */
menu_add( game, item_levelset );
menu_add( game, item_create_switch_x( _("Difficulty:"), HINT_DIFF, &config.diff, str_diff, DIFF_COUNT ) );
menu_add( game, item_create_separator( "" ) );
menu_add( game, item_create_range( _("Players:"), HINT_PLAYERS, &config.player_count, 1, 4, 1 ) );
menu_add( game, item_create_edit( _("1st:"), HINT_PLAYERS, config.player_names[0], 12 ) );
menu_add( game, item_create_edit( _("2nd:"), HINT_PLAYERS, config.player_names[1], 12 ) );
menu_add( game, item_create_edit( _("3rd:"), HINT_PLAYERS, config.player_names[2], 12 ) );
menu_add( game, item_create_edit( _("4th:"), HINT_PLAYERS, config.player_names[3], 12 ) );
menu_add( game, item_create_separator( "" ) );
menu_add( game, item_create_link( _("Back"), HINT_, _main ) );
/* controls */
keys[0] = item_create_key( _("Left:"), HINT_KEYS, &config.k_left, filter );
keys[1] = item_create_key( _("Right:"), HINT_KEYS, &config.k_right, filter );
keys[2] = item_create_key( _("Left Fire:"), HINT_KEYS, &config.k_lfire, filter );
keys[3] = item_create_key( _("Right Fire:"), HINT_KEYS, &config.k_rfire, filter );
keys[4] = item_create_key( _("Paddle Turbo:"), HINT_KEYS, &config.k_turbo, filter );
keys[5] = item_create_key( _("Ball Turbo:"), HINT_KEYS, &config.k_maxballspeed, filter );
keys[6] = item_create_key( _("Return:"), HINT_KEYS, &config.k_return, filter );
// keys[6] = item_create_key( _("Warp:"), HINT_KEYS, &config.k_warp, filter );
for ( i = 0; i < 7; i++ )
menu_add( cont, keys[i] );
/* dynamic restriction */
for ( i = 0; i < 7; i++ )
for ( j = 0; j < 7; j++ )
if ( j != i )
value_add_other_key( keys[i]->value, keys[j]->value );
/* other control stuff */
menu_add( cont, item_create_separator( "" ) );
item = item_create_range( _("Key Speed:"), HINT_KEYSPEED, &config.i_key_speed, 100, 1000, 50 );
item->callback = cb_set_keyspeed;
menu_add( cont, item );
item = item_create_range( _("Motion Modifier:"), HINT_MOD, &config.i_motion_mod, 40, 160, 5 );
item->callback = cb_set_motion_mod;
menu_add( cont, item );
menu_add( cont, item_create_switch( _("Invert Motion:"), HINT_INVERT, &config.invert, _("Off"), _("On") ) );
menu_add( cont, item_create_separator( "" ) );
menu_add( cont, item_create_link( _("Back"), HINT_, _main ) );
/* advanced options */
menu_add( adv, item_create_switch( _("Convex Paddle:"), HINT_CONVEX, &config.convex, _("Off"), _("On") ) );
//menu_add( adv, item_create_switch( _("Corner:"), HINT_CORNER, &config.linear_corner, _("Spherical"), _("Linear") ) );
menu_add( adv,
item_create_switch( _("Ball Fire Angle:"),
HINT_RANDOM_ANGLE, &config.random_angle,
"50", _("Random") ) );
menu_add( adv, item_create_switch( _("Balls:"), HINT_BALLLEVEL, &config.ball_level, _("Below Bonuses"), _("Above Bonuses") ) );
menu_add( adv, item_create_switch( _("Debris:"), HINT_DEBRISLEVEL, &config.debris_level, _("Below Balls"), _("Above Balls") ) );
menu_add( adv, item_create_switch( _("Return Balls:"), HINT_RETURN, &config.return_on_click, _("Auto"), _("By Click") ) );
item = item_create_switch( _("Use Hints:"), HINT_USEHINTS, &config.use_hints, _("Off"), _("On") );
item->callback = cb_hints;
menu_add( adv, item );
menu_add( adv, item_create_range( _("Warp Limit:"), HINT_WARP_LIMIT, &config.rel_warp_limit, 0, 100, 10 ) );
menu_add( adv, item_create_edit( _("Local UDP Port:"), HINT_LOCAL_PORT, config.local_port, 6 ) );
item = item_create_range( _("Acc. Ball Speed:"), HINT_MAXBALLSPEED, &config.maxballspeed_int1000, 600, 900, 20 );
item->callback = cb_maxballspeed;
menu_add( adv, item );
menu_add( adv, item_create_switch( _("Add Bonus Levels:"), HINT_BONUS_LEVELS, &config.addBonusLevels, _("Off"), _("On") ) );
menu_add( adv, item_create_separator( "" ) );
menu_add( adv, item_create_link( _("Back"), HINT_, _main ) );
/* editor */
item_set = item_create_switch_x(
_("Set:"), HINT_EDITOR_SET,
&config.levelset_id_home, levelset_names_home,
levelset_count_home );
item_set->callback = cb_update_edit_set;
menu_add( editor, item_set );
menu_add( editor, item_create_action( _("Edit Set"), HINT_EDITOR_EDIT, ACTION_EDIT ) );
menu_add( editor, item_create_link( _("Delete Set"), HINT_EDITOR_DELETE, confirm_delete ) );
menu_add( editor, item_create_separator( "" ) );
menu_add( editor, item_create_link( _("Back"), HINT_, _main ) );
/* confirm_delete set */
item = item_create_link( _("Yes"), HINT_ ,editor );
item->callback = cb_delete_set;
menu_add( confirm_delete, item );
menu_add( confirm_delete, item_create_link( _("No"), HINT_, editor ) );
/* theme */
item_theme = item_create_switch_x( _("Theme:"), "", &config.theme_id, theme_names, theme_count );
menu_add( theme, item_theme );
item_theme->callback = cb_update_theme_hint;
cb_update_theme_hint();
menu_add( theme, item_create_separator( "" ) );
item = item_create_link( _("Apply"), HINT_APPLY, gfx );
item->callback = cb_change_theme;
menu_add( theme, item );
menu_add( theme, item_create_link( _("Cancel"), HINT_, gfx ) );
/* adjust all menus */
menu_adjust( _main );
#ifdef _1
menu_adjust( options );
#endif
#ifdef AUDIO_ENABLED
menu_adjust( audio );
#endif
menu_adjust( gfx );
menu_adjust( game );
menu_adjust( cont );
menu_adjust( adv );
menu_adjust( editor );
menu_adjust( confirm_delete );
menu_adjust( theme );
/* set main menu as current */
menu_select( _main );
}
void
local_filter_restore(view_t *view)
{
(void)filter_set(&view->local_filter.filter, view->local_filter.prev);
(void)replace_string(&view->local_filter.prev, "");
}
