kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'master' into devs/hermet/lottie

This commit is contained in:
Hermet Park 2019-07-01 20:47:35 +09:00
parent 8bbac405db 229b363f01
commit 9fdfffb14e
85 changed files with 3463 additions and 729 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.travis.yml
View File

@ -52,12 +52,12 @@ jobs:
- os: linux
env: DISTRO=Fedora30 CI_BUILD_TYPE=options-disabled
- os: linux
env: DISTRO=Fedora29 CI_BUILD_TYPE=wayland
env: DISTRO=Fedora30 CI_BUILD_TYPE=wayland
- os: linux
env: DISTRO=Fedora29 CI_BUILD_TYPE=default
env: DISTRO=Fedora30 CI_BUILD_TYPE=default
- os: linux
if: type = cron
env: DISTRO=Fedora29 CI_BUILD_TYPE=release-ready
env: DISTRO=Fedora30 CI_BUILD_TYPE=release-ready
- os: linux
if: type = cron
env: DISTRO=Ubuntu1804

1
data/elementary/themes/default.edc
View File

@ -173,7 +173,6 @@ collections {
#include "edc/efl/calendar.edc"
#include "edc/efl/navigation_bar.edc"
#include "edc/efl/navigation_layout.edc"
#include "edc/efl/nstate.edc"
// XXX: mobile mode needs invisible scrollers... make signals that do this
#include "edc/efl/scroller.edc"
#include "edc/efl/list.edc"

10
data/elementary/themes/edc/efl/nstate.edc
View File

@ -1,10 +0,0 @@
group { "efl/nstate";
inherit: "efl/button";
programs {
program {
signal: "mouse,clicked,1"; source: "event";
action: SIGNAL_EMIT "efl,action,state,changed" "efl";
}
}
}

4
header_checks/meson.build
View File

@ -194,6 +194,10 @@ if (cc.has_header('sys/mman.h'))
config_h.set10('HAVE_MMAN_H', true)
endif
if sys_linux and config_h.has('HAVE_LISTXATTR') and config_h.has('HAVE_SETXATTR') and config_h.has('HAVE_GETXATTR')
config_h.set10('HAVE_XATTR', true)
endif
regexp = []
if sys_windows == true
regexp = cc.find_library('regex',

10
meson.build
View File

@ -8,11 +8,6 @@ if host_machine.system() == 'darwin'
add_languages('objc')
endif
clean_check = run_command('meson/clean_check.sh')
if clean_check.returncode() == 0
error('Meson build requires a clean source tree')
endif
pkgconfig = import('pkgconfig')
test_env = environment()
@ -225,6 +220,11 @@ elif (get_option('crypto') == 'openssl')
config_h.set('HAVE_OPENSSL', '1')
endif
if get_option('crypto') != ''
config_h.set('HAVE_CIPHER', '1')
config_h.set('HAVE_SIGNATURE', '1')
endif
config_h.set_quoted('SHARED_LIB_SUFFIX', '.'+sys_lib_extension)
config_h.set_quoted('MOD_SUFFIX', '.'+sys_mod_extension)
config_h.set_quoted('EXE_SUFFIX', '.'+sys_exe_extension)

3
meson/clean_check.sh
View File

@ -1,3 +0,0 @@
#!/bin/sh
test -f ${MESON_SOURCE_ROOT}/configure

1
src/bin/elementary/meson.build
View File

@ -94,7 +94,6 @@ elementary_test_src = [
'test_naviframe.c',
'test_naviframe_complex.c',
'test_notify.c',
'test_nstate.c',
'test_panel.c',
'test_panes.c',
'test_ui_panes.c',

2
src/bin/elementary/test.c
View File

@ -55,7 +55,6 @@ void test_clock_pause(void *data, Evas_Object *obj, void *event_info);
void test_combobox(void *data, Evas_Object *obj, void *event_info);
void test_check(void *data, Evas_Object *obj, void *event_info);
void test_check_toggle(void *data, Evas_Object *obj, void *event_info);
void test_nstate(void *data, Evas_Object *obj, void *event_info);
void test_radio(void *data, Evas_Object *obj, void *event_info);
void test_layout(void *data, Evas_Object *obj, void *event_info);
void test_layout2(void *data, Evas_Object *obj, void *event_info);
@ -1109,7 +1108,6 @@ add_tests:
ADD_TEST(NULL, "Range Values", "Progressbar", test_progressbar);
ADD_TEST(NULL, "Range Values", "Progressbar 2", test_progressbar2);
ADD_TEST_EO(NULL, "Range Values", "Efl.Ui.Progressbar", test_ui_progressbar);
ADD_TEST_EO(NULL, "Range Values", "Efl.Ui.Nstate", test_nstate);
ADD_TEST_EO(NULL, "Range Values", "Efl.Ui.Slider", test_ui_slider);
ADD_TEST_EO(NULL, "Range Values", "Efl.Ui.Slider_Interval", test_slider_interval);

34
src/bin/elementary/test_nstate.c
View File

@ -1,34 +0,0 @@
#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#include <Efl_Ui.h>
#include <Elementary.h>
static void
_state_changed_cb(void *data EINA_UNUSED, const Efl_Event *ev)
{
int val = efl_ui_nstate_value_get(ev->object);
efl_text_set(ev->object, eina_slstr_printf("nstate = %d", val));
}
void
test_nstate(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED)
{
Evas_Object *win, *bx, *nstate;
win = efl_add_ref(EFL_UI_WIN_CLASS, NULL,
efl_text_set(efl_added, "N-state widget"),
elm_win_autodel_set(efl_added, EINA_TRUE));
bx = efl_add(EFL_UI_BOX_CLASS, win);
efl_content_set(win, bx);
nstate = efl_add(EFL_UI_NSTATE_CLASS, win);
efl_event_callback_add(nstate, EFL_UI_NSTATE_EVENT_CHANGED,
_state_changed_cb, NULL);
efl_ui_nstate_count_set(nstate, 5);
efl_text_set(nstate, "nstate = 0");
efl_pack(bx, nstate);
efl_gfx_entity_size_set(win, EINA_SIZE2D(120, 80));
}

7
src/bin/elementary/test_part_bg.c
View File

@ -4,7 +4,7 @@
#include <Efl_Ui.h>
#include <Elementary.h>
#define MAX_NUM_OF_CONTENT 18
#define MAX_NUM_OF_CONTENT 17
const Efl_Class *content_class[MAX_NUM_OF_CONTENT];
@ -143,9 +143,8 @@ test_part_background(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void
content_class[12] = EFL_UI_BG_CLASS;
content_class[13] = EFL_UI_IMAGE_CLASS;
content_class[14] = EFL_UI_IMAGE_ZOOMABLE_CLASS;
content_class[15] = EFL_UI_NSTATE_CLASS;
content_class[16] = EFL_UI_SPIN_CLASS;
content_class[17] = EFL_UI_SPIN_BUTTON_CLASS;
content_class[15] = EFL_UI_SPIN_CLASS;
content_class[16] = EFL_UI_SPIN_BUTTON_CLASS;
win = efl_add_ref(EFL_UI_WIN_CLASS, NULL,
efl_text_set(efl_added, "Widget Part Background"),

6
src/bin/elementary/test_ui_active_view.c
View File

@ -456,7 +456,7 @@ _animation_cb(void *data, const Efl_Event *ev)
{
Params *params = data;
efl_ui_active_view_view_manager_animation_enabled_set(efl_ui_active_view_manager_get(params->active_view), efl_ui_nstate_value_get(ev->object));
efl_ui_active_view_view_manager_animation_enabled_set(efl_ui_active_view_manager_get(params->active_view), efl_ui_check_selected_get(ev->object));
}
static void
@ -478,8 +478,8 @@ view_animation_cb(void *data,
efl_added, NULL));
ck = efl_add(EFL_UI_CHECK_CLASS, box);
efl_event_callback_add(ck, EFL_UI_NSTATE_EVENT_CHANGED, _animation_cb, params);
efl_ui_nstate_value_set(ck, efl_ui_active_view_view_manager_animation_enabled_get(efl_ui_active_view_manager_get(params->active_view)));
efl_event_callback_add(ck, EFL_UI_CHECK_EVENT_SELECTED_CHANGED, _animation_cb, params);
efl_ui_check_selected_set(ck, efl_ui_active_view_view_manager_animation_enabled_get(efl_ui_active_view_manager_get(params->active_view)));
efl_text_set(ck, "Animation");
efl_pack_end(box, ck);
efl_gfx_entity_visible_set(ck, 1);

2
src/bin/elementary/test_ui_panel.c
View File

@ -114,7 +114,7 @@ test_ui_panel2(void *data EINA_UNUSED, Evas_Object *obj EINA_UNUSED, void *event
check = efl_add(EFL_UI_CHECK_CLASS, box);
efl_ui_check_selected_set(check, elm_config_scroll_thumbscroll_enabled_get());
efl_text_set(check, "Enable thumb scroll (temporarily");
efl_event_callback_add(check, EFL_UI_NSTATE_EVENT_CHANGED, _check_changed, NULL);
efl_event_callback_add(check, EFL_UI_CHECK_EVENT_SELECTED_CHANGED, _check_changed, NULL);
efl_gfx_hint_weight_set(check, EVAS_HINT_EXPAND, 0);
efl_pack(box, check);

8
src/bin/eolian_mono/eolian/mono/events.hh
View File

@ -102,7 +102,13 @@ struct unpack_event_args_visitor
if (eina::optional<bool> b = call_match(match_table, filter_func, accept_func))
return *b;
else
return as_generator("default(" + arg_type + ")").generate(sink, attributes::unused, *context);
{
// Type defined in Eo is passed here. (e.g. enum type defined in Eo)
// Uses conversion from IntPtr with type casting to the given type.
return as_generator(
" (" << arg_type << ")evt.Info"
).generate(sink, attributes::unused, *context);
}
}
bool operator()(grammar::attributes::klass_name const& cls) const
{

24
src/bin/eolian_mono/eolian/mono/klass.hh
View File

@ -196,6 +196,17 @@ struct klass
if (!generate_fields(sink, cls, concrete_cxt))
return false;
if (!as_generator
(
scope_tab << "/// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>\n"
<< scope_tab << "/// <param name=\"ch\">Tag struct storing the native handle of the object being constructed.</param>\n"
<< scope_tab << "private " << concrete_name << "(ConstructingHandle ch) : base(ch)\n"
<< scope_tab << "{\n"
<< scope_tab << "}\n\n"
)
.generate(sink, attributes::unused, concrete_cxt))
return false;
if (!as_generator
(
scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(concrete_cxt).actual_library_name(cls.filename)
@ -246,7 +257,7 @@ struct klass
).generate(sink, attributes::unused, concrete_cxt))
return false;
if(!generate_native_inherit_class(sink, cls, change_indentation(indent.inc(), context)))
if(!generate_native_inherit_class(sink, cls, change_indentation(indent.inc(), concrete_cxt)))
return true;
if(!as_generator("}\n").generate(sink, attributes::unused, concrete_cxt)) return false;
@ -318,7 +329,7 @@ struct klass
).generate(sink, attributes::unused, inherit_cxt))
return false;
if(!generate_native_inherit_class(sink, cls, change_indentation(indent.inc(), context)))
if(!generate_native_inherit_class(sink, cls, change_indentation(indent.inc(), inherit_cxt)))
return true;
if(!as_generator("}\n").generate(sink, attributes::unused, inherit_cxt)) return false;
@ -357,7 +368,7 @@ struct klass
(
indent << lit("/// <summary>Wrapper for native methods and virtual method delegates.\n")
<< indent << "/// For internal use by generated code only.</summary>\n"
<< indent << "public " << (root ? "" : "new " ) << "class " << native_inherit_name << " " << (root ? " : Efl.Eo.NativeClass" : (": " + base_name)) <<"\n"
<< indent << "public new class " << native_inherit_name << " : " << (root ? "Efl.Eo.EoWrapper.NativeMethods" : base_name) << "\n"
<< indent << "{\n"
).generate(sink, attributes::unused, inative_cxt))
return false;
@ -396,7 +407,7 @@ struct klass
).generate(sink, attributes::unused, inative_cxt))
return false;
if(!root)
if (!root || context_find_tag<class_context>(context).current_wrapper_kind != class_context::concrete)
if(!as_generator(indent << scope_tab << scope_tab << "descs.AddRange(base.GetEoOps(type));\n").generate(sink, attributes::unused, inative_cxt))
return false;
@ -492,6 +503,11 @@ struct klass
<< (*(scope_tab << scope_tab << constructor_invocation << "\n"))
<< scope_tab << scope_tab << "FinishInstantiation();\n"
<< scope_tab << "}\n\n"
<< scope_tab << "/// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>\n"
<< scope_tab << "/// <param name=\"ch\">Tag struct storing the native handle of the object being constructed.</param>\n"
<< scope_tab << "protected " << inherit_name << "(ConstructingHandle ch) : base(ch)\n"
<< scope_tab << "{\n"
<< scope_tab << "}\n\n"
<< scope_tab << "/// <summary>Initializes a new instance of the <see cref=\"" << inherit_name << "\"/> class.\n"
<< scope_tab << "/// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>\n"
<< scope_tab << "/// <param name=\"raw\">The native pointer to be wrapped.</param>\n"

34
src/bin/eolian_mono/eolian/mono/marshall_type.hh
View File

@ -26,23 +26,41 @@ struct marshall_annotation_visitor_generate;
*/
struct marshall_type_generator
{
marshall_type_generator(bool is_return = false)
: is_return(is_return) {}
marshall_type_generator(bool is_return = false, bool is_special_subtype = false)
: is_return(is_return)
, is_special_subtype(is_special_subtype)
{}
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::type_def const& type, Context const& context) const
{
return type.original_type.visit(detail::marshall_type_visitor_generate<OutputIterator, Context>{sink, &context, type.c_type, false, is_return, type.is_ptr });
return type.original_type.visit(detail::marshall_type_visitor_generate<OutputIterator, Context>{
sink
, &context
, type.c_type
, false
, is_return
, type.is_ptr
, is_special_subtype
});
}
/* Some types may require a different conversion when they are in @out parameters. */
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
{
return param.type.original_type.visit(detail::marshall_type_visitor_generate<OutputIterator, Context>{sink, &context, param.type.c_type
, param.direction != attributes::parameter_direction::in, false, param.type.is_ptr});
return param.type.original_type.visit(detail::marshall_type_visitor_generate<OutputIterator, Context>{
sink
, &context
, param.type.c_type
, param.direction != attributes::parameter_direction::in
, false
, param.type.is_ptr
, is_special_subtype
});
}
bool is_return;
bool is_special_subtype;
};
/*
@ -73,9 +91,9 @@ struct marshall_annotation_generator
struct marshall_type_terminal
{
marshall_type_generator const operator()(bool is_return) const
marshall_type_generator const operator()(bool is_return, bool is_special_subtype = false) const
{
return marshall_type_generator(is_return);
return marshall_type_generator(is_return, is_special_subtype);
}
} const marshall_type = {};

47
src/bin/eolian_mono/eolian/mono/marshall_type_impl.hh
View File

@ -25,6 +25,7 @@ struct marshall_type_visitor_generate
bool is_out;
bool is_return;
bool is_ptr;
bool is_special_subtype;
typedef marshall_type_visitor_generate<OutputIterator, Context> visitor_type;
typedef bool result_type;
@ -70,12 +71,16 @@ struct marshall_type_visitor_generate
{
regular_type_def r = regular;
r.base_qualifier.qualifier ^= qualifier_info::is_ref;
if (is_special_subtype)
return replace_base_type(r, "Eina.Stringshare");
return replace_base_type(r, "System.String");
}}
, {"stringshare", false, [&]
{
regular_type_def r = regular;
r.base_qualifier.qualifier ^= qualifier_info::is_ref;
if (is_special_subtype)
return replace_base_type(r, "Eina.Stringshare");
return replace_base_type(r, "System.String");
}}
, {"strbuf", nullptr, [&]
@ -171,16 +176,40 @@ struct marshall_type_visitor_generate
regular_type_def r = regular;
r.base_type = "System.IntPtr";
r.namespaces.clear();
return visitor_generate<OutputIterator, Context>{sink, context, c_type, is_out, is_return, is_ptr}(r);
return visitor_generate<OutputIterator, Context>{
sink
, context
, c_type
, is_out
, is_return
, is_ptr
, is_special_subtype
}(r);
}
else
{
return visitor_generate<OutputIterator, Context>{sink, context, c_type, is_out, is_return, is_ptr}(regular);
return visitor_generate<OutputIterator, Context>{
sink
, context
, c_type
, is_out
, is_return
, is_ptr
, is_special_subtype
}(regular);
}
}
bool operator()(attributes::klass_name klass_name) const
{
return visitor_generate<OutputIterator, Context>{sink, context, c_type, is_out, is_return, is_ptr}(klass_name);
return visitor_generate<OutputIterator, Context>{
sink
, context
, c_type
, is_out
, is_return
, is_ptr
, is_special_subtype
}(klass_name);
}
bool operator()(attributes::complex_type_def const& complex) const
{
@ -225,7 +254,7 @@ struct marshall_type_visitor_generate
{
regular_type_def no_pointer_regular = complex.outer;
return visitor_type{sink, context, c_type, false}(no_pointer_regular)
&& as_generator("<" << (type % ", ") << ">").generate(sink, complex.subtypes, *context);
&& as_generator("<" << (type(false, false, true) % ", ") << ">").generate(sink, complex.subtypes, *context);
};
if(eina::optional<bool> b = call_match
@ -250,7 +279,15 @@ struct marshall_type_visitor_generate
return *b;
}
return visitor_generate<OutputIterator, Context>{sink, context, c_type, is_out, is_return, is_ptr}(complex);
return visitor_generate<OutputIterator, Context>{
sink
, context
, c_type
, is_out
, is_return
, is_ptr
, is_special_subtype
}(complex);
}
};
} }

84
src/bin/eolian_mono/eolian/mono/parameter.hh
View File

@ -604,8 +604,6 @@ struct native_convert_in_variable_generator
}
else if (param.type.c_type == "Eina_Array *" || param.type.c_type == "const Eina_Array *"
|| param.type.c_type == "Eina_List *" || param.type.c_type == "const Eina_List *"
|| param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
|| param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
@ -618,6 +616,19 @@ struct native_convert_in_variable_generator
<< ");\n"
).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
}
else if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
|| param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
if (!complex)
return false;
return as_generator(
"var " << string << " = new " << type << "(" << escape_keyword(param.param_name)
<< ", " << (param.type.has_own ? "true" : "false")
<< ");\n"
).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
}
else if (param.type.c_type == "Eina_Value")
{
return as_generator(
@ -706,6 +717,13 @@ struct convert_in_variable_generator
escape_keyword(param.param_name) << ".Own = false;\n"
).generate(sink, attributes::unused, context))
return false;
// Iterators and Accessors can't own their content.
if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
|| param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
)
return true;
if (complex->subtypes.front().has_own && !as_generator(
escape_keyword(param.param_name) << ".OwnContent = false;\n"
).generate(sink, attributes::unused, context))
@ -937,14 +955,6 @@ struct convert_out_assign_generator
|| param_is_acceptable(param, "Eina_List *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_List *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_List *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Iterator *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Iterator *", !WANT_OWN, WANT_OUT)
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
@ -957,6 +967,25 @@ struct convert_out_assign_generator
<< ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type, out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "Eina_Iterator *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Iterator *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
if (!complex)
return false;
return as_generator(
string << " = new " << type << "(" << string
<< ", " << (param.type.has_own ? "true" : "false")
<< ");\n"
).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type, out_variable_name(param.param_name)), context);
}
else if (param_is_acceptable(param, "Eina_Value", WANT_OWN, WANT_OUT)
|| param_is_acceptable(param, "Eina_Value", !WANT_OWN, WANT_OUT))
{
@ -1057,9 +1086,7 @@ struct convert_return_generator
}
else if (ret_type.c_type == "Eina_Array *" || ret_type.c_type == "const Eina_Array *"
|| ret_type.c_type == "Eina_List *" || ret_type.c_type == "const Eina_List *"
|| ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *"
|| ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *"
)
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
if (!complex)
@ -1070,6 +1097,17 @@ struct convert_return_generator
.generate(sink, ret_type, context))
return false;
}
else if(ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *"
|| ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *"
)
{
attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
if (!complex)
return false;
if (!as_generator("return new " << type << "(_ret_var, " << std::string{ret_type.has_own ? "true" : "false"} << ");\n")
.generate(sink, ret_type, context))
return false;
}
else if (ret_type.c_type != "void")
{
return as_generator("return _ret_var;\n").generate(sink, ret_type, context);
@ -1199,6 +1237,13 @@ struct native_convert_out_assign_generator
string << ".Own = false;\n"
).generate(sink, outvar, context))
return false;
// Iterators and Accessors can't own their content.
if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
|| param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
)
return true;
if (complex->subtypes.front().has_own && !as_generator(
string << ".OwnContent = false;\n"
).generate(sink, outvar, context))
@ -1319,9 +1364,16 @@ struct native_convert_return_generator
if (ret_type.has_own && !as_generator("_ret_var.Own = false; ")
.generate(sink, attributes::unused, context))
return false;
if (complex->subtypes.front().has_own && !as_generator("_ret_var.OwnContent = false; ")
.generate(sink, attributes::unused, context))
return false;
// Iterators and Accessors can't own their content.
if (ret_type.c_type != "Eina_Iterator *" && ret_type.c_type != "const Eina_Iterator *"
&& ret_type.c_type != "Eina_Accessor *" && ret_type.c_type != "const Eina_Accessor *"
)
{
if (complex->subtypes.front().has_own && !as_generator("_ret_var.OwnContent = false; ")
.generate(sink, attributes::unused, context))
return false;
}
return as_generator("return _ret_var.Handle;\n")
.generate(sink, attributes::unused, context);

12
src/bin/eolian_mono/eolian/mono/struct_definition.hh
View File

@ -88,7 +88,7 @@ struct to_internal_field_convert_generator
else if (regular && regular->base_type == "stringshare")
{
if (!as_generator(
indent << scope_tab << scope_tab << "_internal_struct." << string << " = Eina.Stringshare.eina_stringshare_add(_external_struct." << string << ");\n")
indent << scope_tab << scope_tab << "_internal_struct." << string << " = Eina.MemoryNative.AddStringshare(_external_struct." << string << ");\n")
.generate(sink, std::make_tuple(field_name, field_name), context))
return false;
}
@ -171,8 +171,7 @@ struct to_external_field_convert_generator
return false;
}
else if (complex && (complex->outer.base_type == "array"
|| complex->outer.base_type == "list"
|| complex->outer.base_type == "iterator"))
|| complex->outer.base_type == "list"))
{
// Always assumes pointer
if (!as_generator(
@ -187,6 +186,13 @@ struct to_external_field_convert_generator
.generate(sink, std::make_tuple(field_name, field.type, field_name), context))
return false;
}
else if (complex && complex->outer.base_type == "iterator")
{
if (!as_generator(
indent << scope_tab << scope_tab << "_external_struct." << string << " = new " << type << "(_internal_struct." << string << ", false);\n")
.generate(sink, std::make_tuple(field_name, field.type, field_name), context))
return false;
}
else if (field.type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion(regular))
{
if (!as_generator(

38
src/bin/eolian_mono/eolian/mono/type.hh
View File

@ -14,29 +14,49 @@ struct visitor_generate;
struct type_generator
{
type_generator(bool is_return = false, bool is_optional = false)
: is_return(is_return), is_optional(is_optional) {}
type_generator(bool is_return = false, bool is_optional = false, bool is_special_subtype = false)
: is_return(is_return)
, is_optional(is_optional)
, is_special_subtype(is_special_subtype)
{}
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::type_def const& type, Context const& context) const
{
return type.original_type.visit(visitor_generate<OutputIterator, Context>{sink, &context, type.c_type, false, is_return, type.is_ptr, is_optional});
return type.original_type.visit(visitor_generate<OutputIterator, Context>{
sink
, &context
, type.c_type
, false
, is_return
, type.is_ptr
, is_optional
, is_special_subtype
});
}
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::parameter_def const& param, Context const& context) const
{
return param.type.original_type.visit(visitor_generate<OutputIterator, Context>{sink, &context, param.type.c_type
, param.direction != attributes::parameter_direction::in, false, param.type.is_ptr, is_optional});
return param.type.original_type.visit(visitor_generate<OutputIterator, Context>{
sink
, &context
, param.type.c_type
, param.direction != attributes::parameter_direction::in
, false
, param.type.is_ptr
, is_optional
, is_special_subtype
});
}
bool is_return, is_optional;
bool is_return, is_optional, is_special_subtype;
};
struct type_terminal
{
type_generator const operator()(bool is_return, bool is_optional = false) const
type_generator const operator()(bool is_return, bool is_optional = false, bool is_special_subtype = false) const
{
return type_generator(is_return, is_optional);
return type_generator(is_return, is_optional, is_special_subtype);
}
} const type = {};

5
src/bin/eolian_mono/eolian/mono/type_impl.hh
View File

@ -99,6 +99,7 @@ struct visitor_generate
bool is_return;
bool is_ptr;
mutable bool is_optional;
bool is_special_subtype;
typedef visitor_generate<OutputIterator, Context> visitor_type;
typedef bool result_type;
@ -205,6 +206,8 @@ struct visitor_generate
{
regular_type_def r = regular;
r.base_qualifier.qualifier ^= qualifier_info::is_ref;
if (is_special_subtype)
return replace_base_type(r, "Eina.Stringshare");
return replace_base_type(r, "System.String");
}}
, {"strbuf", nullptr, [&]
@ -400,7 +403,7 @@ struct visitor_generate
// if(is_out)
// pointers.push_back({{attributes::qualifier_info::is_none, {}}, true});
return visitor_type{sink, context, c_type, false}(no_pointer_regular)
&& as_generator("<" << (type % ", ") << ">").generate(sink, complex.subtypes, *context)
&& as_generator("<" << (type(false, false, true) % ", ") << ">").generate(sink, complex.subtypes, *context)
;
// && detail::generate_pointers(sink, pointers, *context, false);
};

16
src/bindings/mono/efl_mono/efl_csharp_application.cs
View File

@ -88,7 +88,7 @@ public abstract class Application
/// <summary>
/// Called when the application is started. Arguments from the command line are passed here.
/// </summary>
protected abstract void OnInitialize(Eina.Array<System.String> args);
protected abstract void OnInitialize(string[] args);
/// <summary>
/// Arguments are passed here, Additional calls to this function may occure,
@ -130,8 +130,8 @@ public abstract class Application
{
Init(components);
Efl.App app = Efl.App.AppMain;
Eina.Array<String> command_line = new Eina.Array<String>();
command_line.Append(Environment.GetCommandLineArgs());
var command_line = new Eina.Array<Eina.Stringshare>();
command_line.Append(Array.ConvertAll(Environment.GetCommandLineArgs(), s => (Eina.Stringshare)s));
#if EFL_BETA
app.SetCommandArray(command_line);
#endif
@ -139,7 +139,15 @@ public abstract class Application
{
if (evt.arg.Initialization)
{
OnInitialize(evt.arg.Argv);
var evtArgv = evt.arg.Argv;
int n = evtArgv.Length;
var argv = new string[n];
for (int i = 0; i < n; ++i)
{
argv[i] = evtArgv[i];
}
OnInitialize(argv);
}
OnArguments(evt.arg);

2
src/bindings/mono/eina_mono/eina_array.cs
View File

@ -315,7 +315,7 @@ public class Array<T> : IEnumerable<T>, IDisposable
public Eina.Iterator<T> GetIterator()
{
return new Eina.Iterator<T>(eina_array_iterator_new(Handle), true, false);
return new Eina.Iterator<T>(eina_array_iterator_new(Handle), true);
}
public IEnumerator<T> GetEnumerator()

43
src/bindings/mono/eina_mono/eina_common.cs
View File

@ -75,6 +75,30 @@ public static class MemoryNative
return NativeCustomExportFunctions.efl_mono_native_strdup(str);
}
public static IntPtr AddStringshare(string str)
{
IntPtr nativeStr = StringConversion.ManagedStringToNativeUtf8Alloc(str);
try
{
var strShare = NativeMethods.eina_stringshare_add(nativeStr);
return strShare;
}
finally
{
Eina.MemoryNative.Free(nativeStr);
}
}
public static void DelStringshare(IntPtr str)
{
NativeMethods.eina_stringshare_del(str);
}
public static void DelStringshareRef(IntPtr ptr)
{
NativeMethods.efl_mono_native_stringshare_del_ref(ptr);
}
// IntPtr's for some native functions
public static IntPtr PtrCompareFuncPtrGet()
{
@ -91,6 +115,11 @@ public static class MemoryNative
return NativeCustomExportFunctions.efl_mono_native_free_addr_get();
}
public static IntPtr StringshareDelFuncPtrGet()
{
return NativeMethods.efl_mono_native_stringshare_del_addr_get();
}
public static IntPtr EflUnrefFuncPtrGet()
{
return NativeCustomExportFunctions.efl_mono_native_efl_unref_addr_get();
@ -130,9 +159,17 @@ public static class StringConversion
byte[] strbuf = Encoding.UTF8.GetBytes(managedString);
IntPtr native = MemoryNative.Alloc(strbuf.Length + 1);
Marshal.Copy(strbuf, 0, native, strbuf.Length);
Marshal.WriteByte(native + strbuf.Length, 0); // write the terminating null
return native;
try
{
Marshal.Copy(strbuf, 0, native, strbuf.Length);
Marshal.WriteByte(native + strbuf.Length, 0); // write the terminating null
return native;
}
catch(Exception e)
{
MemoryNative.Free(native);
throw e;
}
}
public static string NativeUtf8ToManagedString(IntPtr pNativeData)

153
src/bindings/mono/eina_mono/eina_container_common.cs
View File

@ -19,6 +19,7 @@ public enum ElementType
{
NumericType,
StringType,
StringshareType,
ObjectType
};
@ -195,6 +196,145 @@ public class StringElementTraits : IBaseElementTraits<string>
}
}
public class StringshareElementTraits : IBaseElementTraits<Eina.Stringshare>
{
public StringshareElementTraits()
{
}
public IntPtr ManagedToNativeAlloc(Eina.Stringshare man)
{
var strShare = MemoryNative.AddStringshare(man);
return strShare;
}
public IntPtr ManagedToNativeAllocInlistNode(Eina.Stringshare man)
{
var node = new InlistNode<IntPtr>();
node.Val = ManagedToNativeAlloc(man);
GCHandle pinnedData = GCHandle.Alloc(node, GCHandleType.Pinned);
IntPtr ptr = pinnedData.AddrOfPinnedObject();
IntPtr nat = MemoryNative.AllocCopy
(ptr, Marshal.SizeOf<InlistMem>() + Marshal.SizeOf<IntPtr>());
pinnedData.Free();
return nat;
}
public void ManagedToNativeCopyTo(Eina.Stringshare man, IntPtr mem)
{
IntPtr stringptr = ManagedToNativeAlloc(man);
Marshal.WriteIntPtr(mem, stringptr);
}
public void NativeFree(IntPtr nat)
{
if (nat != IntPtr.Zero)
{
MemoryNative.DelStringshare(nat);
}
}
public void NativeFreeInlistNodeElement(IntPtr nat)
{
if (nat == IntPtr.Zero)
{
return;
}
var val = Marshal.PtrToStructure<IntPtr>
(nat + Marshal.SizeOf<InlistMem>());
NativeFree(val);
}
public void NativeFreeInlistNode(IntPtr nat, bool freeElement)
{
if (nat == IntPtr.Zero)
{
return;
}
if (freeElement)
{
NativeFreeInlistNodeElement(nat);
}
MemoryNative.Free(nat);
}
public void NativeFreeInplace(IntPtr nat)
{
MemoryNative.DelStringshareRef(nat);
}
public void ResidueFreeInplace(IntPtr nat)
{
}
public Eina.Stringshare NativeToManaged(IntPtr nat)
{
if (nat == IntPtr.Zero)
{
return default(Eina.Stringshare);
}
return StringConversion.NativeUtf8ToManagedString(nat);
}
public Eina.Stringshare NativeToManagedInlistNode(IntPtr nat)
{
if (nat == IntPtr.Zero)
{
Eina.Log.Error("Null pointer for Inlist node.");
return default(Eina.Stringshare);
}
IntPtr ptr_location = nat + Marshal.SizeOf<InlistMem>();
return NativeToManaged(Marshal.ReadIntPtr(ptr_location));
}
// Strings inplaced are always a pointer, because they are variable-sized
public Eina.Stringshare NativeToManagedInplace(IntPtr nat)
{
if (nat == IntPtr.Zero)
{
return default(Eina.Stringshare);
}
nat = Marshal.ReadIntPtr(nat);
if (nat == IntPtr.Zero)
{
return default(Eina.Stringshare);
}
return NativeToManaged(nat);
}
public IntPtr EinaCompareCb()
{
return MemoryNative.StrCompareFuncPtrGet();
}
public IntPtr EinaFreeCb()
{
return MemoryNative.StringshareDelFuncPtrGet();
}
public IntPtr EinaHashNew()
{
return eina_hash_stringshared_new(MemoryNative.StringshareDelFuncPtrGet());
}
public IntPtr EinaInarrayNew(uint step)
{
return eina_inarray_new((uint)Marshal.SizeOf<IntPtr>(), step);
}
public IntPtr EinaHashIteratorKeyNew(IntPtr hash)
{
return eina_hash_iterator_key_new(hash);
}
}
public class EflObjectElementTraits<T> : IBaseElementTraits<T>
{
public IntPtr ManagedToNativeAlloc(T man)
@ -709,6 +849,11 @@ public static class TraitFunctions
return type == typeof(string);
}
public static bool IsStringshare(System.Type type)
{
return type == typeof(Eina.Stringshare);
}
public static Eina.ElementType GetElementTypeCode(System.Type type)
{
if (IsEflObject(type))
@ -719,6 +864,10 @@ public static class TraitFunctions
{
return ElementType.StringType;
}
else if (IsStringshare(type))
{
return ElementType.StringshareType;
}
else
{
return ElementType.NumericType;
@ -764,6 +913,10 @@ public static class TraitFunctions
{
traits = new StringElementTraits();
}
else if (IsStringshare(type))
{
traits = new StringshareElementTraits();
}
else if (type.IsValueType)
{
if (type == typeof(int))

10
src/bindings/mono/eina_mono/eina_hash.cs
View File

@ -363,7 +363,9 @@ public class Hash<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IDi
private static bool ForceRefKey<T>()
{
return (!typeof(T).IsValueType) && (typeof(T) != typeof(string));
return (!typeof(T).IsValueType)
&& (typeof(T) != typeof(string))
&& (typeof(T) != typeof(Eina.Stringshare));
}
private static IntPtr CopyNativeObject<T>(T value, bool forceRef)
@ -439,7 +441,7 @@ public class Hash<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IDi
IntPtr old = eina_hash_set(Handle, nk, nv);
FreeNativeIndirection<TKey>(gchnk, ForceRefKey<TKey>());
FreeNativeIndirection<TValue>(gchnv, false);
if (OwnValue || old != IntPtr.Zero)
if (OwnValue && old != IntPtr.Zero)
{
NativeFree<TValue>(old);
}
@ -485,12 +487,12 @@ public class Hash<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IDi
public Eina.Iterator<TKey> Keys()
{
return new Eina.Iterator<TKey>(EinaHashIteratorKeyNew<TKey>(Handle), true, false);
return new Eina.Iterator<TKey>(EinaHashIteratorKeyNew<TKey>(Handle), true);
}
public Eina.Iterator<TValue> Values()
{
return new Eina.Iterator<TValue>(eina_hash_iterator_data_new(Handle), true, false);
return new Eina.Iterator<TValue>(eina_hash_iterator_data_new(Handle), true);
}
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()

4
src/bindings/mono/eina_mono/eina_inarray.cs
View File

@ -358,12 +358,12 @@ public class Inarray<T> : IEnumerable<T>, IDisposable
public Eina.Iterator<T> GetIterator()
{
return new Eina.Iterator<T>(eina_inarray_iterator_new(Handle), true, false);
return new Eina.Iterator<T>(eina_inarray_iterator_new(Handle), true);
}
public Eina.Iterator<T> GetReversedIterator()
{
return new Eina.Iterator<T>(eina_inarray_iterator_reversed_new(Handle), true, false);
return new Eina.Iterator<T>(eina_inarray_iterator_reversed_new(Handle), true);
}
public IEnumerator<T> GetEnumerator()

2
src/bindings/mono/eina_mono/eina_inlist.cs
View File

@ -314,7 +314,7 @@ public class Inlist<T> : IEnumerable<T>, IDisposable
public Eina.Iterator<T> GetIterator()
{
return new Eina.Iterator<T>(eina_inlist_iterator_wrapper_new_custom_export_mono(Handle), true, false);
return new Eina.Iterator<T>(eina_inlist_iterator_wrapper_new_custom_export_mono(Handle), true);
}
public IEnumerator<T> GetEnumerator()

31
src/bindings/mono/eina_mono/eina_iterator.cs
View File

@ -33,20 +33,11 @@ public class Iterator<T> : IEnumerable<T>, IDisposable
{
public IntPtr Handle {get;set;} = IntPtr.Zero;
public bool Own {get;set;} = true;
public bool OwnContent {get;set;} = false;
public Iterator(IntPtr handle, bool own)
{
Handle = handle;
Own = own;
OwnContent = own;
}
public Iterator(IntPtr handle, bool own, bool ownContent)
{
Handle = handle;
Own = own;
OwnContent = ownContent;
}
~Iterator()
@ -63,14 +54,6 @@ public class Iterator<T> : IEnumerable<T>, IDisposable
return;
}
if (OwnContent)
{
for (IntPtr data; eina_iterator_next(h, out data);)
{
NativeFree<T>(data);
}
}
if (Own)
{
if (disposing)
@ -102,16 +85,9 @@ public class Iterator<T> : IEnumerable<T>, IDisposable
return h;
}
public void SetOwnership(bool ownAll)
{
Own = ownAll;
OwnContent = ownAll;
}
public void SetOwnership(bool own, bool ownContent)
public void SetOwnership(bool own)
{
Own = own;
OwnContent = ownContent;
}
public bool Next(out T res)
@ -125,11 +101,6 @@ public class Iterator<T> : IEnumerable<T>, IDisposable
res = NativeToManaged<T>(data);
if (OwnContent)
{
NativeFree<T>(data);
}
return true;
}

4
src/bindings/mono/eina_mono/eina_list.cs
View File

@ -353,12 +353,12 @@ public class List<T> : IEnumerable<T>, IDisposable
public Eina.Iterator<T> GetIterator()
{
return new Eina.Iterator<T>(eina_list_iterator_new(Handle), true, false);
return new Eina.Iterator<T>(eina_list_iterator_new(Handle), true);
}
public Eina.Iterator<T> GetReversedIterator()
{
return new Eina.Iterator<T>(eina_list_iterator_reversed_new(Handle), true, false);
return new Eina.Iterator<T>(eina_list_iterator_reversed_new(Handle), true);
}
public IEnumerator<T> GetEnumerator()

12
src/bindings/mono/eina_mono/eina_promises.cs
View File

@ -180,6 +180,8 @@ public class Promise : IDisposable
{
SanityChecks();
eina_promise_resolve(this.Handle, value);
// Promise will take care of releasing this value correctly.
value.ReleaseOwnership();
this.Handle = IntPtr.Zero;
// Resolving a cb does *not* call its cancellation callback, so we have to release the
// lambda created in the constructor for cleanup.
@ -224,11 +226,12 @@ public class Future
/// </summary>
public Future(IntPtr handle)
{
Handle = ThenRaw(handle, (Eina.Value value) =>
handle = ThenRaw(handle, (Eina.Value value) =>
{
Handle = IntPtr.Zero;
return value;
});
Handle = handle;
}
/// <summary>
@ -304,7 +307,12 @@ public class Future
ResolvedCb cb = handle.Target as ResolvedCb;
if (cb != null)
{
value = cb(value);
Eina.Value managedValue = cb(value);
// Both `value` and `managedValue` will point to the same internal value data.
// Avoid C# wrapper invalidating the underlying C Eina_Value as the eina_future.c
// code will release it.
value = managedValue.GetNative();
managedValue.ReleaseOwnership();
}
else
{

220
src/bindings/mono/eina_mono/eina_stringshare.cs
View File

@ -7,14 +7,224 @@ using System.Runtime.InteropServices;
namespace Eina
{
public class Stringshare
// TODO: move all native functions to a "NativeMethods" class
public static partial class NativeMethods
{
[DllImport(efl.Libs.Eina)] public static extern IntPtr
eina_stringshare_add(IntPtr str);
[DllImport(efl.Libs.Eina)] public static extern System.IntPtr
eina_stringshare_add_length(string str, System.UInt32 slen);
[DllImport(efl.Libs.Eina)] public static extern System.IntPtr
eina_stringshare_add(string str);
eina_stringshare_add_length(IntPtr str, UInt32 slen);
[DllImport(efl.Libs.Eina)] public static extern void
eina_stringshare_del(System.IntPtr str);
eina_stringshare_del(IntPtr str);
[DllImport(efl.Libs.CustomExports)] public static extern void
efl_mono_native_stringshare_del_ref(IntPtr str);
[DllImport(efl.Libs.CustomExports)] public static extern IntPtr
efl_mono_native_stringshare_del_addr_get();
}
/// <summary>
/// Placeholder type to interact with the native type Eina_Stringshare, mainly for eina containers.
/// </summary>
/// <remarks>
/// Using System.String and merely converting this type to it (by cast or implicitly)
/// is recommended for simplicity and ease of use.
///
/// This type is just a System.String wrapper that works as a placeholder for
/// instrumentalizing proper interaction with native EFL API that demands
/// strings to be stringshares.
///
/// Both C strings and eina stringshares are bound as regular strings in EFL#,
/// as working directly with these types would demand unnecessary hassle from
/// the user viewpoint.
/// But for eina containers this distinction is important, and since C# generics
/// do not provide a convenient way of dealing with the same type requiring
/// a different management based on some other condition (at least not without
/// compromising the usability for other types), we use this string wrapper
/// in order to signal this distinction.
///
/// Implements equality/inequality methods for easier comparison with strings and
/// other Stringshare objects. For more specific operations convert to a string.
/// </remarks>
public class Stringshare : IEquatable<Stringshare>, IEquatable<string>
{
/// <sumary>
/// Main constructor. Wrap the given string.
/// Have private acess to avoid wrapping a null reference,
/// use convertion or the factory method to create a new instance.
/// <see cref="Stringshare.Create(string s)"/>
/// <see cref="Stringshare.operator Stringshare(string s)"/>
/// </sumary>
private Stringshare(string s)
{
Str = s;
}
/// <sumary>
/// Auto-implemented property that holds the wrapped string value.
/// </sumary>
public string Str { get; private set; }
/// <sumary>
/// Factory method to instantiate a new object.
/// Get a wrappper for the given string or a null reference if the given
/// string reference is also null.
/// <seealso cref="Stringshare.operator Stringshare(string s)"/>
/// </sumary>
/// <returns>
/// A new instance wrapping the given string, or a null reference if
/// the given string reference is also null.
/// </returns>
public static Stringshare Create(string s)
{
if (s == null)
{
return null;
}
return new Stringshare(s);
}
/// <sumary>
/// Implicit convertion to string.
/// </sumary>
public static implicit operator string(Stringshare ss)
{
if (ReferenceEquals(null, ss))
{
return null;
}
return ss.Str;
}
/// <sumary>
/// Implicit convertion from string to Stringshare.
/// </sumary>
/// <remarks>
/// Note that this method can be used to create an instance of this class,
/// either via an explicit cast or an implicit convertion.
/// <seealso cref="Stringshare.Create(string s)"/>
/// </remarks>
public static implicit operator Stringshare(string s)
{
if (ReferenceEquals(null, s))
{
return null;
}
return new Stringshare(s);
}
/// <sumary>
/// Check two Stringshare objects for equality.
/// </sumary>
/// <returns>
/// True if both wrapped strings have the same content or if both
/// references are null, false otherwise.
/// </returns>
public static bool operator==(Stringshare ss1, Stringshare ss2)
{
return ((string)ss1) == ((string)ss2);
}
/// <sumary>
/// Check two Stringshare objects for inequality.
/// </sumary>
/// <returns>
/// True if the wrapped strings have different content or if one reference is null
/// and the other is not, false otherwise.
/// </returns>
public static bool operator!=(Stringshare ss1, Stringshare ss2)
{
return !(ss1 == ss2);
}
/// <sumary>
/// Returns the wrapped string.
/// <seealso cref="Stringshare.Str"/>
/// <seealso cref="Stringshare.Get()"/>
/// </sumary>
/// <returns>The wrapped string. Same as the property Str.</returns>
public override string ToString()
{
return Str;
}
/// <sumary>
/// Override of GetHashCode for consistency with user-defined equality methods.
/// </sumary>
/// <returns>
/// The wrapped string hash code.
/// </returns>
public override int GetHashCode()
{
return Str.GetHashCode();
}
/// <sumary>
/// Check the given object for equality.
/// </sumary>
/// <returns>
/// True if the given object is the same object or if it is another Stringshare object
/// and both wrapped strings are equal or if it is a string object and its content
/// is the same of the wrapped string.
/// In any other case it returns false.
/// </returns>
public override bool Equals(object other)
{
if (ReferenceEquals(null, other))
{
return false;
}
if (ReferenceEquals(this, other))
{
return true;
}
if (other.GetType() == typeof(string))
{
return this.Str == (string)other;
}
return other.GetType() == typeof(Stringshare) && this == ((Stringshare)other);
}
/// <sumary>
/// Check the given Stringshare for equality.
/// </sumary>
/// <returns>
/// True if the given Stringshare object is not null and its wrapped string
/// have the same content of this.Str, false otherwise.
/// </returns>
public bool Equals(Stringshare other)
{
return this == other;
}
/// <sumary>
/// Check the given Stringshare for equality.
/// </sumary>
/// <returns>
/// True if the given string is not null and the wrapped string have the same
/// content of the given string, false otherwise.
/// </returns>
public bool Equals(string other)
{
return this.Str == other;
}
/// <sumary>
/// Get the wrapped string.
/// <seealso cref="Stringshare.Str"/>
/// <seealso cref="Stringshare.ToString()"/>
/// </sumary>
/// <returns>The wrapped string. Same as the property Str.</returns>
public string Get()
{
return Str;
}
}
}

24
src/bindings/mono/eina_mono/eina_value.cs
View File

@ -46,6 +46,9 @@ static internal class UnsafeNativeMethods
[DllImport(efl.Libs.Eina)]
internal static extern void eina_value_free(IntPtr type);
[DllImport(efl.Libs.Eina)]
internal static extern IntPtr eina_value_type_name_get(IntPtr type);
[DllImport(efl.Libs.Eina)]
[return: MarshalAsAttribute(UnmanagedType.U1)]
internal static extern bool eina_value_convert(IntPtr handle, IntPtr convert);
@ -725,7 +728,16 @@ static class ValueTypeBridge
LoadTypes();
}
return NativeToManaged[native];
try
{
return NativeToManaged[native];
}
catch (KeyNotFoundException)
{
var name_ptr = eina_value_type_name_get(native);
var name = Marshal.PtrToStringAnsi(name_ptr);
throw new Efl.EflException($"Unknown native eina value Type: 0x{native.ToInt64():x} with name {name}");
}
}
public static IntPtr GetNative(ValueType valueType)
@ -978,8 +990,7 @@ public class Value : IDisposable, IComparable<Value>, IEquatable<Value>
// free(), avoiding a call to eina_value_flush that would wipe the underlying value contents
// for pointer types like string.
tmp = MemoryNative.Alloc(Marshal.SizeOf(typeof(ValueNative)));
Marshal.StructureToPtr(value, tmp, false); // Can't get the address of a struct directly.
this.Handle = Alloc();
Marshal.StructureToPtr<ValueNative>(value, tmp, false); // Can't get the address of a struct directly.
// Copy is used to deep copy the pointed payload (e.g. strings) inside this struct, so we can own this value.
if (!eina_value_copy(tmp, this.Handle))
@ -1482,7 +1493,7 @@ public class Value : IDisposable, IComparable<Value>, IEquatable<Value>
{
if (Disposed)
{
throw new ObjectDisposedException(base.GetType().Name);
throw new ObjectDisposedException($"Value at 0x{this.Handle.ToInt64():x}");
}
return this.Handle;
@ -1494,7 +1505,7 @@ public class Value : IDisposable, IComparable<Value>, IEquatable<Value>
{
if (Disposed)
{
throw new ObjectDisposedException(base.GetType().Name);
throw new ObjectDisposedException($"Value at 0x{this.Handle.ToInt64():x}");
}
// Can't call setup with Empty value type (would give an eina error)
@ -1540,7 +1551,7 @@ public class Value : IDisposable, IComparable<Value>, IEquatable<Value>
{
if (Disposed)
{
throw new ObjectDisposedException(GetType().Name);
throw new ObjectDisposedException($"Value at 0x{this.Handle.ToInt64():x}");
}
}
@ -1591,6 +1602,7 @@ public class Value : IDisposable, IComparable<Value>, IEquatable<Value>
/// <summary>Get a ValueNative struct with the *value* pointed by this Eina.Value.</summary>
public ValueNative GetNative()
{
SanityChecks();
ValueNative value = (ValueNative)Marshal.PtrToStructure(this.Handle, typeof(ValueNative));
return value;
}

112
src/bindings/mono/eo_mono/EoWrapper.cs
View File

@ -2,6 +2,7 @@ using System;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Reflection;
namespace Efl
{
@ -18,6 +19,33 @@ public abstract class EoWrapper : IWrapper, IDisposable
private static Efl.EventCb ownershipUniqueDelegate = new Efl.EventCb(OwnershipUniqueCallback);
private static Efl.EventCb ownershipSharedDelegate = new Efl.EventCb(OwnershipSharedCallback);
/// <summary>Constructor to be used when objects are expected to be constructed from native code.
/// For a class that inherited from an EFL# class to be properly constructed from native code
/// one must create a constructor with this signature and calls this base constructor from it.
/// This constructor will take care of calling base constructors of the native classes and
/// perform additional setup so objects are ready to use.
/// It is advisable to check for the <see cref="NativeHandle"/> property in the top level
/// constructor and signal an error when it has a value of IntPtr.Zero after this
/// constructor completion.
/// Warning: Do not use this constructor directly from a `new` statement.</summary>
/// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
protected EoWrapper(ConstructingHandle ch)
{
inherited = true;
handle = Efl.Eo.Globals.efl_constructor(Efl.Eo.Globals.efl_super(ch.NativeHandle, Efl.Eo.Globals.efl_class_get(ch.NativeHandle)));
if (handle == IntPtr.Zero)
{
Eina.Log.Warning("Natice constructor returned NULL");
return;
}
AddWrapperSupervisor();
// Make an additional reference to C#
// - Will also call EVENT_OWNERSHIP_SHARED
Efl.Eo.Globals.efl_ref(handle);
}
/// <summary>Initializes a new instance of the <see cref="Object"/> class.
/// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
/// <param name="raw">The native pointer to be wrapped.</param>
@ -54,7 +82,17 @@ public abstract class EoWrapper : IWrapper, IDisposable
parent_ptr = parent.NativeHandle;
}
handle = Efl.Eo.Globals._efl_add_internal_start(file, line, actual_klass, parent_ptr, 1, 0);
if (!inherited)
{
handle = Efl.Eo.Globals._efl_add_internal_start(file, line, actual_klass, parent_ptr, 1, 0);
}
else
{
handle = Efl.Eo.Globals._efl_add_internal_start_bindings(file, line, actual_klass, parent_ptr, 1, 0,
Efl.Eo.Globals.efl_mono_avoid_top_level_constructor_callback_addr_get(),
IntPtr.Zero);
}
if (handle == System.IntPtr.Zero)
{
throw new Exception("Instantiation failed");
@ -246,8 +284,78 @@ public abstract class EoWrapper : IWrapper, IDisposable
AddNativeEventHandler("eo", "_EFL_EVENT_OWNERSHIP_SHARED", ownershipSharedDelegate, ownershipSharedDelegate);
Eina.Error.RaiseIfUnhandledException();
}
protected struct ConstructingHandle
{
public ConstructingHandle(IntPtr h)
{
NativeHandle = h;
}
public IntPtr NativeHandle { get; set; }
}
public abstract class NativeMethods : Efl.Eo.NativeClass
{
private static EflConstructorDelegate csharpEflConstructorStaticDelegate = new EflConstructorDelegate(Constructor);
private static Efl.Eo.NativeModule EoModule = new Efl.Eo.NativeModule("eo");
private delegate IntPtr EflConstructorDelegate(IntPtr obj, IntPtr pd);
public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(Type type)
{
var descs = new System.Collections.Generic.List<Efl_Op_Description>();
descs.Add(new Efl_Op_Description()
{
api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(EoModule.Module, "efl_constructor"),
func = Marshal.GetFunctionPointerForDelegate(csharpEflConstructorStaticDelegate)
});
return descs;
}
private static IntPtr Constructor(IntPtr obj, IntPtr pd)
{
try
{
var eoKlass = Efl.Eo.Globals.efl_class_get(obj);
var managedType = ClassRegister.GetManagedType(eoKlass);
if (managedType == null)
{
IntPtr nativeName = Efl.Eo.Globals.efl_class_name_get(eoKlass);
var name = Eina.StringConversion.NativeUtf8ToManagedString(nativeName);
Eina.Log.Warning($"Can't get Managed class for object handle 0x{(UInt64)obj:x} with native class [{name}]");
return IntPtr.Zero;
}
var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
ConstructorInfo constructor = managedType.GetConstructor(flags, null, new Type[1] { typeof(ConstructingHandle) }, null);
if (constructor == null)
{
Eina.Log.Error($"Type {managedType.FullName} lacks a constructor that receives a ConstructingHandle. It can not be constructed from native code.");
return IntPtr.Zero;
}
var eoWrapper = (Efl.Eo.IWrapper) constructor.Invoke(new object[1] { new ConstructingHandle(obj) });
if (eoWrapper == null)
{
Eina.Log.Warning("Constructor was unable to create a new object");
return IntPtr.Zero;
}
return eoWrapper.NativeHandle;
}
catch (Exception e)
{
Eina.Log.Warning($"Inherited constructor error: {e.ToString()}");
Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
return IntPtr.Zero;
}
}
}
}
} // namespace Global
} // namespace Eo
} // namespace Efl

4
src/bindings/mono/eo_mono/FunctionWrapper_Unix.cs
View File

@ -18,9 +18,9 @@ public partial class FunctionInterop
///<returns>A function pointer that can be used with delegates.</returns>
public static IntPtr LoadFunctionPointer(IntPtr nativeLibraryHandle, string functionName)
{
Eina.Log.Debug("searching {nativeLibraryHandle} for {functionName}");
Eina.Log.Debug($"searching {nativeLibraryHandle} for {functionName}");
var s = FunctionInterop.dlsym(nativeLibraryHandle, functionName);
Eina.Log.Debug("searching {nativeLibraryHandle} for {functionName}, result {s}");
Eina.Log.Debug($"searching {nativeLibraryHandle} for {functionName}, result {s}");
return s;
}
}

25
src/bindings/mono/eo_mono/iwrapper.cs
View File

@ -44,10 +44,6 @@ public class Globals
public static FunctionWrapper<efl_object_shutdown_delegate> efl_object_shutdown_ptr = new FunctionWrapper<efl_object_shutdown_delegate>(efl.Libs.EoModule, "efl_object_shutdown");
public static void efl_object_shutdown() => efl_object_shutdown_ptr.Value.Delegate();
// [DllImport(efl.Libs.Eo)] public static extern void efl_object_shutdown();
public static FunctionWrapper<_efl_add_internal_start_delegate> _efl_add_internal_start_ptr = new FunctionWrapper<_efl_add_internal_start_delegate>(efl.Libs.EoModule, "_efl_add_internal_start");
public delegate IntPtr
_efl_add_internal_start_delegate([MarshalAs(UnmanagedType.LPStr)] String file, int line,
IntPtr klass, IntPtr parent, byte is_ref, byte is_fallback);
[DllImport(efl.Libs.CustomExports)] public static extern IntPtr efl_mono_wrapper_supervisor_get(IntPtr eo);
[DllImport(efl.Libs.CustomExports)] public static extern void efl_mono_wrapper_supervisor_set(IntPtr eo, IntPtr ws);
@ -55,6 +51,9 @@ public class Globals
[DllImport(efl.Libs.Eo)] public static extern IntPtr
_efl_add_internal_start([MarshalAs(UnmanagedType.LPStr)] String file, int line,
IntPtr klass, IntPtr parent, byte is_ref, byte is_fallback);
[DllImport(efl.Libs.Eo)] public static extern IntPtr
_efl_add_internal_start_bindings([MarshalAs(UnmanagedType.LPStr)] String file, int line, IntPtr klass, IntPtr parent,
byte is_ref, byte is_fallback, IntPtr substitute_ctor, IntPtr data);
public delegate IntPtr
_efl_add_end_delegate(IntPtr eo, byte is_ref, byte is_fallback);
[DllImport(efl.Libs.Eo)] public static extern IntPtr
@ -196,6 +195,10 @@ public class Globals
public delegate IntPtr dlerror_delegate();
[DllImport(efl.Libs.Evil)] public static extern IntPtr dlerror();
[DllImport(efl.Libs.Eo)] public static extern IntPtr efl_constructor(IntPtr obj);
[DllImport(efl.Libs.CustomExports)] public static extern IntPtr efl_mono_avoid_top_level_constructor_callback_addr_get();
[DllImport(efl.Libs.Eo)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
efl_event_callback_priority_add(IntPtr obj, IntPtr desc, short priority, IntPtr cb, IntPtr data);
@ -491,7 +494,7 @@ public class Globals
{
foreach (IntPtr ptr in dict.Values)
{
Eina.Stringshare.eina_stringshare_del(ptr);
Eina.NativeMethods.eina_stringshare_del(ptr);
}
}
@ -530,8 +533,10 @@ public class Globals
}
else
{
// Will mark the returned task below as completed.
tcs.SetResult(received);
// Async receiver methods may consume the value C# wrapper, like when awaiting in the start of an
// using block. In order to continue to forward the value correctly to the next futures
// in the chain, we give the Async wrapper a copy of the received wrapper.
tcs.SetResult(new Eina.Value(received));
}
fulfilled = true;
@ -1143,13 +1148,13 @@ public class StringsharePassOwnershipMarshaler : ICustomMarshaler
public object MarshalNativeToManaged(IntPtr pNativeData)
{
var ret = Eina.StringConversion.NativeUtf8ToManagedString(pNativeData);
Eina.Stringshare.eina_stringshare_del(pNativeData);
Eina.NativeMethods.eina_stringshare_del(pNativeData);
return ret;
}
public IntPtr MarshalManagedToNative(object managedObj)
{
return Eina.Stringshare.eina_stringshare_add((string)managedObj);
return Eina.MemoryNative.AddStringshare((string)managedObj);
}
public void CleanUpNativeData(IntPtr pNativeData)
@ -1188,7 +1193,7 @@ public class StringshareKeepOwnershipMarshaler : ICustomMarshaler
public IntPtr MarshalManagedToNative(object managedObj)
{
return Eina.Stringshare.eina_stringshare_add((string)managedObj);
return Eina.MemoryNative.AddStringshare((string)managedObj);
}
public void CleanUpNativeData(IntPtr pNativeData)

8
src/examples/elementary/radio_cxx_example_01.cc
View File

@ -33,7 +33,7 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
auto cb_val = std::bind([bx] (efl::ui::Radio &obj EINA_UNUSED)
{ std::cout << "val is now: " << bx.selected_value_get() << std::endl; },
std::placeholders::_1);
efl::eolian::event_add(efl::ui::Nstate::changed_event, radio, cb_val);
efl::eolian::event_add(efl::ui::Radio_Group::value_changed_event, radio, cb_val);
efl::ui::Radio radio2(instantiate, win);
radio2.text_set("Radio 2");
@ -43,18 +43,18 @@ efl_main(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED)
ic2.icon_set("file");
radio2.content_set(ic2);
bx.pack_end(radio2);
efl::eolian::event_add(efl::ui::Nstate::changed_event, radio2, cb_val);
efl::eolian::event_add(efl::ui::Radio_Group::value_changed_event, radio2, cb_val);
efl::ui::Radio radio3(instantiate, win);
radio3.text_set("Radio 3");
radio3.state_value_set(3);
bx.pack_end(radio3);
efl::eolian::event_add(efl::ui::Nstate::changed_event, radio3, cb_val);
efl::eolian::event_add(efl::ui::Radio_Group::value_changed_event, radio3, cb_val);
efl::ui::Radio radio4(instantiate, win);
radio4.text_set("Radio 4");
radio4.state_value_set(4);
bx.pack_end(radio4);
efl::eolian::event_add(efl::ui::Nstate::changed_event, radio4, cb_val);
efl::eolian::event_add(efl::ui::Radio_Group::value_changed_event, radio4, cb_val);
}
EFL_MAIN()

11
src/lib/ecore_wl2/Ecore_Wl2.h
View File

@ -1765,6 +1765,7 @@ EAPI Ecore_Wl2_Drag_Action ecore_wl2_offer_action_get(Ecore_Wl2_Offer *offer);
* @return a eina array of strdup´ed strings, this array must NOT be changed or freed
*
* @ingroup Ecore_Wl2_Dnd_Group
* @since 1.19
*/
EAPI Eina_Array* ecore_wl2_offer_mimes_get(Ecore_Wl2_Offer *offer);
@ -1942,6 +1943,16 @@ EAPI void ecore_wl2_window_buffer_attach(Ecore_Wl2_Window *win, void *buffer, in
*/
EAPI void ecore_wl2_display_flush(Ecore_Wl2_Display *display);
/**
* Get if a given window is resizing
*
* @param window
*
* @return EINA_TRUE if resizing, EINA_FALSE otherwise
*
* @ingroup Ecore_Wl2_Window_Group
* @since 1.21
*/
EAPI Eina_Bool ecore_wl2_window_resizing_get(Ecore_Wl2_Window *window);
/**

21
src/lib/efl_mono/efl_custom_exports_mono.c
View File

@ -125,6 +125,12 @@ EAPI void efl_mono_native_free_ref(void **ptr)
free(*ptr);
}
EAPI void efl_mono_native_stringshare_del_ref(void **str)
{
if (!str) return;
eina_stringshare_del(*str);
}
EAPI void *efl_mono_native_alloc_copy(const void *val, unsigned int size)
{
if (!val) return NULL;
@ -161,11 +167,26 @@ EAPI Eina_Free_Cb efl_mono_native_free_addr_get()
return (Eina_Free_Cb)free;
}
EAPI Eina_Free_Cb efl_mono_native_stringshare_del_addr_get()
{
return (Eina_Free_Cb)eina_stringshare_del;
}
EAPI Eina_Free_Cb efl_mono_native_efl_unref_addr_get()
{
return (Eina_Free_Cb)efl_mono_thread_safe_efl_unref;
}
static Eo *_efl_mono_avoid_top_level_constructor_cb(void *data EINA_UNUSED, Eo *obj)
{
return efl_constructor(efl_super(obj, efl_class_get(obj)));
}
EAPI Efl_Substitute_Ctor_Cb efl_mono_avoid_top_level_constructor_callback_addr_get()
{
return &_efl_mono_avoid_top_level_constructor_cb;
}
// Iterator Wrapper //
typedef struct _Eina_Iterator_Wrapper_Mono

2
src/lib/elementary/Efl_Ui.h
View File

@ -179,6 +179,7 @@ EAPI void efl_ui_focus_relation_free(Efl_Ui_Focus_Relations *rel);
# include <efl_ui_layout_part_content.eo.h>
# include <efl_ui_layout_part_text.eo.h>
# include <efl_ui_layout_part_table.eo.h>
# include <efl_ui_item.eo.h>
# include <efl_ui_win_part.eo.h>
# include <efl_ui_bg.eo.h>
# include <efl_ui_box.eo.h>
@ -207,7 +208,6 @@ EAPI void efl_ui_focus_relation_free(Efl_Ui_Focus_Relations *rel);
# include <efl_ui_clock.h>
# include <efl_ui_image_factory.eo.h>
# include <efl_ui_video.h>
# include <efl_ui_nstate.h>
# include <efl_ui_calendar.h>
# include <efl_ui_button_eo.h>

1
src/lib/elementary/Elementary.h
View File

@ -250,7 +250,6 @@ typedef Eo Efl_Ui_Focus_Manager;
#include <elm_mirroring.h>
#include <elm_need.h>
#include <elm_notify.h>
#include <efl_ui_nstate.h>
#include <elm_object.h>
#include <elm_panel.h>

6
src/lib/elementary/efl_ui_active_view_view_manager_scroll.c
View File

@ -105,6 +105,10 @@ _mouse_down_cb(void *data,
pd->mouse_move.active = EINA_TRUE;
pd->mouse_move.from = efl_ui_active_view_active_index_get(pd->container);
pd->mouse_move.mouse_start = efl_input_pointer_position_get(ev);
pd->transition.from = pd->mouse_move.from;
pd->transition.to = pd->transition.from + 1;
pd->transition.progress = 0.0;
}
static void
@ -124,9 +128,7 @@ _mouse_move_cb(void *data,
pos_y_diff = pd->mouse_move.mouse_start.x - pos.x;
pd->transition.active = EINA_TRUE;
pd->transition.from = pd->mouse_move.from;
pd->transition.progress = (double)pos_y_diff / (double)pd->page_size.w;
pd->transition.to = pd->transition.from + 1;
_propagate_progress(data, pd->transition.from + pd->transition.progress);

1
src/lib/elementary/efl_ui_check.c
View File

@ -5,7 +5,6 @@
#define EFL_ACCESS_OBJECT_PROTECTED
#define EFL_ACCESS_WIDGET_ACTION_PROTECTED
#define ELM_LAYOUT_PROTECTED
#define EFL_UI_NSTATE_PROTECTED
#define EFL_PART_PROTECTED
#include <Elementary.h>

155
src/lib/elementary/efl_ui_nstate.c
View File

@ -1,155 +0,0 @@
#ifdef HAVE_CONFIG_H
# include "elementary_config.h"
#endif
#define EFL_UI_NSTATE_PROTECTED
#include "Elementary.h"
#include "elm_priv.h"
#include "efl_ui_nstate.eo.h"
#include "efl_ui_button_private.h"
#include "efl_ui_nstate_private.h"
#define MY_CLASS EFL_UI_NSTATE_CLASS
#define MY_CLASS_NAME "Efl.Ui.Nstate"
static Eina_Bool _key_action_activate(Evas_Object *obj, const char *params);
static void _state_active(Evas_Object *obj, Efl_Ui_Nstate_Data *sd);
static const Elm_Action key_actions[] = {
{"activate", _key_action_activate},
{NULL, NULL}
};
static void
_on_state_changed(void *data,
Evas_Object *o EINA_UNUSED,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
{
efl_ui_nstate_activate(data);
}
EOLIAN static Efl_Object *
_efl_ui_nstate_efl_object_constructor(Eo *obj, Efl_Ui_Nstate_Data *pd)
{
if (!elm_widget_theme_klass_get(obj))
elm_widget_theme_klass_set(obj, "nstate");
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_canvas_object_type_set(obj, MY_CLASS_NAME);
pd->state = 0;
// Default: 2 states
pd->nstate = 2;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
efl_layout_signal_callback_add
(wd->resize_obj, "efl,action,state,changed", "*", obj, _on_state_changed, NULL);
//TODO: Add ATSPI call here
return obj;
}
static void
_next_state_set(Efl_Ui_Nstate_Data *sd)
{
++sd->state;
if (sd->state == sd->nstate) sd->state = 0;
}
static void
_state_signal_emit(Evas_Object *obj, Efl_Ui_Nstate_Data *sd)
{
char buf[64];
sprintf(buf, "efl,state,changed,%d", sd->state);
elm_layout_signal_emit(obj, buf, "efl");
edje_object_message_signal_process(elm_layout_edje_get(obj));
elm_layout_sizing_eval(obj);
}
static void
_state_active(Evas_Object *obj, Efl_Ui_Nstate_Data *sd)
{
_state_signal_emit(obj, sd);
efl_event_callback_legacy_call(obj, EFL_UI_NSTATE_EVENT_CHANGED, NULL);
}
EOLIAN static int
_efl_ui_nstate_count_get(const Eo *obj EINA_UNUSED, Efl_Ui_Nstate_Data *pd)
{
return pd->nstate;
}
EOLIAN static void
_efl_ui_nstate_count_set(Eo *obj EINA_UNUSED, Efl_Ui_Nstate_Data *pd, int nstate)
{
if (pd->nstate == nstate) return;
pd->nstate = nstate;
pd->state = 0;
}
EOLIAN static int
_efl_ui_nstate_value_get(const Eo *obj EINA_UNUSED, Efl_Ui_Nstate_Data *pd)
{
return pd->state;
}
static Eina_Bool
_is_valid_state(Efl_Ui_Nstate_Data *sd, int state)
{
if (sd->state == state || (state < 0 || state >= sd->nstate))
return EINA_FALSE;
return EINA_TRUE;
}
EOLIAN static void
_efl_ui_nstate_value_set(Eo *obj, Efl_Ui_Nstate_Data *pd, int state)
{
if (!_is_valid_state(pd, state)) return;
pd->state = state;
_state_active(obj, pd);
}
EOLIAN static Eina_Error
_efl_ui_nstate_efl_ui_widget_theme_apply(Eo *obj, Efl_Ui_Nstate_Data *pd)
{
Eina_Error int_ret = EFL_UI_THEME_APPLY_ERROR_GENERIC;
int_ret = efl_ui_widget_theme_apply(efl_super(obj, MY_CLASS));
if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
_state_signal_emit(obj, pd);
return int_ret;
}
static Eina_Bool
_key_action_activate(Evas_Object *obj, const char *params EINA_UNUSED)
{
efl_ui_nstate_activate(obj);
return EINA_TRUE;
}
EOLIAN static void
_efl_ui_nstate_activate(Eo *obj, Efl_Ui_Nstate_Data *_pd)
{
_next_state_set(_pd);
_state_active(obj, _pd);
}
EOLIAN static void
_efl_ui_nstate_class_constructor(Efl_Class *klass)
{
evas_smart_legacy_type_register(MY_CLASS_NAME, klass);
}
/* Standard widget overrides */
ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(efl_ui_nstate, Efl_Ui_Nstate_Data)
#include "efl_ui_nstate.eo.c"

39
src/lib/elementary/efl_ui_nstate.eo
View File

@ -1,39 +0,0 @@
class @beta Efl.Ui.Nstate extends Efl.Ui.Button
{
[[Efl UI nstate class]]
methods {
activate @protected {
[[Activate widget]]
}
@property count {
[[Maximum number of states]]
set {
}
get {
}
values {
nstate: int; [[The number of states.]]
}
}
@property value {
set {
[[Set the particular state given in (0...nstate}.]]
}
get {
[[Get the state value.]]
}
values {
state: int; [[The state.]]
}
}
}
implements {
class.constructor;
Efl.Object.constructor;
Efl.Ui.Widget.theme_apply;
Efl.Ui.Widget.widget_input_event_handler;
}
events {
changed: void; [[Called when the value changed.]]
}
}

24
src/lib/elementary/efl_ui_nstate.h
View File

@ -1,24 +0,0 @@
/**
* @defgroup Elm_Nstate Nstate
* @ingroup Elementary
*
* @image html nstate_inheritance_tree.png
* @image latex nstate_inheritance_tree.eps
*
* @image html img/widget/nstate/preview-00.png
* @image latex img/widget/nstate/preview-00.eps
*
* A Nstate is a widget which displays one of the state among states defined by user.
*
* This widget inherits from the @ref Button, so that all the functions acting on @ref Button also work for nstate objects.
*
* This widget emits the following signals, besides the ones sent from
* @ref Button:
* - @c "state,changed" - whenever state of nstate is changed
*
* Default content parts of the nstate widget that you can use are the
* the same that you use with the @ref Button
* @{
*/
#include "efl_ui_nstate.eo.h"

57
src/lib/elementary/efl_ui_nstate_private.h
View File

@ -1,57 +0,0 @@
#ifndef EFL_UI_NSTATE_PRIVATE_H
#define EFL_UI_NSTATE_PRIVATE_H
#include "Elementary.h"
/* DO NOT USE THIS HEADER UNLESS YOU ARE PREPARED FOR BREAKING OF YOUR
* CODE. THIS IS ELEMENTARY'S INTERNAL WIDGET API (for now) AND IS NOT
* FINAL. CALL elm_widget_api_check(ELM_INTERNAL_API_VERSION) TO CHECK
* IT AT RUNTIME.
*/
/**
* @addtogroup Widget
* @{
*
* @section efl-ui-nstate-class The Efl Ui Nstate Class
*
*/
/**
* Base widget smart data extended with nstate instance data.
*/
typedef struct _Efl_Ui_Nstate_Data
{
int nstate;
int state;
} Efl_Ui_Nstate_Data;
/**
* @}
*/
#define EFL_UI_NSTATE_DATA_GET(o, sd) \
Efl_Ui_Nstate_Data * sd = efl_data_scope_get(o, EFL_UI_NSTATE_CLASS)
#define EFL_UI_NSTATE_DATA_GET_OR_RETURN(o, ptr) \
EFL_UI_NSTATE_DATA_GET(o, ptr); \
if (EINA_UNLIKELY(!ptr)) \
{ \
ERR("No widget data for object %p (%s)", \
o, evas_object_type_get(o)); \
return; \
}
#define EFL_UI_NSTATE_DATA_GET_OR_RETURN_VAL(o, ptr, val) \
EFL_UI_NSTATE_DATA_GET(o, ptr); \
if (EINA_UNLIKELY(!ptr)) \
{ \
ERR("No widget data for object %p (%s)", \
o, evas_object_type_get(o)); \
return val; \
}
#define EFL_UI_NSTATE_CHECK(obj) \
if (EINA_UNLIKELY(!efl_isa((obj), EFL_UI_NSTATE_CLASS))) \
return;
#endif

2
src/lib/elementary/elm_dayselector.c
View File

@ -235,7 +235,7 @@ _elm_dayselector_content_set(Eo *obj, Elm_Dayselector_Data *sd, const char *item
char buf[1024];
Elm_Dayselector_Item_Data *it = NULL;
EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(content, EFL_UI_NSTATE_CLASS), EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(efl_isa(content, EFL_UI_CHECK_CLASS), EINA_FALSE);
if (!item) return EINA_FALSE;
day = atoi(item + (strlen(item) - 1));

4
src/lib/elementary/meson.build
View File

@ -50,7 +50,6 @@ pub_eo_files = [
'efl_ui_image_zoomable.eo',
'efl_ui_layout.eo',
'efl_ui_layout_base.eo',
'efl_ui_nstate.eo',
'efl_ui_navigation_bar.eo',
'efl_ui_navigation_bar_part.eo',
'efl_ui_navigation_bar_part_back_button.eo',
@ -374,7 +373,6 @@ elementary_headers_unstable = [
'efl_ui_widget_scroller.h',
'efl_ui_widget_scroll_manager.h',
'efl_ui_widget_pan.h',
'efl_ui_nstate_private.h',
'Efl_Ui.h',
'efl_ui_tab_pager_private.h',
'efl_ui_tab_bar_private.h',
@ -518,7 +516,6 @@ elementary_pub_headers = [
'elm_notify.h',
'elm_notify_common.h',
'elm_notify_legacy.h',
'efl_ui_nstate.h',
'elm_object.h',
'elm_object_item.h',
'elm_panel.h',
@ -812,7 +809,6 @@ elementary_src = [
'elm_menu.c',
'elm_module.c',
'elm_notify.c',
'efl_ui_nstate.c',
'elm_panel.c',
'efl_ui_panes.c',
'elm_photo.c',

2
src/lib/eolian/database_validate.c
View File

@ -273,7 +273,7 @@ _validate_type(Validate_State *vals, Eolian_Type *tp)
{
if (!_validate_type(vals, itp))
return EINA_FALSE;
if ((kwid >= KW_accessor) && (kwid <= KW_list) && (kwid != KW_future))
if (kwid == KW_array || kwid == KW_hash || kwid == KW_list)
{
if (!database_type_is_ownable(src, itp, EINA_TRUE))
{

6
src/lib/eolian/eo_parser.c
View File

@ -768,8 +768,10 @@ parse_type_void(Eo_Lexer *ls, Eina_Bool allow_ptr)
def->base_type = eo_lexer_type_release(ls, parse_type_void(ls, EINA_TRUE));
else
def->base_type = eo_lexer_type_release(ls, parse_type(ls, EINA_TRUE));
if ((def->base_type->owned = (ls->t.kw == KW_at_owned)))
eo_lexer_get(ls);
/* view-only types are not allowed to own the contents */
if (tpid == KW_array || tpid == KW_hash || tpid == KW_list || tpid == KW_future)
if ((def->base_type->owned = (ls->t.kw == KW_at_owned)))
eo_lexer_get(ls);
if (tpid == KW_hash)
{
check_next(ls, ',');

1
src/lib/evas/canvas/efl_canvas_vg_container.c
View File

@ -399,7 +399,6 @@ _efl_canvas_vg_container_efl_duplicate_duplicate(const Eo *obj,
container = efl_duplicate(efl_super(obj, MY_CLASS));
efl_event_callback_add(container, EFL_EVENT_INVALIDATE, _invalidate_cb, NULL);
efl_parent_set(container, efl_parent_get(obj));
//Copy Mask
if (pd->mask_src)

110
src/lib/evas/canvas/evas_events.c
View File

@ -814,7 +814,7 @@ static void
_evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
Efl_Input_Pointer *parent_ev,
Evas_Pointer_Data *pdata,
int event_id)
int event_id, Eina_Bool cancel)
{
Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
Evas_Object *eo_src = _evas_object_image_source_get(eo_obj);
@ -853,7 +853,7 @@ _evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
ev->device);
continue;
}
if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
if ((!cancel) && ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
(obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
(obj_pdata->mouse_grabbed > 0))
{
@ -864,12 +864,15 @@ _evas_event_source_mouse_up_events(Evas_Object *eo_obj, Evas *eo_e,
ev->cur = point;
pointer_mode = obj_pdata->pointer_mode;
_evas_event_havemap_adjust_f(eo_child, child, &ev->cur, obj_pdata->mouse_grabbed);
evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_UP, evt,
event_id, EFL_EVENT_POINTER_UP);
if (cancel)
efl_event_callback_call(eo_child, EFL_EVENT_POINTER_CANCEL, evt);
else
evas_object_event_callback_call(eo_child, child, EVAS_CALLBACK_MOUSE_UP, evt,
event_id, EFL_EVENT_POINTER_UP);
if (e->delete_me) break;
if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
{
if (pdata->seat->nogrep > 0) pdata->seat->nogrep--;
if ((!cancel) && (pdata->seat->nogrep > 0)) pdata->seat->nogrep--;
break;
}
}
@ -1755,9 +1758,10 @@ _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
Efl_Input_Pointer *evt;
Eina_List *l, *copy;
Evas_Object *eo_obj;
int event_id, b;
int event_id = 0, b;
Evas *eo_e;
Evas_Pointer_Data *pdata;
Eina_Bool cancel;
static const int value_flags =
_efl_input_value_mask(EFL_INPUT_VALUE_TIMESTAMP) |
@ -1773,20 +1777,29 @@ _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
if (!pdata) return;
b = ev->button;
DBG("ButtonEvent:up time=%u x=%d y=%d button=%d downs=%d",
ev->timestamp, pdata->seat->x, pdata->seat->y, b, pdata->seat->downs);
cancel = ev->action == EFL_POINTER_ACTION_CANCEL;
if (cancel)
DBG("ButtonEvent:cancel time=%u x=%d y=%d button=%d downs=%d",
ev->timestamp, pdata->seat->x, pdata->seat->y, b, pdata->seat->downs);
else
DBG("ButtonEvent:up time=%u x=%d y=%d button=%d downs=%d",
ev->timestamp, pdata->seat->x, pdata->seat->y, b, pdata->seat->downs);
if ((b < 1) || (b > 32)) return;
if (pdata->seat->downs <= 0) return;
pdata->button &= ~(1u << (b - 1));
pdata->seat->downs--;
if (!cancel)
{
pdata->button &= ~(1u << (b - 1));
pdata->seat->downs--;
}
if (e->is_frozen) return;
e->last_timestamp = ev->timestamp;
eo_e = e->evas;
evt = ev->eo;
event_id = _evas_object_event_new();
if (!cancel)
event_id = _evas_object_event_new();
ev->cur.x = pdata->seat->x;
ev->cur.y = pdata->seat->y;
@ -1798,8 +1811,9 @@ _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
if (ev->device) efl_ref(ev->device);
_evas_walk(e);
/* update released touch point */
_evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_UP);
if (!cancel)
/* update released touch point */
_evas_touch_point_update(eo_e, 0, pdata->seat->x, pdata->seat->y, EVAS_TOUCH_POINT_UP);
copy = evas_event_list_copy(pdata->seat->object.in);
EINA_LIST_FOREACH(copy, l, eo_obj)
{
@ -1815,7 +1829,7 @@ _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
ev->device);
continue;
}
if (((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
if ((!cancel) && ((obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_AUTOGRAB) ||
(obj_pdata->pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)) &&
(obj_pdata->mouse_grabbed > 0))
{
@ -1829,29 +1843,35 @@ _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
ev->cur.x = pdata->seat->x;
ev->cur.y = pdata->seat->y;
_evas_event_havemap_adjust_f(eo_obj, obj, &ev->cur, obj_pdata->mouse_grabbed);
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_UP, evt,
event_id, EFL_EVENT_POINTER_UP);
if (cancel)
efl_event_callback_call(eo_obj, EFL_EVENT_POINTER_CANCEL, evt);
else
evas_object_event_callback_call(eo_obj, obj, EVAS_CALLBACK_MOUSE_UP, evt,
event_id, EFL_EVENT_POINTER_UP);
if ((obj->proxy->is_proxy) && (obj->proxy->src_events))
_evas_event_source_mouse_up_events(eo_obj, eo_e, evt, pdata, event_id);
_evas_event_source_mouse_up_events(eo_obj, eo_e, evt, pdata, event_id, cancel);
if (e->delete_me) break;
}
if (pointer_mode == EVAS_OBJECT_POINTER_MODE_NOGRAB_NO_REPEAT_UPDOWN)
{
if (pdata->seat->nogrep > 0) pdata->seat->nogrep--;
if ((!cancel) && (pdata->seat->nogrep > 0)) pdata->seat->nogrep--;
break;
}
}
eina_list_free(copy);
e->last_mouse_up_counter++;
_evas_post_event_callback_call(eo_e, e, event_id);
if (pdata->seat->mouse_grabbed == 0)
_post_up_handle(e, evt, pdata);
if (pdata->seat->mouse_grabbed < 0)
if (!cancel)
{
ERR("BUG? pdata->seat->mouse_grabbed (=%d) < 0!",
pdata->seat->mouse_grabbed);
e->last_mouse_up_counter++;
_evas_post_event_callback_call(eo_e, e, event_id);
if (pdata->seat->mouse_grabbed == 0)
_post_up_handle(e, evt, pdata);
if (pdata->seat->mouse_grabbed < 0)
{
ERR("BUG? pdata->seat->mouse_grabbed (=%d) < 0!",
pdata->seat->mouse_grabbed);
}
}
/* remove released touch point from the touch point list */
_evas_touch_point_remove(eo_e, 0);
@ -1863,7 +1883,7 @@ _canvas_event_feed_mouse_up_internal(Evas_Public_Data *e, Efl_Input_Pointer_Data
static void
_canvas_event_feed_mouse_updown(Eo *eo_e, int b, Evas_Button_Flags flags,
unsigned int timestamp, const void *data,
Eina_Bool down, Efl_Input_Device *device)
Eina_Bool down, Efl_Input_Device *device, Eina_Bool cancel)
{
Efl_Input_Pointer_Data *ev = NULL;
Efl_Input_Pointer *evt;
@ -1879,7 +1899,10 @@ _canvas_event_feed_mouse_updown(Eo *eo_e, int b, Evas_Button_Flags flags,
ev->data = (void *) data;
ev->timestamp = timestamp;
ev->device = efl_ref(device ? device : _evas_event_legacy_device_get(eo_e, EINA_TRUE));
ev->action = down ? EFL_POINTER_ACTION_DOWN : EFL_POINTER_ACTION_UP;
if (cancel)
ev->action = EFL_POINTER_ACTION_CANCEL;
else
ev->action = down ? EFL_POINTER_ACTION_DOWN : EFL_POINTER_ACTION_UP;
ev->button = b;
ev->button_flags = flags;
ev->radius = 1;
@ -1890,12 +1913,21 @@ _canvas_event_feed_mouse_updown(Eo *eo_e, int b, Evas_Button_Flags flags,
//ev->window_pos = ?;
//ev->fake = 1;
/* first, send the cancel action through to trigger POINTER_CANCEL on all
* relevant objects.
* this does not change canvas state in any way.
* note that the 'down' branch can only occur if 'cancel' is not true
*/
if (down)
_canvas_event_feed_mouse_down_internal(e, ev);
else
_canvas_event_feed_mouse_up_internal(e, ev);
efl_unref(evt);
/* next, emit actual up event and perform state changes */
if (cancel)
_canvas_event_feed_mouse_updown(eo_e, b, flags, timestamp, data, down, device, EINA_FALSE);
}
static void
@ -1903,7 +1935,7 @@ _canvas_event_feed_mouse_updown_legacy(Eo *eo_e, int b, Evas_Button_Flags flags,
unsigned int timestamp, const void *data,
Eina_Bool down)
{
_canvas_event_feed_mouse_updown(eo_e, b, flags, timestamp, data, down, NULL);
_canvas_event_feed_mouse_updown(eo_e, b, flags, timestamp, data, down, NULL, EINA_FALSE);
}
EAPI void
@ -1954,7 +1986,7 @@ _canvas_event_feed_mouse_cancel_internal(Evas_Public_Data *e, Efl_Input_Pointer_
for (i = 0; i < 32; i++)
{
if ((pdata->button & (1u << i)))
_canvas_event_feed_mouse_updown(eo_e, i + 1, 0, ev->timestamp, ev->data, 0, ev->device);
_canvas_event_feed_mouse_updown(eo_e, i + 1, 0, ev->timestamp, ev->data, 0, ev->device, EINA_TRUE);
}
ev->action = EFL_POINTER_ACTION_CANCEL;
@ -3462,9 +3494,11 @@ _canvas_event_feed_key_legacy(Eo *eo_e, Evas_Public_Data *e,
ev->compose = compose;
ev->timestamp = timestamp;
ev->keycode = keycode;
ev->pressed = down;
ev->no_stringshare = EINA_TRUE;
ev->device = efl_ref(_evas_event_legacy_device_get(e->evas, EINA_FALSE));
if (down)
_canvas_event_feed_key_down_internal(e, ev);
else
@ -4211,22 +4245,20 @@ _evas_canvas_event_key_cb(void *data, const Efl_Event *event)
static void
_evas_canvas_event_focus_cb(void *data, const Efl_Event *event)
{
Efl_Input_Device *seat = efl_input_device_get(event->info);
Efl_Input_Device *seat = efl_canvas_scene_seat_default_get(event->object);
Evas_Public_Data *e = data;
if (event->desc == EFL_EVENT_FOCUS_IN)
EINA_SAFETY_ON_NULL_RETURN(seat);
if (event->desc == EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN)
{
if (eina_list_data_find(e->focused_by, seat)) return;
e->focused_by = eina_list_append(e->focused_by, seat);
evas_event_callback_call(e->evas, EVAS_CALLBACK_CANVAS_FOCUS_IN,
event->info);
}
else
{
if (!eina_list_data_find(e->focused_by, seat)) return;
e->focused_by = eina_list_remove(e->focused_by, seat);
evas_event_callback_call(e->evas, EVAS_CALLBACK_CANVAS_FOCUS_OUT,
event->info);
}
}
@ -4245,8 +4277,8 @@ EFL_CALLBACKS_ARRAY_DEFINE(_evas_canvas_event_pointer_callbacks,
{ EFL_EVENT_FINGER_UP, _evas_canvas_event_pointer_cb },
{ EFL_EVENT_KEY_DOWN, _evas_canvas_event_key_cb },
{ EFL_EVENT_KEY_UP, _evas_canvas_event_key_cb },
{ EFL_EVENT_FOCUS_IN, _evas_canvas_event_focus_cb },
{ EFL_EVENT_FOCUS_OUT, _evas_canvas_event_focus_cb })
{ EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN, _evas_canvas_event_focus_cb },
{ EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT, _evas_canvas_event_focus_cb })
void
_evas_canvas_event_init(Evas *eo_e, Evas_Public_Data *e)

6
src/lib/evas/canvas/evas_main.c
View File

@ -857,9 +857,9 @@ static void
_evas_canvas_focus_inout_dispatch(Eo *eo_e, Evas_Device *seat EINA_UNUSED,
Eina_Bool in)
{
efl_event_callback_call(eo_e,
in ? EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN : EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT,
NULL);
efl_event_callback_legacy_call(eo_e,
in ? EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_IN : EFL_CANVAS_SCENE_EVENT_SCENE_FOCUS_OUT,
NULL);
}
EOLIAN static void

2
src/modules/ecore_evas/meson.build
View File

@ -44,3 +44,5 @@ if get_option('vnc-server')
subdir(join_paths('vnc_server'))
endif
config_h.set('BUILD_ECORE_EVAS_EWS', '1')

14
src/modules/evas/vg_loaders/svg/evas_vg_load_svg.c
View File

@ -887,6 +887,12 @@ _handle_fill_rule_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, cons
node->style->fill.fill_rule = _to_fill_rule(value);
}
static void
_handle_opacity_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->opacity = _to_opacity(value);
}
static void
_handle_fill_opacity_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
@ -915,6 +921,7 @@ static const struct {
STYLE_DEF(fill, fill),
STYLE_DEF(fill-rule, fill_rule),
STYLE_DEF(fill-opacity, fill_opacity),
STYLE_DEF(opacity, opacity),
STYLE_DEF(stroke, stroke),
STYLE_DEF(stroke-width, stroke_width),
STYLE_DEF(stroke-linejoin, stroke_linejoin),
@ -995,12 +1002,13 @@ _create_node(Svg_Node *parent, Svg_Node_Type type)
// update the default value of stroke and fill
//https://www.w3.org/TR/SVGTiny12/painting.html#SpecifyingPaint
// default fill color is black
node->style->fill.paint.r = 0;
node->style->fill.paint.g = 0;
node->style->fill.paint.b = 0;
//node->style->fill.paint.r = 0;
//node->style->fill.paint.g = 0;
//node->style->fill.paint.b = 0;
node->style->fill.paint.none = EINA_FALSE;
// default fill opacity is 1
node->style->fill.opacity = 255;
node->style->opacity = 255;
// default fill rule is nonzero
node->style->fill.fill_rule = EFL_GFX_FILL_RULE_WINDING;

1
src/static_libs/vg_common/vg_common.h
View File

@ -272,6 +272,7 @@ struct _Svg_Style_Property
int r;
int g;
int b;
int opacity;
};
struct _Svg_Node

12
src/static_libs/vg_common/vg_common_svg.c
View File

@ -183,6 +183,8 @@ _eet_for_style_property(void)
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "r", r, EET_T_INT);
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "g", g, EET_T_INT);
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "b", b, EET_T_INT);
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "opacity", opacity, EET_T_INT);
// for fill
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "fill.flags", fill.flags, EET_T_INT);
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "fill.paint.r", fill.paint.r, EET_T_INT);
@ -731,6 +733,15 @@ _apply_vg_property(Svg_Node *node, Efl_VG *vg, Efl_VG *parent, Vg_File_Data *vg_
style->fill.paint.b, style->fill.opacity);
}
//apply node opacity
if (style->opacity < 255)
{
int r, g, b, a;
efl_gfx_color_get(vg, &r, &g, &b, &a);
float fa = ((float) style->opacity / 255);
efl_gfx_color_set(vg, ((float) r) * fa, ((float) g) * fa, ((float) b) * fa, ((float) a) * fa);
}
efl_gfx_shape_stroke_width_set(vg, style->stroke.width);
efl_gfx_shape_stroke_cap_set(vg, style->stroke.cap);
efl_gfx_shape_stroke_join_set(vg, style->stroke.join);
@ -906,6 +917,7 @@ _create_node(Svg_Node *parent, Svg_Node_Type type)
// default line join is miter
node->style->stroke.join = EFL_GFX_JOIN_MITER;
node->style->stroke.scale = 1.0;
node->style->opacity = 255;
node->parent = parent;
node->type = type;

787
src/tests/efl_mono/Eina.cs
View File

File diff suppressed because it is too large Load Diff

4
src/tests/efl_mono/EinaTestData.cs
View File

@ -24,6 +24,10 @@ public static class BaseData
public static readonly string[] append_seq_str = {"42","43","33"};
public static readonly string[] modified_seq_str = {"0x0","0x2A","0x42","42","43","33"};
public static readonly Eina.Stringshare[] base_seq_strshare = {"0x0","0x2A","0x42"};
public static readonly Eina.Stringshare[] append_seq_strshare = {"42","43","33"};
public static readonly Eina.Stringshare[] modified_seq_strshare = {"0x0","0x2A","0x42","42","43","33"};
public static Dummy.Numberwrapper NW(int n)
{
var nw = new Dummy.Numberwrapper();

96
src/tests/efl_mono/EoConstruction.cs Normal file
View File

@ -0,0 +1,96 @@
using System;
class InheritedConstructibleObject : Dummy.ConstructibleObject
{
public InheritedConstructibleObject() : base()
{
if (this.NativeConstructionCount != 1)
{
DefaultConstrutorCallCount = -100;
}
++DefaultConstrutorCallCount;
this.IncrementDefaultConstructionCount();
}
private InheritedConstructibleObject(ConstructingHandle ch) : base(ch)
{
if (this.NativeConstructionCount != 1)
{
SpecialConstrutorCallCount = -100;
}
++SpecialConstrutorCallCount;
this.IncrementSpecialConstructionCount();
}
public int DefaultConstrutorCallCount { get; set; } = 0;
public int SpecialConstrutorCallCount { get; set; } = 0;
public bool InheritedFlag
{
get { return inherited; }
}
public override int MultiplyIntegerValue(int v)
{
return 3 * v;
}
}
namespace TestSuite
{
class TestEoConstruction
{
public static void TestGeneratedEoDirectConstruction()
{
var obj = new Dummy.ConstructibleObject();
Test.AssertEquals(obj.NativeConstructionCount, 1);
Test.AssertEquals(obj.DefaultConstructionCount, 0);
Test.AssertEquals(obj.SpecialConstructionCount, 0);
Test.AssertEquals(obj.MultiplyIntegerValue(21), 42);
obj.Dispose();
}
public static void TestInheritedEoDirectConstruction()
{
var obj = new InheritedConstructibleObject();
Test.AssertEquals(obj.InheritedFlag, true);
Test.AssertEquals(obj.NativeConstructionCount, 1);
Test.AssertEquals(obj.DefaultConstructionCount, 1);
Test.AssertEquals(obj.SpecialConstructionCount, 0);
Test.AssertEquals(obj.DefaultConstrutorCallCount, 1);
Test.AssertEquals(obj.SpecialConstrutorCallCount, 0);
Test.AssertEquals(obj.MultiplyIntegerValue(21), 63);
obj.Dispose();
}
public static void TestInheritedEoIndirectConstruction()
{
var obj = new Dummy.ConstructibleObject();
Test.AssertEquals(obj.NativeConstructionCount, 1);
Test.AssertEquals(obj.DefaultConstructionCount, 0);
Test.AssertEquals(obj.SpecialConstructionCount, 0);
Test.AssertEquals(obj.MultiplyIntegerValue(21), 42);
var obj2 = (InheritedConstructibleObject) obj.ConstructTypeAndStore(typeof(InheritedConstructibleObject));
Test.AssertEquals(obj2.InheritedFlag, true);
Test.AssertEquals(obj2.NativeConstructionCount, 1);
Test.AssertEquals(obj2.DefaultConstructionCount, 0);
Test.AssertEquals(obj2.SpecialConstructionCount, 1);
Test.AssertEquals(obj2.DefaultConstrutorCallCount, 0);
Test.AssertEquals(obj2.SpecialConstrutorCallCount, 1);
Test.AssertEquals(obj2.MultiplyIntegerValue(21), 63);
var internalObj = obj.InternalObject;
Test.Assert(ReferenceEquals(obj2, internalObj)); // Ensure it always use the same object instance
Test.AssertEquals(obj2.NativeConstructionCount, 1); // And that constructors are not called again
Test.AssertEquals(obj2.MultiplyIntegerValue(32), 96); // And that it is still usable
obj.Dispose();
obj2.Dispose();
}
}
}

25
src/tests/efl_mono/Promises.cs
View File

@ -42,6 +42,31 @@ class TestPromises
Test.AssertEquals(received_value, reference_value);
}
public static void test_simple_with_object()
{
bool callbackCalled = false;
Eina.Value receivedValue = null;
Efl.Loop loop = Efl.App.AppMain;
Eina.Promise promise = new Eina.Promise();
Eina.Future future = new Eina.Future(promise);
future = future.Then((Eina.Value value) => {
callbackCalled = true;
receivedValue = new Eina.Value(value);
return value;
});
Eina.Value referenceValue = new Eina.Value(Eina.ValueType.Array, Eina.ValueType.Int32);
referenceValue.Append(32);
promise.Resolve(new Eina.Value(referenceValue));
loop.Iterate();
Test.Assert(callbackCalled, "Future callback should have been called.");
Test.AssertEquals(receivedValue, referenceValue);
}
public static void test_simple_reject()
{
bool callbackCalled = false;

26
src/tests/efl_mono/TestUtils.cs
View File

@ -37,46 +37,46 @@ public static class Test
throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}");
}
/// <summary> Asserts if expected is equal to actual, using expected.Equals(actual).</summary>
public static void AssertEquals<T>(T expected, T actual, String msg = null,
/// <summary> Asserts if lhs is equal to rhs, using lhs.Equals(rhs).</summary>
public static void AssertEquals<T>(T lhs, T rhs, String msg = null,
[CallerLineNumber] int line = 0,
[CallerFilePath] string file = null,
[CallerMemberName] string member = null)
{
if (expected == null && actual == null)
if (lhs == null && rhs == null)
return;
if (expected == null || !expected.Equals(actual))
if (lhs == null || !lhs.Equals(rhs))
{
if (file == null)
file = "(unknown file)";
if (member == null)
member = "(unknown member)";
if (msg == null || msg.Length == 0)
msg = $"Expected \"{expected}\", actual \"{actual}\"";
msg = $"Left hand side \"{lhs}\", right hand side \"{rhs}\"";
throw new AssertionException($"{file}:{line} ({member}) {msg}");
}
}
/// <summary> Asserts if expected is not equal to actual, using !expected.Equals(actual).</summary>
public static void AssertNotEquals<T>(T expected, T actual, String msg = null,
/// <summary> Asserts if lhs is not equal to rhs, using !lhs.Equals(rhs).</summary>
public static void AssertNotEquals<T>(T lhs, T rhs, String msg = null,
[CallerLineNumber] int line = 0,
[CallerFilePath] string file = null,
[CallerMemberName] string member = null)
{
if (expected == null ? actual == null : expected.Equals(actual))
if (lhs == null ? rhs == null : lhs.Equals(rhs))
{
if (file == null)
file = "(unknown file)";
if (member == null)
member = "(unknown member)";
if (msg == null || msg.Length == 0)
msg = $"Expected \"{expected}\" shouldn't be equal to actual \"{actual}\"";
msg = $"Left hand side \"{lhs}\" shouldn't be equal to right hand side \"{rhs}\"";
throw new AssertionException($"{file}:{line} ({member}) {msg}");
}
}
/// <summary> Asserts if actual is near enough of expected, using the optional tolerance (default 0.00001).</summary>
public static void AssertAlmostEquals(double expected, double actual, double tolerance=0.00001,
/// <summary> Asserts if rhs is near enough of lhs, using the optional tolerance (default 0.00001).</summary>
public static void AssertAlmostEquals(double lhs, double rhs, double tolerance=0.00001,
String msg = null,
[CallerLineNumber] int line = 0,
[CallerFilePath] string file = null,
@ -86,10 +86,10 @@ public static class Test
file = "(unknown file)";
if (member == null)
member = "(unknown member)";
double difference = Math.Abs(expected - actual);
double difference = Math.Abs(lhs - rhs);
if (difference > tolerance) {
if (msg == null || msg.Length == 0)
msg = $"Expected \"{expected}\". Difference: \"{difference}\"";
msg = $"Left hand side \"{lhs}\". Difference: \"{difference}\"";
throw new AssertionException($"{file}:{line} ({member}) {msg}");
}
}

77
src/tests/efl_mono/dummy_constructible_object.c Normal file
View File

@ -0,0 +1,77 @@
#include "libefl_mono_native_test.h"
typedef struct _Dummy_Constructible_Object_Data
{
Eo *internal_obj;
int native_construction_count;
int default_construction_count;
int special_construction_count;
} Dummy_Constructible_Object_Data;
EOLIAN static Eo *
_dummy_constructible_object_efl_object_constructor(Eo *obj, Dummy_Constructible_Object_Data *pd)
{
++(pd->native_construction_count);
return efl_constructor(efl_super(obj, DUMMY_CONSTRUCTIBLE_OBJECT_CLASS));
}
EOLIAN static void
_dummy_constructible_object_efl_object_destructor(Eo *obj, Dummy_Constructible_Object_Data *pd)
{
if (pd->internal_obj)
efl_unref(pd->internal_obj);
efl_destructor(efl_super(obj, DUMMY_CONSTRUCTIBLE_OBJECT_CLASS));
}
EOLIAN static Efl_Object *
_dummy_constructible_object_construct_type_and_store(Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd, const Efl_Class *klass)
{
pd->internal_obj = efl_add_ref(klass, NULL);
return pd->internal_obj;
}
EOLIAN static void
_dummy_constructible_object_increment_default_construction_count(Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd)
{
++(pd->default_construction_count);
}
EOLIAN static void
_dummy_constructible_object_increment_special_construction_count(Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd)
{
++(pd->special_construction_count);
}
EOLIAN static int
_dummy_constructible_object_native_construction_count_get(const Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd)
{
return pd->native_construction_count;
}
EOLIAN static int
_dummy_constructible_object_default_construction_count_get(const Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd)
{
return pd->default_construction_count;
}
EOLIAN static int
_dummy_constructible_object_special_construction_count_get(const Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd)
{
return pd->special_construction_count;
}
EOLIAN static Efl_Object *
_dummy_constructible_object_internal_object_get(const Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd)
{
return pd->internal_obj;
}
EOLIAN static int
_dummy_constructible_object_multiply_integer_value(const Eo *obj EINA_UNUSED, Dummy_Constructible_Object_Data *pd EINA_UNUSED, int v)
{
return 2 * v;
}
#include "dummy_constructible_object.eo.c"

53
src/tests/efl_mono/dummy_constructible_object.eo Normal file
View File

@ -0,0 +1,53 @@
class Dummy.Constructible_Object extends Efl.Object {
methods {
construct_type_and_store {
params {
@in type: const(Efl.Class);
}
return: Efl.Object;
}
increment_default_construction_count {
}
increment_special_construction_count {
}
@property native_construction_count {
get {
}
values {
value: int;
}
}
@property default_construction_count {
get {
}
values {
value: int;
}
}
@property special_construction_count {
get {
}
values {
value: int;
}
}
@property internal_object {
get {
}
values {
value: Efl.Object;
}
}
multiply_integer_value @const {
params {
v: int;
}
return: int;
}
}
implements {
Efl.Object.constructor;
Efl.Object.destructor;
}
}

846
src/tests/efl_mono/dummy_test_object.c
View File

@ -16,6 +16,10 @@ typedef struct Dummy_Test_Object_Data
int iface_prop;
Eo *provider;
Eo *iface_provider;
// Containers passed to C# as iterator/accessors
Eina_Array *out_array;
Eina_Free_Cb out_array_free_element_cb;
} Dummy_Test_Object_Data;
static
@ -56,9 +60,9 @@ Dummy_Numberwrapper **_new_obj_ref(int n)
return &r;
}
// ############ //
// Test.Testing //
// ############ //
// ################# //
// Dummy.Test_Object //
// ################# //
static Efl_Object*
_dummy_test_object_efl_object_constructor(Eo *obj, Dummy_Test_Object_Data *pd)
@ -97,6 +101,17 @@ _dummy_test_object_efl_object_destructor(Eo *obj, Dummy_Test_Object_Data *pd)
pd->list_for_accessor = NULL;
}
if (pd->out_array)
{
if (pd->out_array_free_element_cb)
{
unsigned n = eina_array_count(pd->out_array);
for (unsigned i = 0; i < n; ++i)
pd->out_array_free_element_cb(eina_array_data_get(pd->out_array, i));
}
eina_array_free(pd->out_array);
}
efl_destructor(efl_super(obj, DUMMY_TEST_OBJECT_CLASS));
}
@ -722,6 +737,139 @@ Eina_Array *_dummy_test_object_eina_array_str_return_own(EINA_UNUSED Eo *obj, EI
return arr;
}
// Eina_Stringshare
Eina_Bool _array_strshare_equal(const Eina_Array *arr, const char * const base[], unsigned int len)
{
Eina_Bool result = EINA_TRUE;
if (eina_array_count(arr) != len)
return EINA_FALSE;
for (unsigned int i = 0; i < len && result; ++i)
{
Eina_Stringshare *ssa = eina_array_data_get(arr, i);
Eina_Stringshare *sse = eina_stringshare_add(base[i]);
result = (ssa == sse);
if (!result)
fprintf(stderr, "Unexpected stringshare value. Expected: \"%s\" [%p]; Actual: \"%s\" [%p].\n", sse, sse, ssa, ssa);
eina_stringshare_del(sse);
}
return result;
}
Eina_Bool _dummy_test_object_eina_array_strshare_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_strshare_equal(arr, base_seq_str, base_seq_str_size);
eina_array_push(arr, eina_stringshare_add("42"));
eina_array_push(arr, eina_stringshare_add("43"));
eina_array_push(arr, eina_stringshare_add("33"));
return r;
}
static Eina_Array *_array_strshare_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_array_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array *arr)
{
Eina_Bool r = _array_strshare_equal(arr, base_seq_str, base_seq_str_size);
eina_array_push(arr, eina_stringshare_add("42"));
eina_array_push(arr, eina_stringshare_add("43"));
eina_array_push(arr, eina_stringshare_add("33"));
_array_strshare_in_own_to_check = arr;
return r;
}
Eina_Bool _dummy_test_object_check_eina_array_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_strshare_in_own_to_check) return EINA_FALSE;
Eina_Bool r = _array_strshare_equal(_array_strshare_in_own_to_check, modified_seq_str, modified_seq_str_size);
unsigned int i;
Eina_Stringshare *ele;
Eina_Array_Iterator it;
EINA_ARRAY_ITER_NEXT(_array_strshare_in_own_to_check, i, ele, it)
eina_stringshare_del(ele);
eina_array_free(_array_strshare_in_own_to_check);
_array_strshare_in_own_to_check = NULL;
return r;
}
Eina_Array *_array_strshare_out_to_check = NULL;
Eina_Bool _dummy_test_object_eina_array_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
eina_array_push(*arr, eina_stringshare_add("0x0"));
eina_array_push(*arr, eina_stringshare_add("0x2A"));
eina_array_push(*arr, eina_stringshare_add("0x42"));
_array_strshare_out_to_check = *arr;
return EINA_TRUE;
}
Eina_Bool _dummy_test_object_check_eina_array_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_strshare_out_to_check) return EINA_FALSE;
Eina_Bool r = _array_strshare_equal(_array_strshare_out_to_check, modified_seq_str, modified_seq_str_size);
unsigned int i;
Eina_Stringshare *ele;
Eina_Array_Iterator it;
EINA_ARRAY_ITER_NEXT(_array_strshare_out_to_check, i, ele, it)
eina_stringshare_del(ele);
eina_array_free(_array_strshare_out_to_check);
_array_strshare_out_to_check = NULL;
return r;
}
Eina_Bool _dummy_test_object_eina_array_strshare_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Array **arr)
{
if (!arr) return EINA_FALSE;
*arr = eina_array_new(default_step);
eina_array_push(*arr, eina_stringshare_add("0x0"));
eina_array_push(*arr, eina_stringshare_add("0x2A"));
eina_array_push(*arr, eina_stringshare_add("0x42"));
return EINA_TRUE;
}
Eina_Array *_array_strshare_return_to_check = NULL;
Eina_Array *_dummy_test_object_eina_array_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, eina_stringshare_add("0x0"));
eina_array_push(arr, eina_stringshare_add("0x2A"));
eina_array_push(arr, eina_stringshare_add("0x42"));
_array_strshare_return_to_check = arr;
return arr;
}
Eina_Bool _dummy_test_object_check_eina_array_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_array_strshare_return_to_check) return EINA_FALSE;
Eina_Bool r = _array_strshare_equal(_array_strshare_return_to_check, modified_seq_str, modified_seq_str_size);
unsigned int i;
Eina_Stringshare *ele;
Eina_Array_Iterator it;
EINA_ARRAY_ITER_NEXT(_array_strshare_return_to_check, i, ele, it)
eina_stringshare_del(ele);
eina_array_free(_array_strshare_return_to_check);
_array_strshare_return_to_check = NULL;
return r;
}
Eina_Array *_dummy_test_object_eina_array_strshare_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = eina_array_new(default_step);
eina_array_push(arr, eina_stringshare_add("0x0"));
eina_array_push(arr, eina_stringshare_add("0x2A"));
eina_array_push(arr, eina_stringshare_add("0x42"));
return arr;
}
// Object
Eina_Bool _array_obj_equal(const Eina_Array *arr, const Dummy_Numberwrapper * const base[], unsigned int len)
@ -1482,6 +1630,136 @@ Eina_List *_dummy_test_object_eina_list_str_return_own(EINA_UNUSED Eo *obj, EINA
return lst;
}
// Eina_Stringshare
Eina_Bool _list_strshare_equal(const Eina_List *lst, const char * const base[], unsigned int len)
{
if (eina_list_count(lst) != len)
return EINA_FALSE;
const Eina_List *l;
Eina_Stringshare *data;
int i = 0;
EINA_LIST_FOREACH(lst, l, data)
{
Eina_Stringshare *ssa = data;
Eina_Stringshare *sse = eina_stringshare_add(base[i]);
if (ssa != sse)
{
fprintf(stderr, "Unexpected stringshare value. Expected: \"%s\" [%p]; Actual: \"%s\" [%p].\n", sse, sse, ssa, ssa);
eina_stringshare_del(sse);
return EINA_FALSE;
}
eina_stringshare_del(sse);
++i;
}
return EINA_TRUE;
}
Eina_Bool _dummy_test_object_eina_list_strshare_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_strshare_equal(lst, base_seq_str, base_seq_str_size);
return r;
}
static Eina_List *_list_strshare_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_list_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List *lst)
{
Eina_Bool r = _list_strshare_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
lst = eina_list_append(lst, eina_stringshare_add("42"));
lst = eina_list_append(lst, eina_stringshare_add("43"));
lst = eina_list_append(lst, eina_stringshare_add("33"));
_list_strshare_in_own_to_check = lst;
return r;
}
Eina_Bool _dummy_test_object_check_eina_list_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_strshare_in_own_to_check) return EINA_FALSE;
Eina_Bool r = _list_strshare_equal(_list_strshare_in_own_to_check, modified_seq_str, modified_seq_str_size);
if (!r) return r;
Eina_Stringshare *ele;
EINA_LIST_FREE(_list_strshare_in_own_to_check, ele)
eina_stringshare_del(ele);
_list_strshare_in_own_to_check = NULL;
return r;
}
Eina_List *_list_strshare_out_to_check = NULL;
Eina_Bool _dummy_test_object_eina_list_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, eina_stringshare_add("0x0"));
*lst = eina_list_append(*lst, eina_stringshare_add("0x2A"));
*lst = eina_list_append(*lst, eina_stringshare_add("0x42"));
_list_strshare_out_to_check = *lst;
return EINA_TRUE;
}
Eina_Bool _dummy_test_object_check_eina_list_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_strshare_out_to_check) return EINA_FALSE;
Eina_Bool r = _list_strshare_equal(_list_strshare_out_to_check, base_seq_str, base_seq_str_size);
if (!r) return r;
Eina_Stringshare *ele;
EINA_LIST_FREE(_list_strshare_out_to_check, ele)
eina_stringshare_del(ele);
_list_strshare_out_to_check = NULL;
return r;
}
Eina_Bool _dummy_test_object_eina_list_strshare_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_List **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_list_append(*lst, eina_stringshare_add("0x0"));
*lst = eina_list_append(*lst, eina_stringshare_add("0x2A"));
*lst = eina_list_append(*lst, eina_stringshare_add("0x42"));
return EINA_TRUE;
}
Eina_List *_list_strshare_return_to_check = NULL;
Eina_List *_dummy_test_object_eina_list_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, eina_stringshare_add("0x0"));
lst = eina_list_append(lst, eina_stringshare_add("0x2A"));
lst = eina_list_append(lst, eina_stringshare_add("0x42"));
_list_strshare_return_to_check = lst;
return lst;
}
Eina_Bool _dummy_test_object_check_eina_list_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_list_strshare_return_to_check) return EINA_FALSE;
Eina_Bool r = _list_strshare_equal(_list_strshare_return_to_check, base_seq_str, base_seq_str_size);
if (!r) return r;
Eina_Stringshare *ele;
EINA_LIST_FREE(_list_strshare_return_to_check, ele)
eina_stringshare_del(ele);
_list_strshare_return_to_check = NULL;
return r;
}
Eina_List *_dummy_test_object_eina_list_strshare_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_List *lst = NULL;
lst = eina_list_append(lst, eina_stringshare_add("0x0"));
lst = eina_list_append(lst, eina_stringshare_add("0x2A"));
lst = eina_list_append(lst, eina_stringshare_add("0x42"));
return lst;
}
// Object
Eina_Bool _list_obj_equal(const Eina_List *lst, const Dummy_Numberwrapper * const base[], unsigned int len)
@ -1917,6 +2195,164 @@ Eina_Inlist *_dummy_test_object_eina_inlist_str_return_own(EINA_UNUSED Eo *obj,
return lst;
}
// Eina_Stringshare
typedef struct _Dummy_Inlist_Node_Strshare
{
EINA_INLIST;
Eina_Stringshare *val;
} Dummy_Inlist_Node_Strshare;
Eina_Inlist *_new_inlist_strshare(const char *v)
{
Dummy_Inlist_Node_Strshare *node = malloc(sizeof(Dummy_Inlist_Node_Strshare));
node->val = eina_stringshare_add(v);
return EINA_INLIST_GET(node);
}
Eina_Bool _inlist_strshare_equal(const Eina_Inlist *lst, const char * const base[], unsigned int len)
{
if (eina_inlist_count(lst) != len)
return EINA_FALSE;
const Dummy_Inlist_Node_Strshare *node;
int i = 0;
EINA_INLIST_FOREACH(lst, node)
{
Eina_Stringshare *ssa = node->val;
Eina_Stringshare *sse = eina_stringshare_add(base[i]);
if (ssa != sse)
{
fprintf(stderr, "Unexpected stringshare value. Expected: \"%s\" [%p]; Actual: \"%s\" [%p].\n", sse, sse, ssa, ssa);
eina_stringshare_del(sse);
return EINA_FALSE;
}
eina_stringshare_del(sse);
++i;
}
return EINA_TRUE;
}
Eina_Bool _dummy_test_object_eina_inlist_strshare_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_strshare_equal(lst, base_seq_str, base_seq_str_size);
return r;
}
static Eina_Inlist *_inlist_strshare_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_inlist_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist *lst)
{
Eina_Bool r = _inlist_strshare_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
lst = eina_inlist_append(lst, _new_inlist_strshare("42"));
lst = eina_inlist_append(lst, _new_inlist_strshare("43"));
lst = eina_inlist_append(lst, _new_inlist_strshare("33"));
_inlist_strshare_in_own_to_check = lst;
return r;
}
Eina_Bool _dummy_test_object_check_eina_inlist_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_strshare_in_own_to_check;
if (!lst) return EINA_FALSE;
_inlist_strshare_in_own_to_check = NULL;
Eina_Bool r = _inlist_strshare_equal(lst, modified_seq_str, modified_seq_str_size);
if (!r) return r;
Dummy_Inlist_Node_Strshare *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
eina_stringshare_del(node->val);
free(node);
}
return r;
}
Eina_Inlist *_inlist_strshare_out_to_check = NULL;
Eina_Bool _dummy_test_object_eina_inlist_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_strshare("0x0"));
*lst = eina_inlist_append(*lst, _new_inlist_strshare("0x2A"));
*lst = eina_inlist_append(*lst, _new_inlist_strshare("0x42"));
_inlist_strshare_out_to_check = *lst;
return EINA_TRUE;
}
Eina_Bool _dummy_test_object_check_eina_inlist_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_strshare_out_to_check;
if (!lst) return EINA_FALSE;
_inlist_strshare_out_to_check = NULL;
Eina_Bool r = _inlist_strshare_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
Dummy_Inlist_Node_Strshare *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
eina_stringshare_del(node->val);
free(node);
}
return r;
}
Eina_Bool _dummy_test_object_eina_inlist_strshare_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Inlist **lst)
{
if (!lst) return EINA_FALSE;
*lst = eina_inlist_append(*lst, _new_inlist_strshare("0x0"));
*lst = eina_inlist_append(*lst, _new_inlist_strshare("0x2A"));
*lst = eina_inlist_append(*lst, _new_inlist_strshare("0x42"));
return EINA_TRUE;
}
Eina_Inlist *_inlist_strshare_return_to_check = NULL;
Eina_Inlist *_dummy_test_object_eina_inlist_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_strshare("0x0"));
lst = eina_inlist_append(lst, _new_inlist_strshare("0x2A"));
lst = eina_inlist_append(lst, _new_inlist_strshare("0x42"));
_inlist_strshare_return_to_check = lst;
return lst;
}
Eina_Bool _dummy_test_object_check_eina_inlist_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = _inlist_strshare_return_to_check;
if (!lst) return EINA_FALSE;
_inlist_strshare_return_to_check = NULL;
Eina_Bool r = _inlist_strshare_equal(lst, base_seq_str, base_seq_str_size);
if (!r) return r;
Dummy_Inlist_Node_Strshare *node;
EINA_INLIST_FREE(lst, node)
{
lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
eina_stringshare_del(node->val);
free(node);
}
return r;
}
Eina_Inlist *_dummy_test_object_eina_inlist_strshare_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Inlist *lst = NULL;
lst = eina_inlist_append(lst, _new_inlist_strshare("0x0"));
lst = eina_inlist_append(lst, _new_inlist_strshare("0x2A"));
lst = eina_inlist_append(lst, _new_inlist_strshare("0x42"));
return lst;
}
// Object
typedef struct _Dummy_Inlist_Node_Obj
@ -2438,6 +2874,194 @@ Eina_Bool _dummy_test_object_check_eina_hash_str_return_own(EINA_UNUSED Eo *obj,
}
// Eina_Stringshare //
Eina_Bool _hash_strshare_check(const Eina_Hash *hsh, const char *key, const char *expected_val)
{
Eina_Stringshare *ssk = eina_stringshare_add(key);
Eina_Stringshare *sse = eina_stringshare_add(expected_val);
Eina_Stringshare *ssa = eina_hash_find(hsh, ssk);
Eina_Bool result = (ssa == sse);
if (!result)
fprintf(stderr, "Unexpected stringshare value. Expected: \"%s\" [%p]; Actual: \"%s\" [%p].\n", sse, sse, ssa, ssa);
eina_stringshare_del(ssk);
eina_stringshare_del(sse);
return result;
}
static inline Eina_Bool _hash_strshare_add(Eina_Hash *hsh, const char *key, const char *val)
{
return eina_hash_add(hsh, eina_stringshare_add(key), eina_stringshare_add(val));
}
// strshare in
Eina_Bool _dummy_test_object_eina_hash_strshare_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh)
{
if (!_hash_strshare_check(hsh, "aa", "aaa"))
return EINA_FALSE;
return _hash_strshare_add(hsh, "bb", "bbb");
}
// strshare in own
static Eina_Bool _hash_strshare_in_own_free_flag = EINA_FALSE;
static void _hash_strshare_in_own_free_cb(void *data)
{
_hash_strshare_in_own_free_flag = EINA_TRUE;
eina_stringshare_del(data);
}
static Eina_Hash *_hash_strshare_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_hash_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash *hsh)
{
eina_hash_free_cb_set(hsh, _hash_strshare_in_own_free_cb);
if (!_hash_strshare_check(hsh, "aa", "aaa"))
return EINA_FALSE;
_hash_strshare_in_own_to_check = hsh;
return _hash_strshare_add(hsh, "bb", "bbb");
}
Eina_Bool _dummy_test_object_check_eina_hash_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_strshare_in_own_to_check) return EINA_FALSE;
Eina_Hash *hsh = _hash_strshare_in_own_to_check;
if (!_hash_strshare_check(hsh, "aa", "aaa")
|| !_hash_strshare_check(hsh, "bb", "bbb")
|| !_hash_strshare_check(hsh, "cc", "ccc"))
return EINA_FALSE;
eina_hash_free(hsh);
return _hash_strshare_in_own_free_flag;
}
// strshare out
static Eina_Bool _hash_strshare_out_free_flag = EINA_FALSE;
static void _hash_strshare_out_free_cb(void *data)
{
_hash_strshare_out_free_flag = EINA_TRUE;
eina_stringshare_del(data);
}
Eina_Hash *_hash_strshare_out_to_check = NULL;
Eina_Bool _dummy_test_object_eina_hash_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh)
{
if (!hsh) return EINA_FALSE;
*hsh = eina_hash_string_superfast_new(_hash_strshare_out_free_cb);
_hash_strshare_out_to_check = *hsh;
return _hash_strshare_add(*hsh, "aa", "aaa");
}
Eina_Bool _dummy_test_object_check_eina_hash_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_strshare_out_to_check) return EINA_FALSE;
Eina_Hash *hsh = _hash_strshare_out_to_check;
if (!_hash_strshare_check(hsh, "aa", "aaa")
|| !_hash_strshare_check(hsh, "bb", "bbb"))
return EINA_FALSE;
eina_hash_free(hsh);
_hash_strshare_out_to_check = NULL;
return _hash_strshare_out_free_flag;
}
// strshare out own
static Eina_Bool _hash_strshare_out_own_free_flag = EINA_FALSE;
static void _hash_strshare_out_own_free_cb(void *data)
{
_hash_strshare_out_own_free_flag = EINA_TRUE;
eina_stringshare_del(data);
}
Eina_Bool _dummy_test_object_eina_hash_strshare_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Hash **hsh)
{
if (!hsh) return EINA_FALSE;
*hsh = eina_hash_string_superfast_new(_hash_strshare_out_own_free_cb);
return _hash_strshare_add(*hsh, "aa", "aaa");
}
Eina_Bool _dummy_test_object_check_eina_hash_strshare_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_strshare_out_own_free_flag;
}
// strshare return
static Eina_Bool _hash_strshare_return_free_flag = EINA_FALSE;
static void _hash_strshare_return_free_cb(void *data)
{
_hash_strshare_return_free_flag = EINA_TRUE;
eina_stringshare_del(data);
}
Eina_Hash *_hash_strshare_return_to_check = NULL;
Eina_Hash *_dummy_test_object_eina_hash_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Hash *hsh = eina_hash_string_superfast_new(_hash_strshare_return_free_cb);
_hash_strshare_add(hsh, "aa", "aaa");
_hash_strshare_return_to_check = hsh;
return hsh;
}
Eina_Bool _dummy_test_object_check_eina_hash_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
if (!_hash_strshare_return_to_check) return EINA_FALSE;
Eina_Hash *hsh = _hash_strshare_return_to_check;
if (!_hash_strshare_check(hsh, "aa", "aaa")
|| !_hash_strshare_check(hsh, "bb", "bbb"))
return EINA_FALSE;
eina_hash_free(hsh);
_hash_strshare_return_to_check = NULL;
return _hash_strshare_return_free_flag;
}
// strshare return own
static Eina_Bool _hash_strshare_return_own_free_flag = EINA_FALSE;
static void _hash_strshare_return_own_free_cb(void *data)
{
_hash_strshare_return_own_free_flag = EINA_TRUE;
eina_stringshare_del(data);
}
Eina_Hash *_dummy_test_object_eina_hash_strshare_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Hash *hsh = eina_hash_string_superfast_new(_hash_strshare_return_own_free_cb);
_hash_strshare_add(hsh, "aa", "aaa");
return hsh;
}
Eina_Bool _dummy_test_object_check_eina_hash_strshare_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
return !_hash_strshare_return_own_free_flag;
}
// Object //
Eina_Bool _hash_obj_check(const Eina_Hash *hsh, Dummy_Numberwrapper *key, Dummy_Numberwrapper *expected_val, int knum, int vnum)
@ -2695,7 +3319,7 @@ static Eina_Iterator *_iterator_int_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_iterator_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_int_equal(itr, base_seq_int, base_seq_int_size, EINA_TRUE);
Eina_Bool r = _iterator_int_equal(itr, base_seq_int, base_seq_int_size, EINA_FALSE);
_iterator_int_in_own_to_check = itr;
return r;
}
@ -2746,9 +3370,12 @@ Eina_Bool _dummy_test_object_eina_iterator_int_out_own(EINA_UNUSED Eo *obj, EINA
{
if (!itr) return EINA_FALSE;
Eina_Array *arr = _iterator_int_eina_array_new();
if (pd->out_array)
eina_array_free(pd->out_array);
*itr = eina_array_iterator_new(arr);
pd->out_array = _iterator_int_eina_array_new();
*itr = eina_array_iterator_new(pd->out_array);
return EINA_TRUE;
}
@ -2786,8 +3413,11 @@ Eina_Bool _dummy_test_object_check_eina_iterator_int_return(EINA_UNUSED Eo *obj,
Eina_Iterator *_dummy_test_object_eina_iterator_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = _iterator_int_eina_array_new();
return eina_array_iterator_new(arr);
if (pd->out_array)
eina_array_free(pd->out_array);
pd->out_array = _iterator_int_eina_array_new();
return eina_array_iterator_new(pd->out_array);
}
// String //
@ -2853,7 +3483,7 @@ static Eina_Iterator *_iterator_str_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_iterator_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_str_equal(itr, base_seq_str, base_seq_str_size, EINA_TRUE);
Eina_Bool r = _iterator_str_equal(itr, base_seq_str, base_seq_str_size, EINA_FALSE);
_iterator_str_in_own_to_check = itr;
return r;
}
@ -2904,9 +3534,12 @@ Eina_Bool _dummy_test_object_eina_iterator_str_out_own(EINA_UNUSED Eo *obj, EINA
{
if (!itr) return EINA_FALSE;
Eina_Array *arr = _iterator_str_eina_array_new();
if (pd->out_array)
eina_array_free(pd->out_array);
*itr = eina_array_iterator_new(arr);
pd->out_array = _iterator_str_eina_array_new();
*itr = eina_array_iterator_new(pd->out_array);
return EINA_TRUE;
}
@ -2944,8 +3577,179 @@ Eina_Bool _dummy_test_object_check_eina_iterator_str_return(EINA_UNUSED Eo *obj,
Eina_Iterator *_dummy_test_object_eina_iterator_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = _iterator_str_eina_array_new();
return eina_array_iterator_new(arr);
if (pd->out_array)
eina_array_free(pd->out_array);
pd->out_array = _iterator_str_eina_array_new();
return eina_array_iterator_new(pd->out_array);
}
// Eina_Stringshare //
Eina_Bool _iterator_strshare_equal(Eina_Iterator *itr, const char * const base[], unsigned int len, Eina_Bool release)
{
Eina_Stringshare *ssa;
unsigned i = 0;
EINA_ITERATOR_FOREACH(itr, ssa)
{
Eina_Stringshare *sse = eina_stringshare_add(base[i]);
if (ssa != sse)
{
fprintf(stderr, "Unexpected stringshare value. Expected: \"%s\" [%p]; Actual: \"%s\" [%p].\n", sse, sse, ssa, ssa);
eina_stringshare_del(sse);
return EINA_FALSE;
}
eina_stringshare_del(sse);
if (release)
eina_stringshare_del(ssa);
++i;
}
if (i != len)
return EINA_FALSE;
return EINA_TRUE;
}
Eina_Array *_iterator_strshare_eina_array_new()
{
Eina_Array *arr = eina_array_new(32);
for (unsigned i = 0; i < base_seq_str_size; ++i)
{
eina_array_push(arr, eina_stringshare_add(base_seq_str[i]));
}
return arr;
}
Eina_Bool _iterator_strshare_test_array(Eina_Array *arr)
{
if (eina_array_count(arr) != base_seq_str_size)
return EINA_FALSE;
for (unsigned i = 0; i < base_seq_str_size; ++i)
{
Eina_Stringshare *ssa = eina_array_data_get(arr, i);
Eina_Stringshare *sse = eina_stringshare_add(base_seq_str[i]);
if (ssa != sse)
return EINA_FALSE;
eina_stringshare_del(ssa);
eina_stringshare_del(sse);
}
eina_array_free(arr);
return EINA_TRUE;
}
// <strshare> in
Eina_Bool _dummy_test_object_eina_iterator_strshare_in(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_strshare_equal(itr, base_seq_str, base_seq_str_size, EINA_FALSE);
return r;
}
// <strshare> in own
static Eina_Iterator *_iterator_strshare_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_iterator_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_strshare_equal(itr, base_seq_str, base_seq_str_size, EINA_FALSE);
_iterator_strshare_in_own_to_check = itr;
return r;
}
Eina_Bool _dummy_test_object_check_eina_iterator_strshare_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
eina_iterator_free(_iterator_strshare_in_own_to_check);
_iterator_strshare_in_own_to_check = NULL;
return EINA_TRUE;
}
// <strshare> out
Eina_Iterator *_iterator_strshare_out_to_check = NULL;
Eina_Array *_iterator_strshare_out_array = NULL;
Eina_Bool _dummy_test_object_eina_iterator_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
_iterator_strshare_out_array = _iterator_strshare_eina_array_new();
*itr = eina_array_iterator_new(_iterator_strshare_out_array);
_iterator_strshare_out_to_check = *itr;
return EINA_TRUE;
}
Eina_Bool _dummy_test_object_check_eina_iterator_strshare_out(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_strshare_out_to_check;
if (!itr) return EINA_FALSE;
_iterator_strshare_out_to_check = NULL;
Eina_Array *arr = _iterator_strshare_out_array;
if (!arr) return EINA_FALSE;
_iterator_strshare_out_array = NULL;
Eina_Bool r = _iterator_strshare_test_array(arr);
if (!r) return r;
eina_iterator_free(itr);
return r;
}
// <strshare> out own
Eina_Bool _dummy_test_object_eina_iterator_strshare_out_own(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd, Eina_Iterator **itr)
{
if (!itr) return EINA_FALSE;
pd->out_array = _iterator_strshare_eina_array_new();
pd->out_array_free_element_cb = (Eina_Free_Cb) eina_stringshare_del;
*itr = eina_array_iterator_new(pd->out_array);
return EINA_TRUE;
}
// <strshare> return
Eina_Iterator *_iterator_strshare_return_to_check = NULL;
Eina_Array *_iterator_strshare_return_array = NULL;
Eina_Iterator *_dummy_test_object_eina_iterator_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
_iterator_strshare_return_array = _iterator_strshare_eina_array_new();
_iterator_strshare_return_to_check = eina_array_iterator_new(_iterator_strshare_return_array);
return _iterator_strshare_return_to_check;
}
Eina_Bool _dummy_test_object_check_eina_iterator_strshare_return(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Iterator *itr = _iterator_strshare_return_to_check;
if (!itr) return EINA_FALSE;
_iterator_strshare_return_to_check = NULL;
Eina_Array *arr = _iterator_strshare_return_array;
if (!arr) return EINA_FALSE;
_iterator_strshare_return_array = NULL;
Eina_Bool r = _iterator_strshare_test_array(arr);
if (!r) return r;
eina_iterator_free(itr);
return r;
}
// <strshare> return own
Eina_Iterator *_dummy_test_object_eina_iterator_strshare_return_own(EINA_UNUSED Eo *obj, Dummy_Test_Object_Data *pd)
{
pd->out_array = _iterator_strshare_eina_array_new();
pd->out_array_free_element_cb = (Eina_Free_Cb) eina_stringshare_del;
return eina_array_iterator_new(pd->out_array);
}
// Object //
@ -3015,7 +3819,7 @@ static Eina_Iterator *_iterator_obj_in_own_to_check = NULL;
Eina_Bool _dummy_test_object_eina_iterator_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd, Eina_Iterator *itr)
{
Eina_Bool r = _iterator_obj_equal(itr, base_seq_obj, base_seq_obj_size, EINA_TRUE);
Eina_Bool r = _iterator_obj_equal(itr, base_seq_obj, base_seq_obj_size, EINA_FALSE);
_iterator_obj_in_own_to_check = itr;
return r;
}
@ -3066,9 +3870,12 @@ Eina_Bool _dummy_test_object_eina_iterator_obj_out_own(EINA_UNUSED Eo *obj, EINA
{
if (!itr) return EINA_FALSE;
Eina_Array *arr = _iterator_obj_eina_array_new();
if (pd->out_array)
eina_array_free(pd->out_array);
*itr = eina_array_iterator_new(arr);
pd->out_array = _iterator_obj_eina_array_new();
*itr = eina_array_iterator_new(pd->out_array);
return EINA_TRUE;
}
@ -3106,8 +3913,11 @@ Eina_Bool _dummy_test_object_check_eina_iterator_obj_return(EINA_UNUSED Eo *obj,
Eina_Iterator *_dummy_test_object_eina_iterator_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Dummy_Test_Object_Data *pd)
{
Eina_Array *arr = _iterator_obj_eina_array_new();
return eina_array_iterator_new(arr);
if (pd->out_array)
eina_array_free(pd->out_array);
pd->out_array = _iterator_obj_eina_array_new();
return eina_array_iterator_new(pd->out_array);
}
// //

218
src/tests/efl_mono/dummy_test_object.eo
View File

@ -468,6 +468,52 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
return: array<mstring @owned> @owned;
}
/* Eina_Stringshare */
eina_array_strshare_in {
params {
@in arr: array<stringshare>;
}
return: bool;
}
eina_array_strshare_in_own {
params {
@in arr: array<stringshare @owned> @owned;
}
return: bool;
}
check_eina_array_strshare_in_own {
return: bool;
}
eina_array_strshare_out {
params {
@out arr: array<stringshare>;
}
return: bool;
}
check_eina_array_strshare_out {
return: bool;
}
eina_array_strshare_out_own {
params {
@out arr: array<stringshare @owned> @owned;
}
return: bool;
}
eina_array_strshare_return {
return: array<stringshare>;
}
check_eina_array_strshare_return {
return: bool;
}
eina_array_strshare_return_own {
return: array<stringshare @owned> @owned;
}
/* Object */
eina_array_obj_in {
params {
@ -615,6 +661,52 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
return: list<mstring @owned> @owned;
}
/* Eina_Stringshare */
eina_list_strshare_in {
params {
@in lst: list<stringshare>;
}
return: bool;
}
eina_list_strshare_in_own {
params {
@in lst: list<stringshare @owned> @owned;
}
return: bool;
}
check_eina_list_strshare_in_own {
return: bool;
}
eina_list_strshare_out {
params {
@out lst: list<stringshare>;
}
return: bool;
}
check_eina_list_strshare_out {
return: bool;
}
eina_list_strshare_out_own {
params {
@out lst: list<stringshare @owned> @owned;
}
return: bool;
}
eina_list_strshare_return {
return: list<stringshare>;
}
check_eina_list_strshare_return {
return: bool;
}
eina_list_strshare_return_own {
return: list<stringshare @owned> @owned;
}
/* Object */
eina_list_obj_in {
params {
@ -774,6 +866,58 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
return: bool;
}
// Eina_Stringshare //
eina_hash_strshare_in {
params {
@in hsh: hash<stringshare, stringshare>;
}
return: bool;
}
eina_hash_strshare_in_own {
params {
@in hsh: hash<stringshare, stringshare @owned> @owned;
}
return: bool;
}
check_eina_hash_strshare_in_own {
return: bool;
}
eina_hash_strshare_out {
params {
@out hsh: hash<stringshare, stringshare>;
}
return: bool;
}
check_eina_hash_strshare_out {
return: bool;
}
eina_hash_strshare_out_own {
params {
@out hsh: hash<stringshare, stringshare @owned> @owned;
}
return: bool;
}
check_eina_hash_strshare_out_own {
return: bool;
}
eina_hash_strshare_return {
return: hash<stringshare, stringshare>;
}
check_eina_hash_strshare_return {
return: bool;
}
eina_hash_strshare_return_own {
return: hash<stringshare, stringshare @owned> @owned;
}
check_eina_hash_strshare_return_own {
return: bool;
}
// Object //
eina_hash_obj_in {
params {
@ -869,14 +1013,14 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
/* Integer */
eina_iterator_int_in {
params {
@in itr: iterator<ptr(int)>;
@in itr: iterator<int>;
}
return: bool;
}
eina_iterator_int_in_own {
params {
@in itr: iterator<free(ptr(int),free) @owned> @owned;
@in itr: iterator<int> @owned;
}
return: bool;
}
@ -886,7 +1030,7 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
eina_iterator_int_out {
params {
@out itr: iterator<ptr(int)>;
@out itr: iterator<int>;
}
return: bool;
}
@ -896,20 +1040,20 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
eina_iterator_int_out_own {
params {
@out itr: iterator<free(ptr(int),free) @owned> @owned;
@out itr: iterator<int> @owned;
}
return: bool;
}
eina_iterator_int_return {
return: iterator<ptr(int)>;
return: iterator<int>;
}
check_eina_iterator_int_return {
return: bool;
}
eina_iterator_int_return_own {
return: iterator<free(ptr(int),free) @owned> @owned;
return: iterator<int> @owned;
}
/* String */
@ -922,7 +1066,7 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
eina_iterator_str_in_own {
params {
@in itr: iterator<mstring @owned> @owned;
@in itr: iterator<mstring> @owned;
}
return: bool;
}
@ -942,7 +1086,7 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
eina_iterator_str_out_own {
params {
@out itr: iterator<mstring @owned> @owned;
@out itr: iterator<mstring> @owned;
}
return: bool;
}
@ -955,7 +1099,53 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
}
eina_iterator_str_return_own {
return: iterator<mstring @owned> @owned;
return: iterator<mstring> @owned;
}
/* Eina_Stringshare */
eina_iterator_strshare_in {
params {
@in itr: iterator<stringshare>;
}
return: bool;
}
eina_iterator_strshare_in_own {
params {
@in itr: iterator<stringshare> @owned;
}
return: bool;
}
check_eina_iterator_strshare_in_own {
return: bool;
}
eina_iterator_strshare_out {
params {
@out itr: iterator<stringshare>;
}
return: bool;
}
check_eina_iterator_strshare_out {
return: bool;
}
eina_iterator_strshare_out_own {
params {
@out itr: iterator<stringshare> @owned;
}
return: bool;
}
eina_iterator_strshare_return {
return: iterator<stringshare>;
}
check_eina_iterator_strshare_return {
return: bool;
}
eina_iterator_strshare_return_own {
return: iterator<stringshare> @owned;
}
/* Object */
@ -968,7 +1158,7 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
eina_iterator_obj_in_own {
params {
@in itr: iterator<Dummy.Numberwrapper @owned> @owned;
@in itr: iterator<Dummy.Numberwrapper> @owned;
}
return: bool;
}
@ -988,7 +1178,7 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
eina_iterator_obj_out_own {
params {
@out itr: iterator<Dummy.Numberwrapper @owned> @owned;
@out itr: iterator<Dummy.Numberwrapper> @owned;
}
return: bool;
}
@ -1001,7 +1191,7 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
}
eina_iterator_obj_return_own {
return: iterator<Dummy.Numberwrapper @owned> @owned;
return: iterator<Dummy.Numberwrapper> @owned;
}
/* Function Pointer */
@ -1393,9 +1583,9 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface {
/* Accessors */
clone_accessor {
params {
@in acc: accessor<ptr(int)>;
@in acc: accessor<int>;
}
return: accessor<ptr(int)> @owned;
return: accessor<int> @owned;
}
@property setter_only {

1
src/tests/efl_mono/libefl_mono_native_test.h
View File

@ -55,6 +55,7 @@
#include "dummy_inherit_helper.eo.h"
#include "dummy_part_holder.eo.h"
#include "dummy_event_manager.eo.h"
#include "dummy_constructible_object.eo.h"
#include <interfaces/efl_part.eo.h>

3
src/tests/efl_mono/meson.build
View File

@ -7,6 +7,7 @@ eo_files = [
'dummy_inherit_iface.eo',
'dummy_part_holder.eo',
'dummy_event_manager.eo',
'dummy_constructible_object.eo',
]
eo_file_targets = []
@ -33,6 +34,7 @@ efl_mono_native_test = library('efl_mono_native_test',
'dummy_part_holder.c',
'dummy_test_object.c',
'dummy_event_manager.c',
'dummy_constructible_object.c',
],
dependencies : [ecore, eo, efl],
)
@ -65,6 +67,7 @@ efl_mono_src = [
'Eldbus.cs',
'Eo.cs',
'EoPromises.cs',
'EoConstruction.cs',
'Errors.cs',
'Events.cs',
'FunctionPointers.cs',

1
src/tests/elementary/efl_ui_suite.c
View File

@ -3,7 +3,6 @@
#endif
#include "efl_ui_suite.h"
#include "suite_helpers.h"
#include "eo_internal.h"
static const Efl_Test_Case etc[] = {

1
src/tests/elementary/efl_ui_suite.h
View File

@ -6,6 +6,7 @@
#define EFL_NOLEGACY_API_SUPPORT
#include <Efl_Ui.h>
#include "../efl_check.h"
#include "suite_helpers.h"
#define ck_assert_strn_eq(s1, s2, len) \
{ \

20
src/tests/elementary/efl_ui_test_active_view.c
View File

@ -11,8 +11,6 @@ EFL_CLASS_SIMPLE_CLASS(efl_ui_active_view_indicator, "efl_ui_active_view_indicat
static Efl_Ui_Win *win;
static Efl_Ui_Active_View_Container *container;
static int tree_abort;
static int tree_abort_level;
typedef struct {
struct {
@ -608,22 +606,6 @@ EFL_START_TEST (efl_ui_active_view_test_pop3)
}
EFL_END_TEST
static void
_shutdown(void)
{
eina_log_abort_on_critical_set(tree_abort);
eina_log_abort_on_critical_level_set(tree_abort_level);
}
static void
_setup(void)
{
tree_abort = eina_log_abort_on_critical_get();
tree_abort_level = eina_log_abort_on_critical_level_get();
eina_log_abort_on_critical_level_set(2);
eina_log_abort_on_critical_set(1);
}
static void
active_view_setup()
{
@ -645,7 +627,7 @@ active_view_teardown()
void efl_ui_test_active_view(TCase *tc)
{
tcase_add_checked_fixture(tc, _setup, _shutdown);
tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown);
tcase_add_checked_fixture(tc, active_view_setup, active_view_teardown);
tcase_add_test(tc, efl_ui_active_view_init);
tcase_add_test(tc, efl_ui_active_view_active_index);

1
src/tests/elementary/efl_ui_test_focus.c
View File

@ -1,5 +1,4 @@
#include "efl_ui_test_focus_common.h"
#include "suite_helpers.h"
EFL_START_TEST(focus_unregister_twice)
{

1
src/tests/elementary/efl_ui_test_radio_group.c
View File

@ -4,7 +4,6 @@
#include <Efl_Ui.h>
#include "efl_ui_suite.h"
#include "suite_helpers.h"
static Eo *win, *radio_group;

1
src/tests/elementary/efl_ui_test_widget.c
View File

@ -7,7 +7,6 @@
#include <Efl_Ui.h>
#include "efl_ui_suite.h"
#include "eo_internal.h"
#include "suite_helpers.h"
typedef struct {
Efl_Ui_Widget *btn1, *btn2;

348
src/tests/elementary/efl_ui_test_win.c
View File

@ -94,9 +94,357 @@ EFL_START_TEST(efl_ui_win_test_object_focus)
}
EFL_END_TEST
static void
create_environment(Eo **win, Eo **rect)
{
*win = efl_new(EFL_UI_WIN_CLASS);
*rect = efl_add(EFL_CANVAS_RECTANGLE_CLASS, evas_object_evas_get(*win));
efl_canvas_object_seat_focus_add(*rect, NULL);
efl_gfx_entity_geometry_set(*win, EINA_RECT(0, 0, 200, 200));
efl_gfx_entity_geometry_set(*rect, EINA_RECT(0, 0, 200, 200));
get_me_to_those_events(evas_object_evas_get(*win));
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_focus)
{
Efl_Ui_Win *win;
Efl_Canvas_Object *rect, *focus_in = NULL, *focus_out = NULL;
create_environment(&win, &rect);
efl_canvas_object_seat_focus_del(rect, NULL);
efl_event_callback_add(rect, EFL_EVENT_FOCUS_IN , _check_focus_event, &focus_in);
efl_event_callback_add(rect, EFL_EVENT_FOCUS_OUT, _check_focus_event, &focus_out);
efl_canvas_object_seat_focus_add(rect, NULL);
ck_assert_ptr_eq(focus_out, NULL);
ck_assert_ptr_eq(focus_in, rect);
focus_out = NULL;
focus_in = NULL;
efl_canvas_object_seat_focus_del(rect, NULL);
ck_assert_ptr_eq(focus_out, rect);
ck_assert_ptr_eq(focus_in, NULL);
focus_out = NULL;
focus_in = NULL;
}
EFL_END_TEST
#define TIMESTAMP 1337
static void
_check_key_event(void *data, const Efl_Event *ev)
{
Eina_Bool *pressed = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_str_eq(efl_input_key_name_get(ev->info), "odiaeresis");
ck_assert_str_eq(efl_input_key_get(ev->info), "ö");
ck_assert_str_eq(efl_input_key_string_get(ev->info), "Ö");
ck_assert_str_eq(efl_input_key_compose_string_get(ev->info), "Ö");
ck_assert_int_eq(efl_input_key_code_get(ev->info), 0xffe1);
*pressed = efl_input_key_pressed_get(ev->info);
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_key_down)
{
Efl_Ui_Win *win;
Eina_Bool pressed = EINA_FALSE;
Efl_Canvas_Object *rect;
create_environment(&win, &rect);
efl_event_callback_add(rect, EFL_EVENT_KEY_DOWN , _check_key_event, &pressed);
efl_event_callback_add(rect, EFL_EVENT_KEY_UP, _check_key_event, &pressed);
evas_event_feed_key_down_with_keycode(evas_object_evas_get(win), "odiaeresis", "ö", "Ö", "Ö", TIMESTAMP, NULL, 0xffe1);
ck_assert_int_eq(pressed, EINA_TRUE);
evas_event_feed_key_up_with_keycode(evas_object_evas_get(win), "odiaeresis", "ö", "Ö", "Ö", TIMESTAMP, NULL, 0xffe1);
ck_assert_int_eq(pressed, EINA_FALSE);
}
EFL_END_TEST
static void
position_eq(Eina_Position2D a, Eina_Position2D b)
{
ck_assert_int_eq(a.x, b.x);
ck_assert_int_eq(a.y, b.y);
}
static void
_check_ptr_move_event(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_previous_position_get(ev->info), EINA_POSITION2D(20, 20));
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(25, 25));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_MOVE);
*called = EINA_TRUE;
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_move)
{
Efl_Ui_Win *win;
Eina_Bool called = EINA_FALSE;
Efl_Canvas_Object *rect;
create_environment(&win, &rect);
evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
efl_event_callback_add(rect, EFL_EVENT_POINTER_MOVE , _check_ptr_move_event, &called);
evas_event_feed_mouse_move(evas_object_evas_get(win), 25, 25, TIMESTAMP, NULL);
ck_assert_int_eq(called, EINA_TRUE);
}
EFL_END_TEST
static void
_check_ptr_down_event(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), EINA_TRUE);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), EVAS_BUTTON_TRIPLE_CLICK);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_DOWN);
*called = EINA_TRUE;
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_down)
{
Efl_Ui_Win *win;
Eina_Bool called = EINA_FALSE;
Efl_Canvas_Object *rect;
create_environment(&win, &rect);
evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
efl_event_callback_add(rect, EFL_EVENT_POINTER_DOWN , _check_ptr_down_event, &called);
evas_event_feed_mouse_down(evas_object_evas_get(win), 1, EVAS_BUTTON_TRIPLE_CLICK, TIMESTAMP, NULL);
ck_assert_int_eq(called, EINA_TRUE);
}
EFL_END_TEST
static void
_check_ptr_up_event(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), EINA_TRUE);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), EVAS_BUTTON_TRIPLE_CLICK);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_UP);
*called = EINA_TRUE;
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_up)
{
Efl_Ui_Win *win;
Eina_Bool called = EINA_FALSE;
Efl_Canvas_Object *rect;
create_environment(&win, &rect);
evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
evas_event_feed_mouse_down(evas_object_evas_get(win), 1, EVAS_BUTTON_TRIPLE_CLICK, TIMESTAMP, NULL);
efl_event_callback_add(rect, EFL_EVENT_POINTER_UP , _check_ptr_up_event, &called);
evas_event_feed_mouse_up(evas_object_evas_get(win), 1, EVAS_BUTTON_TRIPLE_CLICK, TIMESTAMP, NULL);
ck_assert_int_eq(called, EINA_TRUE);
}
EFL_END_TEST
static void
_check_pointer_in_cb(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_IN );
*called = EINA_TRUE;
}
static void
_check_pointer_out_cb(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(5, 5));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_OUT );
*called = EINA_TRUE;
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_in_out)
{
Efl_Ui_Win *win;
Eina_Bool pointer_in = EINA_FALSE, pointer_out = EINA_FALSE;
Efl_Canvas_Object *rect;
create_environment(&win, &rect);
evas_event_feed_mouse_move(evas_object_evas_get(win), 5, 5, TIMESTAMP - 1, NULL);
evas_object_geometry_set(rect, 10, 10, 20, 20);
evas_event_feed_mouse_move(evas_object_evas_get(win), 5, 5, TIMESTAMP - 1, NULL);
efl_event_callback_add(rect, EFL_EVENT_POINTER_IN, _check_pointer_in_cb, &pointer_in);
efl_event_callback_add(rect, EFL_EVENT_POINTER_OUT, _check_pointer_out_cb, &pointer_out);
evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP, NULL);
ck_assert_int_eq(pointer_in, EINA_TRUE);
ck_assert_int_eq(pointer_out, EINA_FALSE);
pointer_in = EINA_FALSE;
pointer_out = EINA_FALSE;
evas_event_feed_mouse_move(evas_object_evas_get(win), 5, 5, TIMESTAMP, NULL);
ck_assert_int_eq(pointer_in, EINA_FALSE);
ck_assert_int_eq(pointer_out, EINA_TRUE);
}
EFL_END_TEST
static void
_check_pointer_wheel_cb(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 2);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 1);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_WHEEL );
*called = EINA_TRUE;
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_wheel)
{
Efl_Ui_Win *win;
Eina_Bool pointer_wheel = EINA_FALSE;
Efl_Canvas_Object *rect;
create_environment(&win, &rect);
efl_event_callback_add(rect, EFL_EVENT_POINTER_WHEEL, _check_pointer_wheel_cb, &pointer_wheel);
evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP, NULL);
evas_event_feed_mouse_wheel(evas_object_evas_get(win), 1, 2, TIMESTAMP, NULL);
ck_assert_int_eq(pointer_wheel, EINA_TRUE);
}
EFL_END_TEST
static void
_check_ptr_cancel_down_event(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_DOWN);
*called = EINA_TRUE;
}
static void
_check_ptr_cancel_event(void *data, const Efl_Event *ev)
{
int *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_CANCEL );
ck_assert_int_eq(*called, 0);
*called = 1;
}
static void
_check_ptr_cancel_up_event(void *data, const Efl_Event *ev)
{
Eina_Bool *called = data;
ck_assert_int_eq(efl_input_timestamp_get(ev->info), TIMESTAMP);
ck_assert_int_eq(efl_input_pointer_wheel_delta_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_wheel_horizontal_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_double_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_triple_click_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_button_flags_get(ev->info), 0);
ck_assert_int_eq(efl_input_pointer_touch_id_get(ev->info), 0);
position_eq(efl_input_pointer_position_get(ev->info), EINA_POSITION2D(20, 20));
ck_assert_int_eq(efl_input_pointer_button_get(ev->info), 1);
ck_assert_int_eq(efl_input_pointer_action_get(ev->info), EFL_POINTER_ACTION_UP);
ck_assert_int_eq(*called, 1);
*called = 2;
}
EFL_START_TEST(efl_ui_win_test_efl_input_interface_pointer_cancel)
{
Efl_Ui_Win *win;
Eina_Bool called_down = EINA_FALSE;
int called;
Efl_Canvas_Object *rect;
create_environment(&win, &rect);
evas_event_feed_mouse_move(evas_object_evas_get(win), 20, 20, TIMESTAMP - 1, NULL);
efl_event_callback_add(rect, EFL_EVENT_POINTER_DOWN, _check_ptr_cancel_down_event, &called_down);
evas_event_feed_mouse_down(evas_object_evas_get(win), 1, 0, TIMESTAMP, NULL);
ck_assert_int_eq(called_down, EINA_TRUE);
called = EINA_FALSE;
efl_event_callback_add(rect, EFL_EVENT_POINTER_CANCEL, _check_ptr_cancel_event, &called);
efl_event_callback_add(rect, EFL_EVENT_POINTER_UP, _check_ptr_cancel_up_event, &called);
evas_event_feed_mouse_cancel(evas_object_evas_get(win), TIMESTAMP, NULL);
ck_assert_int_eq(called, 2);
}
EFL_END_TEST
void
efl_ui_test_win(TCase *tc)
{
tcase_add_test(tc, efl_ui_win_test_scene_focus);
tcase_add_test(tc, efl_ui_win_test_object_focus);
tcase_add_test(tc, efl_ui_win_test_object_focus);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_focus);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_key_down);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_move);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_down);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_up);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_in_out);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_wheel);
tcase_add_test(tc, efl_ui_win_test_efl_input_interface_pointer_cancel);
}

29
src/tests/elementary/elm_test_entry.c
View File

@ -400,29 +400,14 @@ end_test()
return EINA_FALSE;
}
static void
mag_job(void *e)
{
evas_event_feed_mouse_out(e, 0, NULL);
evas_event_feed_mouse_in(e, 0, NULL);
evas_event_feed_mouse_move(e, 200, 100, 0, NULL);
evas_event_feed_mouse_down(e, 1, 0, 0, NULL);
real_timer_add(elm_config_longpress_timeout_get() + 0.1, end_test, NULL);
}
static void
norendered(void *data EINA_UNUSED, Evas *e, void *event_info EINA_UNUSED)
{
ecore_job_add(mag_job, e);
evas_event_callback_del(e, EVAS_CALLBACK_RENDER_POST, norendered);
}
EFL_START_TEST(elm_entry_magnifier)
{
Evas_Object *win, *entry;
Evas *e;
char buf[4096];
win = win_add_focused(NULL, "entry", ELM_WIN_BASIC);
e = evas_object_evas_get(win);
evas_object_size_hint_weight_set(win, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
entry = elm_entry_add(win);
@ -466,9 +451,13 @@ EFL_START_TEST(elm_entry_magnifier)
evas_object_show(win);
evas_object_resize(entry, 600, 400);
evas_object_resize(win, 600, 400);
evas_smart_objects_calculate(evas_object_evas_get(win));
evas_event_callback_add(evas_object_evas_get(win), EVAS_CALLBACK_RENDER_POST, norendered, NULL);
ecore_main_loop_begin();
get_me_to_those_events(e);
evas_event_feed_mouse_out(e, 0, NULL);
evas_event_feed_mouse_in(e, 0, NULL);
evas_event_feed_mouse_move(e, 200, 100, 0, NULL);
evas_event_feed_mouse_down(e, 1, 0, 0, NULL);
real_timer_add(elm_config_longpress_timeout_get() + 0.1, end_test, NULL);
}
EFL_END_TEST

87
src/tests/elementary/elm_test_slider.c
View File

@ -41,35 +41,13 @@ EFL_START_TEST(elm_atspi_role_get)
}
EFL_END_TEST
static Evas_Object *fslider, *scroller;
static void
mag_job(void *e)
{
int x, y, w, h;
ck_assert_int_eq(elm_object_scroll_hold_get(scroller), 0);
evas_event_feed_mouse_in(e, 0, NULL);
evas_object_geometry_get(fslider, &x, &y, &w, &h);
evas_event_feed_mouse_move(e, x+w/2, y+h/2, 0, NULL);
//ensure that the scroller is on hold
ck_assert_int_eq(elm_object_scroll_hold_get(scroller), 1);
evas_event_feed_mouse_move(e, x+w+w/2, y+h+h/2, 0, NULL);
ck_assert_int_eq(elm_object_scroll_hold_get(scroller), 0);
ecore_main_loop_quit();
}
static void
norendered(void *data EINA_UNUSED, Evas *e, void *event_info EINA_UNUSED)
{
ecore_job_add(mag_job, e);
evas_event_callback_del(e, EVAS_CALLBACK_RENDER_POST, norendered);
}
EFL_START_TEST(elm_slider_in_scroller)
{
Evas_Object *win, *slider, *box;
Evas_Object *win, *slider, *box, *scroller, *fslider;
Evas *e;
win = win_add(NULL, "slider", ELM_WIN_BASIC);
e = evas_object_evas_get(win);
evas_object_size_hint_weight_set(win, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
scroller = elm_scroller_add(win);
@ -96,11 +74,18 @@ EFL_START_TEST(elm_slider_in_scroller)
evas_object_resize(win, 100, 100);
evas_object_show(win);
evas_smart_objects_calculate(evas_object_evas_get(win));
evas_event_callback_add(evas_object_evas_get(win), EVAS_CALLBACK_RENDER_POST, norendered, NULL);
get_me_to_those_events(scroller);
elm_run();
int x, y, w, h;
ck_assert_int_eq(elm_object_scroll_hold_get(scroller), 0);
evas_event_feed_mouse_in(e, 0, NULL);
evas_object_geometry_get(fslider, &x, &y, &w, &h);
evas_event_feed_mouse_move(e, x+w/2, y+h/2, 0, NULL);
//ensure that the scroller is on hold
ck_assert_int_eq(elm_object_scroll_hold_get(scroller), 1);
evas_event_feed_mouse_move(e, x+w+w/2, y+h+h/2, 0, NULL);
ck_assert_int_eq(elm_object_scroll_hold_get(scroller), 0);
}
EFL_END_TEST
@ -110,38 +95,19 @@ static void
slider_changed(void *data EINA_UNUSED, Evas_Object *obj, void *event_info EINA_UNUSED)
{
event_counter++;
if (event_counter == 2) ecore_main_loop_quit();
else evas_object_smart_callback_del(obj, "changed", slider_changed);
}
static void
slider_change(void *data)
{
int x, y, w, h;
int sx, sy, sw, sh;
Evas *e = evas_object_evas_get(data);
evas_object_geometry_get(elm_object_part_content_get(data, "elm.swallow.bar"), &x, &y, &w, &h);
evas_object_geometry_get(data, &sx, &sy, &sw, &sh);
evas_event_feed_mouse_in(e, 0, NULL);
evas_event_feed_mouse_move(e, x + (w / 2), y + (h / 2), 0, NULL);
evas_event_feed_mouse_down(e, 1, 0, 0, NULL);
evas_event_feed_mouse_move(e, sx + (sw / 2), sy + (sh / 2), 0, NULL);
evas_event_feed_mouse_up(e, 1, 0, 0, NULL);
}
static void
events_norendered(void *data, Evas *e, void *event_info EINA_UNUSED)
{
evas_event_callback_del(e, EVAS_CALLBACK_RENDER_POST, norendered);
ecore_job_add(slider_change, data);
if (event_counter == 1)
evas_object_smart_callback_del(obj, "changed", slider_changed);
else if (event_counter == 2)
ecore_main_loop_quit();
}
EFL_START_TEST(elm_slider_events)
{
Evas_Object *win, *slider;
Evas *e;
win = win_add(NULL, "slider", ELM_WIN_BASIC);
e = evas_object_evas_get(win);
slider = elm_slider_add(win);
evas_object_smart_callback_add(slider, "changed", slider_changed, NULL);
@ -151,8 +117,19 @@ EFL_START_TEST(elm_slider_events)
evas_object_resize(slider, 400, 100);
evas_object_resize(win, 400, 100);
edje_object_message_signal_process(elm_layout_edje_get(slider));
evas_smart_objects_calculate(evas_object_evas_get(win));
evas_event_callback_add(evas_object_evas_get(win), EVAS_CALLBACK_RENDER_POST, events_norendered, slider);
get_me_to_those_events(slider);
int x, y, w, h;
int sx, sy, sw, sh;
evas_object_geometry_get(elm_object_part_content_get(slider, "elm.swallow.bar"), &x, &y, &w, &h);
evas_object_geometry_get(slider, &sx, &sy, &sw, &sh);
evas_event_feed_mouse_in(e, 0, NULL);
evas_event_feed_mouse_move(e, x + (w / 2), y + (h / 2), 0, NULL);
evas_event_feed_mouse_down(e, 1, 0, 0, NULL);
evas_event_feed_mouse_move(e, sx + (sw / 2), sy + (sh / 2), 0, NULL);
evas_event_feed_mouse_up(e, 1, 0, 0, NULL);
ecore_main_loop_begin();
ck_assert_int_eq(event_counter, 2);
}

25
src/tests/elementary/suite_helpers.c
View File

@ -358,3 +358,28 @@ fail_on_errors_setup(void)
eina_log_abort_on_critical_level_set(2);
eina_log_abort_on_critical_set(1);
}
static void
next_event_job()
{
ecore_main_loop_quit();
}
static void
events_norendered(void *data EINA_UNUSED, Evas *e, void *event_info EINA_UNUSED)
{
evas_event_callback_del(e, EVAS_CALLBACK_RENDER_POST, events_norendered);
ecore_job_add(next_event_job, NULL);
}
void
get_me_to_those_events(Eo *obj)
{
Evas *e = obj;
if (!efl_isa(obj, EFL_CANVAS_SCENE_INTERFACE))
e = evas_object_evas_get(obj);
evas_smart_objects_calculate(e);
evas_event_callback_add(e, EVAS_CALLBACK_RENDER_POST, events_norendered, NULL);
ecore_main_loop_begin();
}

1
src/tests/elementary/suite_helpers.h
View File

@ -10,4 +10,5 @@ void *real_timer_add(double in, Ecore_Task_Cb cb, void *data);
void fail_on_errors_teardown(void);
void fail_on_errors_setup(void);
void get_me_to_those_events(Eo *obj);
#endif

4
src/tests/eolian/data/owning.eo
View File

@ -15,9 +15,7 @@ class Owning {
test2 {
params {
test1 : list<ptr(Test.A) @owned> @owned;
test2 : iterator<ptr(Test.A) @owned> @owned;
test3 : hash<string, ptr(Test.A) @owned> @owned;
test4 : accessor<ptr(Test.A) @owned> @owned;
test2 : hash<string, ptr(Test.A) @owned> @owned;
}
}

21
src/tests/eolian/data/owning_ref.c
View File

@ -13,32 +13,21 @@ _owning_test1_ownership_fallback(Eina_List *test1, Eina_Iterator *test2, Eina_Ha
EOAPI EFL_VOID_FUNC_BODYV_FALLBACK(owning_test1, _owning_test1_ownership_fallback(test1, test2, test3, test4);, EFL_FUNC_CALL(test1, test2, test3, test4), Eina_List *test1, Eina_Iterator *test2, Eina_Hash *test3, Eina_Accessor *test4);
void _owning_test2(Eo *obj, Owning_Data *pd, Eina_List *test1, Eina_Iterator *test2, Eina_Hash *test3, Eina_Accessor *test4);
void _owning_test2(Eo *obj, Owning_Data *pd, Eina_List *test1, Eina_Hash *test2);
static void
_owning_test2_ownership_fallback(Eina_List *test1, Eina_Iterator *test2, Eina_Hash *test3, Eina_Accessor *test4)
_owning_test2_ownership_fallback(Eina_List *test1, Eina_Hash *test2)
{
Test_A *test1_iter;
EINA_LIST_FREE(test1,test1_iter)
{
free_a(test1_iter);
}
Test_A *test2_iter;
EINA_ITERATOR_FOREACH(test2,test2_iter)
{
free_a(test2_iter);
}
eina_hash_free_cb_set(test3,NULL);
eina_hash_free(test3);
Test_A *test4_iter;
unsigned int test4_i = 0;
EINA_ACCESSOR_FOREACH(test4,test4_i,test4_iter)
{
free_a(test4_iter);
}
eina_hash_free_cb_set(test2,NULL);
eina_hash_free(test2);
}
EOAPI EFL_VOID_FUNC_BODYV_FALLBACK(owning_test2, _owning_test2_ownership_fallback(test1, test2, test3, test4);, EFL_FUNC_CALL(test1, test2, test3, test4), Eina_List *test1, Eina_Iterator *test2, Eina_Hash *test3, Eina_Accessor *test4);
EOAPI EFL_VOID_FUNC_BODYV_FALLBACK(owning_test2, _owning_test2_ownership_fallback(test1, test2);, EFL_FUNC_CALL(test1, test2), Eina_List *test1, Eina_Hash *test2);
static Eina_Bool
_owning_class_initializer(Efl_Class *klass)

1
src/tests/evas/evas_suite.c
View File

@ -10,6 +10,7 @@
static const Efl_Test_Case etc[] = {
{ "Evas", evas_test_init },
{ "Evas Focus", evas_test_focus },
{ "Evas New", evas_test_new },
{ "Object", evas_test_object },
{ "Object Textblock", evas_test_textblock },

1
src/tests/evas/evas_suite.h
View File

@ -4,6 +4,7 @@
#include <check.h>
#include "../efl_check.h"
void evas_test_init(TCase *tc);
void evas_test_focus(TCase *tc);
void evas_test_new(TCase *tc);
void evas_test_object(TCase *tc);
void evas_test_textblock(TCase *tc);

28
src/tests/evas/evas_test_focus.c Normal file
View File

@ -0,0 +1,28 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <Evas.h>
#include "evas_suite.h"
EFL_START_TEST(evas_focus)
{
Evas *evas = evas_new();
evas_output_method_set(evas, evas_render_method_lookup("buffer"));
evas_focus_in(evas);
ck_assert_int_eq(evas_focus_state_get(evas), EINA_TRUE);
evas_focus_out(evas);
ck_assert_int_eq(evas_focus_state_get(evas), EINA_FALSE);
evas_focus_out(evas);
ck_assert_int_eq(evas_focus_state_get(evas), EINA_FALSE);
}
EFL_END_TEST
void evas_test_focus(TCase *tc)
{
tcase_add_test(tc, evas_focus);
}

1
src/tests/evas/meson.build
View File

@ -14,6 +14,7 @@ evas_suite_src = [
'evas_test_mask.c',
'evas_test_evasgl.c',
'evas_test_matrix.c',
'evas_test_focus.c',
'evas_tests_helpers.h',
'evas_suite.h'
]