static void
cleanup_view(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; i++)
free(view->dir_entry[i].name);
free(view->dir_entry);
filter_dispose(&view->manual_filter);
filter_dispose(&view->auto_filter);
}
static void
free_view(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free(view->dir_entry[i].name);
}
dynarray_free(view->dir_entry);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->manual_filter);
filter_dispose(&view->auto_filter);
}
STATIC ASM VOID filter_destruct( register __a2 APTR pool, register __a1 struct filter *ent)
{
if (ent)
{
filter_dispose(ent);
}
}
TEARDOWN()
{
int i;
for(i = 0; i < view->list_rows; i++)
free(view->dir_entry[i].name);
free(view->dir_entry);
filter_dispose(&view->auto_filter);
filter_dispose(&view->manual_filter);
filter_dispose(&view->local_filter.filter);
(void)rmdir("0");
(void)rmdir("1");
(void)rmdir("2");
(void)rmdir("3");
}
void
view_teardown(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->manual_filter);
filter_dispose(&view->auto_filter);
fswatch_free(view->watch);
view->watch = NULL;
}
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);
}
static void
test_append_escapes(void)
{
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
assert_int_equal(0, filter_append(&filter, "ef|gh"));
assert_true(filter_matches(&filter, "ef|gh"));
filter_dispose(&filter);
}
void
view_teardown(FileView *view)
{
int i;
for(i = 0; i < view->list_rows; ++i)
{
free_dir_entry(view, &view->dir_entry[i]);
}
dynarray_free(view->dir_entry);
for(i = 0; i < view->custom.entry_count; ++i)
{
free_dir_entry(view, &view->custom.entries[i]);
}
dynarray_free(view->custom.entries);
filter_dispose(&view->local_filter.filter);
filter_dispose(&view->auto_filter);
filter_dispose(&view->manual_filter);
}
/**************************************************************************
Create a new rule
**************************************************************************/
static void filter_new(void)
{
#if 0
struct filter *f = filter_create();
if (f)
{
DoMethod(filter_listview, MUIM_NList_InsertSingle, f, MUIV_NList_Insert_Bottom);
filter_dispose(f);
set(filter_listview, MUIA_NList_Active, xget(filter_listview, MUIA_NList_Entries)-1);
filter_edit();
}
#endif
}
/**
* Creates a new filter.
*/
static void filter_new(void)
{
struct filter *f = filter_create();
if (f)
{
DoMethod(filter_list, MUIM_NList_InsertSingle, (ULONG)f, MUIV_NList_Insert_Bottom);
filter_dispose(f);
set(filter_list, MUIA_NList_Active, MUIV_NList_Active_Bottom);
if (filter_last_selected) set(filter_name_string, MUIA_BetterString_SelectSize, -utf8len(filter_last_selected->name));
set(filter_wnd, MUIA_Window_ActiveObject, filter_name_string);
}
}
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_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_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);
}
static void
test_empty_value_not_appended(void)
{
char *initial_value;
filter_t filter;
assert_int_equal(0, filter_init(&filter, 1));
initial_value = strdup(filter.raw);
assert_int_equal(1, filter_append(&filter, ""));
assert_string_equal(initial_value, filter.raw);
free(initial_value);
filter_dispose(&filter);
}
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;
}
STATIC ASM SAVEDS VOID filter_destruct(REG(a0,struct Hook *h),REG(a2,APTR pool), REG(a1,struct filter *ent))
{
if (ent) filter_dispose(ent);
}
void
name_filters_add_selection(view_t *view)
{
dir_entry_t *entry;
filter_t filter;
int filtered;
(void)filter_init(&filter, FILTER_DEF_CASE_SENSITIVITY);
/* Traverse items and update/create filter values. */
entry = NULL;
while(iter_selection_or_current(view, &entry))
{
const char *name = entry->name;
char name_with_slash[NAME_MAX + 1 + 1];
if(fentry_is_dir(entry))
{
append_slash(entry->name, name_with_slash, sizeof(name_with_slash));
name = name_with_slash;
}
(void)filter_append(&view->auto_filter, name);
(void)filter_append(&filter, name);
}
/* Even current file might be unavailable for filtering. In this case, just
* do nothing. */
if(filter_is_empty(&filter))
{
filter_dispose(&filter);
return;
}
if(view->custom.type == CV_DIFF)
{
(void)filter_in_compare(view, &filter, &is_newly_filtered);
ui_view_schedule_redraw(view);
filter_dispose(&filter);
return;
}
/* Update entry lists to remove entries that must be filtered out now. No
* view reload is needed. */
filtered = zap_entries(view, view->dir_entry, &view->list_rows,
&is_newly_filtered, &filter, 0, 1);
if(flist_custom_active(view))
{
(void)zap_entries(view, view->local_filter.entries,
&view->local_filter.entry_count, &is_newly_filtered, &filter, 1, 1);
}
else
{
view->filtered += filtered;
}
filter_dispose(&filter);
fpos_ensure_valid_pos(view);
ui_view_schedule_redraw(view);
}
