diff options
Diffstat (limited to 'src/tests/elementary')
48 files changed, 3242 insertions, 126 deletions
diff --git a/src/tests/elementary/custom_gesture.c b/src/tests/elementary/custom_gesture.c new file mode 100644 index 0000000000..629f68bcd5 --- /dev/null +++ b/src/tests/elementary/custom_gesture.c @@ -0,0 +1,19 @@ +#include <Efl_Ui.h> +#include "custom_gesture.eo.h" +#include "custom_gesture.h" +#define MY_CLASS CUSTOM_GESTURE_CLASS + + +EOLIAN static int +_custom_gesture_x_delta_get(const Eo *obj EINA_UNUSED, Custom_Gesture_Data *pd) +{ + return pd->x_delta; +} + +EOLIAN static int +_custom_gesture_y_delta_get(const Eo *obj EINA_UNUSED, Custom_Gesture_Data *pd) +{ + return pd->y_delta; +} + +#include "custom_gesture.eo.c" diff --git a/src/tests/elementary/custom_gesture.eo b/src/tests/elementary/custom_gesture.eo new file mode 100644 index 0000000000..7a6266db93 --- /dev/null +++ b/src/tests/elementary/custom_gesture.eo @@ -0,0 +1,26 @@ +import eina_types; +parse efl_canvas_gesture_recognizer; + +class @beta Custom_Gesture extends Efl.Canvas.Gesture_Custom +{ + [[This is a test class for custom gesture implementations. + ]] + methods { + @property x_delta { + [[This is the total change in the X coordinate.]] + get { + } + values { + val: int; [[The change since the start of the gesture.]] + } + } + @property y_delta { + [[This is the total change in the Y coordinate.]] + get { + } + values { + val: int; [[The change since the start of the gesture.]] + } + } + } +} diff --git a/src/tests/elementary/custom_gesture.h b/src/tests/elementary/custom_gesture.h new file mode 100644 index 0000000000..fa12b68593 --- /dev/null +++ b/src/tests/elementary/custom_gesture.h @@ -0,0 +1,16 @@ +#ifndef CUSTOM_GESTURE_H +# define CUSTOM_GESTURE_H + + +typedef struct Custom_Gesture_Data +{ + int x_delta; + int y_delta; +} Custom_Gesture_Data; + + + + + + +#endif diff --git a/src/tests/elementary/custom_recognizer.c b/src/tests/elementary/custom_recognizer.c new file mode 100644 index 0000000000..4797b9530e --- /dev/null +++ b/src/tests/elementary/custom_recognizer.c @@ -0,0 +1,56 @@ +#include <Efl_Ui.h> +#include "custom_recognizer.eo.h" +#include "custom_gesture.eo.h" +#include "custom_gesture.h" + +#define MY_CLASS CUSTOM_RECOGNIZER_CLASS + +typedef struct Custom_Recognizer_Data +{ + +} Custom_Recognizer_Data; + +EOLIAN static const Efl_Class * +_custom_recognizer_efl_canvas_gesture_recognizer_type_get(const Eo *obj EINA_UNUSED, Custom_Recognizer_Data *pd EINA_UNUSED) +{ + return CUSTOM_GESTURE_CLASS; +} + +EOLIAN static Eo * +_custom_recognizer_efl_object_finalize(Eo *obj, Custom_Recognizer_Data *pd EINA_UNUSED) +{ + efl_gesture_recognizer_custom_gesture_name_set(obj, "custom_gesture"); + return efl_finalize(efl_super(obj, MY_CLASS)); +} + +EOLIAN static Efl_Canvas_Gesture_Recognizer_Result +_custom_recognizer_efl_canvas_gesture_recognizer_recognize(Eo *obj EINA_UNUSED, Custom_Recognizer_Data *pd EINA_UNUSED, + Efl_Canvas_Gesture *gesture, Efl_Object *watched EINA_UNUSED, + Efl_Canvas_Gesture_Touch *event) +{ + const Efl_Gesture_Touch_Point_Data *data = efl_gesture_touch_current_data_get(event); + Custom_Gesture_Data *gd; + + /* ignore multi-touch */ + if (data->id) return EFL_GESTURE_RECOGNIZER_RESULT_IGNORE; + + switch (efl_gesture_touch_state_get(event)) + { + case EFL_GESTURE_TOUCH_STATE_BEGIN: + return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER; + case EFL_GESTURE_TOUCH_STATE_UPDATE: + gd = efl_data_scope_get(gesture, CUSTOM_GESTURE_CLASS); + gd->x_delta += data->cur.pos.x - data->prev.pos.x; + gd->y_delta += data->cur.pos.y - data->prev.pos.y; + return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER; + case EFL_GESTURE_TOUCH_STATE_END: + return EFL_GESTURE_RECOGNIZER_RESULT_FINISH; + default: + + break; + } + + return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL; +} + +#include "custom_recognizer.eo.c" diff --git a/src/tests/elementary/custom_recognizer.eo b/src/tests/elementary/custom_recognizer.eo new file mode 100644 index 0000000000..bbe4c0cfc6 --- /dev/null +++ b/src/tests/elementary/custom_recognizer.eo @@ -0,0 +1,11 @@ +class @beta Custom_Recognizer extends Efl.Canvas.Gesture_Recognizer_Custom +{ + [[Custom gesture recognizer test class. + ]] + c_prefix: custom_recognizer; + implements { + Efl.Object.finalize; + Efl.Canvas.Gesture_Recognizer.recognize; + Efl.Canvas.Gesture_Recognizer.type { get; } + } +} diff --git a/src/tests/elementary/custom_recognizer2.c b/src/tests/elementary/custom_recognizer2.c new file mode 100644 index 0000000000..3b8995058a --- /dev/null +++ b/src/tests/elementary/custom_recognizer2.c @@ -0,0 +1,41 @@ +#include <Efl_Ui.h> +#include "custom_recognizer2.eo.h" +#define MY_CLASS CUSTOM_RECOGNIZER2_CLASS + +typedef struct Custom_Recognizer2_Data +{ +} Custom_Recognizer2_Data; + +EOLIAN static Eo * +_custom_recognizer2_efl_object_finalize(Eo *obj, Custom_Recognizer2_Data *pd EINA_UNUSED) +{ + efl_gesture_recognizer_custom_gesture_name_set(obj, "custom_gesture2"); + return efl_finalize(efl_super(obj, MY_CLASS)); +} + +EOLIAN static Efl_Canvas_Gesture_Recognizer_Result +_custom_recognizer2_efl_canvas_gesture_recognizer_recognize(Eo *obj EINA_UNUSED, Custom_Recognizer2_Data *pd EINA_UNUSED, + Efl_Canvas_Gesture *gesture EINA_UNUSED, Efl_Object *watched EINA_UNUSED, + Efl_Canvas_Gesture_Touch *event) +{ + Eina_Position2D start = efl_gesture_touch_start_point_get(event); + Eina_Position2D cur = efl_gesture_touch_current_point_get(event); + switch (efl_gesture_touch_state_get(event)) + { + case EFL_GESTURE_TOUCH_STATE_BEGIN: + return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER; + case EFL_GESTURE_TOUCH_STATE_UPDATE: + if (EINA_POSITION2D_EQ(start, cur)) + return EFL_GESTURE_RECOGNIZER_RESULT_TRIGGER; + if ((cur.x - start.x == 1) && (cur.y == start.y)) + return EFL_GESTURE_RECOGNIZER_RESULT_FINISH; + case EFL_GESTURE_TOUCH_STATE_END: + default: + + break; + } + + return EFL_GESTURE_RECOGNIZER_RESULT_CANCEL; +} + +#include "custom_recognizer2.eo.c" diff --git a/src/tests/elementary/custom_recognizer2.eo b/src/tests/elementary/custom_recognizer2.eo new file mode 100644 index 0000000000..35c97d9d61 --- /dev/null +++ b/src/tests/elementary/custom_recognizer2.eo @@ -0,0 +1,10 @@ +class @beta Custom_Recognizer2 extends Efl.Canvas.Gesture_Recognizer_Custom +{ + [[Custom gesture recognizer test class. + ]] + c_prefix: custom_recognizer2; + implements { + Efl.Object.finalize; + Efl.Canvas.Gesture_Recognizer.recognize; + } +} diff --git a/src/tests/elementary/efl_ui_suite.c b/src/tests/elementary/efl_ui_suite.c index 9234d68a2f..cfe45f4cf7 100644 --- a/src/tests/elementary/efl_ui_suite.c +++ b/src/tests/elementary/efl_ui_suite.c @@ -14,6 +14,7 @@ static const Efl_Test_Case etc[] = { { "efl_ui_config", efl_ui_test_config}, { "efl_ui_focus", efl_ui_test_focus}, { "efl_ui_focus_sub", efl_ui_test_focus_sub}, + { "efl_ui_gesture", efl_ui_test_gesture}, { "efl_ui_box", efl_ui_test_box}, { "efl_ui_box_flow", efl_ui_test_box_flow}, { "efl_ui_box_stack", efl_ui_test_box_stack}, @@ -38,14 +39,18 @@ static const Efl_Test_Case etc[] = { { "efl_ui_collection", efl_ui_test_item_container }, { "efl_ui_grid_container", efl_ui_test_grid_container }, { "efl_ui_list_container", efl_ui_test_list_container }, + { "efl_ui_collection_view", efl_ui_test_collection_view }, { "efl_ui_select_model", efl_ui_test_select_model }, { "efl_ui_view_model", efl_ui_test_view_model }, { "efl_ui_group_item", efl_ui_test_group_item }, { "efl_ui_text", efl_ui_test_text}, +#ifdef BUILD_VG_LOADER_JSON + { "efl_ui_vg_animation", efl_ui_test_vg_animation}, +#endif { NULL, NULL } }; -EFL_CLASS_SIMPLE_CLASS(efl_ui_widget, "efl_ui_widget", EFL_UI_WIDGET_CLASS); +EFL_CLASS_SIMPLE_CLASS(efl_ui_widget, "Efl.Ui.Widget", EFL_UI_WIDGET_CLASS); int main(int argc, char **argv) diff --git a/src/tests/elementary/efl_ui_suite.h b/src/tests/elementary/efl_ui_suite.h index cb83a00ce7..4963b4a77c 100644 --- a/src/tests/elementary/efl_ui_suite.h +++ b/src/tests/elementary/efl_ui_suite.h @@ -33,6 +33,7 @@ void efl_ui_test_image(TCase *tc); void efl_ui_test_callback(TCase *tc); void efl_ui_test_focus(TCase *tc); void efl_ui_test_focus_sub(TCase *tc); +void efl_ui_test_gesture(TCase *tc); void efl_ui_model(TCase *tc); void efl_ui_test_widget(TCase *tc); void efl_ui_test_spotlight(TCase *tc); @@ -46,6 +47,7 @@ void efl_ui_test_spin_button(TCase *tc); void efl_ui_test_item_container(TCase *tc); void efl_ui_test_list_container(TCase *tc); void efl_ui_test_grid_container(TCase *tc); +void efl_ui_test_collection_view(TCase *tc); void efl_ui_test_config(TCase *tc); void efl_ui_test_popup(TCase *tc); void efl_ui_test_scroller(TCase *tc); @@ -53,6 +55,7 @@ void efl_ui_test_select_model(TCase *tc); void efl_ui_test_view_model(TCase *tc); void efl_ui_test_group_item(TCase *tc); void efl_ui_test_text(TCase *tc); +void efl_ui_test_vg_animation(TCase *tc); void loop_timer_interval_set(Eo *obj, double in); diff --git a/src/tests/elementary/efl_ui_test_collection_view.c b/src/tests/elementary/efl_ui_test_collection_view.c new file mode 100644 index 0000000000..9e9f91b48e --- /dev/null +++ b/src/tests/elementary/efl_ui_test_collection_view.c @@ -0,0 +1,156 @@ +#ifdef HAVE_CONFIG_H +# include "elementary_config.h" +#endif + +#include <Efl_Ui.h> +#include "efl_ui_suite.h" + +#define NUM_ITEMS 50 + +static Efl_Model* +_make_model(Efl_Ui_Win *win) +{ + Eina_Value vi; + Efl_Generic_Model *model, *child; + unsigned int i; + + model = efl_add(EFL_GENERIC_MODEL_CLASS, win); + model = efl_add(EFL_UI_VIEW_MODEL_CLASS, model, + efl_ui_view_model_set(efl_added, model)); + eina_value_setup(&vi, EINA_VALUE_TYPE_INT); + + efl_ui_view_model_property_string_add(model, "relative", "Relative index ${child.index}", "WRONG", "WRONG"); + efl_ui_view_model_property_string_add(model, "title", "Initial index ${initial}", "WRONG", "WRONG"); + + + for (i = 0; i < (NUM_ITEMS); i++) + { + child = efl_model_child_add(model); + eina_value_set(&vi, i); + efl_model_property_set(child, "initial", &vi); + } + + eina_value_flush(&vi); + return model; +} + +static Eina_Value +_quit(Eo *obj, void *data EINA_UNUSED, const Eina_Value v) +{ + efl_loop_quit(efl_loop_get(obj), v); + return v; +} + +static Eina_Value +_children_get(Eo *obj EINA_UNUSED, void *data EINA_UNUSED, const Eina_Value v) +{ + Efl_Model *child; + unsigned int i, len; + + EINA_VALUE_ARRAY_FOREACH(&v, len, i, child) + { + Eina_Value *rel_val, *title_val; + char *relative, *title; + if (i != 5) continue; + rel_val = efl_model_property_get(child, "relative"); + title_val = efl_model_property_get(child, "title"); + relative = eina_value_to_string(rel_val); + title = eina_value_to_string(title_val); + + ck_assert(eina_streq(relative, "Relative index 5")); + ck_assert(eina_streq(title, "Initial index 5")); + free(relative); + free(title); + break; + } + return EINA_VALUE_EMPTY; +} + +EFL_START_TEST(test_efl_ui_collection_view_basic) +{ + Efl_Ui_Win *win; + Efl_Model *model; + Efl_Ui_List_View *lv; + Efl_Ui_Factory *fl; + Eina_Future *f; + int count_realize = 0; + int count_unrealize = 0; + + win = win_add(); + efl_gfx_entity_size_set(win, EINA_SIZE2D(100, 100)); + + model = _make_model(win); + fl = efl_add(EFL_UI_LAYOUT_FACTORY_CLASS, win, + efl_ui_property_bind(efl_added, "text", "title"), + efl_ui_widget_factory_item_class_set(efl_added, EFL_UI_LIST_DEFAULT_ITEM_CLASS)); + + lv = efl_add(EFL_UI_LIST_VIEW_CLASS, win, + efl_ui_collection_view_factory_set(efl_added, fl), + efl_ui_view_model_set(efl_added, model), + efl_event_callback_add(efl_added, EFL_UI_COLLECTION_VIEW_EVENT_ITEM_REALIZED, + (void*)event_callback_that_increments_an_int_when_called, &count_realize), + efl_event_callback_add(efl_added, EFL_UI_COLLECTION_VIEW_EVENT_ITEM_UNREALIZED, + (void*)event_callback_that_increments_an_int_when_called, &count_unrealize) + ); + efl_content_set(win, lv); + + get_me_to_those_events(lv); + ck_assert_int_gt(count_realize, 0); + /* FIXME: this should eventually be eq(0) */ + ck_assert_int_gt(count_unrealize, 0); + + f = efl_model_children_slice_get(lv, 0, efl_model_children_count_get(lv)); + f = efl_future_then(lv, f, .success_type = EINA_VALUE_TYPE_ARRAY, .success = _children_get); + ecore_main_loop_iterate(); + efl_event_callback_del(lv, EFL_UI_COLLECTION_VIEW_EVENT_ITEM_REALIZED, (void*)event_callback_that_increments_an_int_when_called, &count_realize); + efl_event_callback_del(lv, EFL_UI_COLLECTION_VIEW_EVENT_ITEM_UNREALIZED, (void*)event_callback_that_increments_an_int_when_called, &count_unrealize); +} +EFL_END_TEST + +EFL_START_TEST(test_efl_ui_collection_view_select) +{ + Efl_Ui_Win *win; + Efl_Model *model; + Efl_Ui_List_View *lv; + Efl_Ui_Factory *fl; + Eina_Value *sel_val; + unsigned long sel = 10000; + + win = win_add(); + efl_gfx_entity_size_set(win, EINA_SIZE2D(100, 100)); + + model = _make_model(win); + model = efl_add(EFL_UI_SELECT_MODEL_CLASS, efl_main_loop_get(), efl_ui_view_model_set(efl_added, model)); + fl = efl_add(EFL_UI_LAYOUT_FACTORY_CLASS, win, + efl_ui_property_bind(efl_added, "text", "title"), + efl_ui_widget_factory_item_class_set(efl_added, EFL_UI_LIST_DEFAULT_ITEM_CLASS)); + + lv = efl_add(EFL_UI_LIST_VIEW_CLASS, win, + efl_ui_collection_view_factory_set(efl_added, fl), + efl_ui_view_model_set(efl_added, model) + ); + efl_content_set(win, lv); + + get_me_to_those_events(lv); + + /* nothing selected yet */ + sel_val = efl_model_property_get(model, "child.selected"); + ck_assert(eina_value_type_get(sel_val) == EINA_VALUE_TYPE_ERROR); + + efl_future_then(model, efl_model_property_ready_get(model, "child.selected"), .success = _quit); + + click_object_at(lv, 50, 5); + ecore_main_loop_begin(); + + sel_val = efl_model_property_get(model, "child.selected"); + ck_assert(eina_value_type_get(sel_val) == EINA_VALUE_TYPE_ULONG); + ck_assert(eina_value_ulong_get(sel_val, &sel)); + ck_assert_int_eq(sel, 0); +} +EFL_END_TEST + +void efl_ui_test_collection_view(TCase *tc) +{ + tcase_add_test(tc, test_efl_ui_collection_view_basic); + tcase_add_test(tc, test_efl_ui_collection_view_select); +} diff --git a/src/tests/elementary/efl_ui_test_config.c b/src/tests/elementary/efl_ui_test_config.c index a9f31ea988..df3a3356d9 100644 --- a/src/tests/elementary/efl_ui_test_config.c +++ b/src/tests/elementary/efl_ui_test_config.c @@ -25,7 +25,15 @@ EFL_START_TEST(efl_config_eoapi) #define CONFIG_CHKB(opt, val) CONFIG_CHK(opt, bool, val) #define CONFIG_CHKI(opt, val) CONFIG_CHK(opt, int, val) -#define CONFIG_CHKD(opt, val) CONFIG_CHK(opt, double, val) + +#define CONFIG_CHKD_internal(opt, typ, val) do { \ + typ old = elm_config_ ## opt ## _get(); \ + fail_if(!EINA_DBL_EQ(old, efl_config_ ## typ ## _get(cfg, #opt))); \ + fail_if(!efl_config_ ## typ ## _set(cfg, #opt, val)); \ + fail_if(!EINA_DBL_EQ(elm_config_ ## opt ## _get(), val)); \ + fail_if(!EINA_DBL_EQ(efl_config_ ## typ ## _get(cfg, #opt), val)); \ + } while (0) +#define CONFIG_CHKD(opt, val) CONFIG_CHKD_internal(opt, double, val) // note: leaks badly #define CONFIG_CHKS(opt, val) do { \ @@ -67,9 +75,9 @@ EFL_START_TEST(efl_config_eoapi) CONFIG_CHKD(scroll_thumbscroll_acceleration_threshold, 0); CONFIG_CHKD(scroll_thumbscroll_acceleration_time_limit, 0); CONFIG_CHKD(scroll_thumbscroll_acceleration_weight, 0); - CONFIG_CHKE(focus_autoscroll_mode, EFL_UI_FOCUS_AUTOSCROLL_MODE_NONE, "none"); + CONFIG_CHKE(focus_autoscroll_mode, ELM_FOCUS_AUTOSCROLL_MODE_NONE, "none"); CONFIG_CHKD(longpress_timeout, 0); - CONFIG_CHKE(softcursor_mode, EFL_UI_SOFTCURSOR_MODE_ON, "on"); + CONFIG_CHKE(softcursor_mode, ELM_SOFTCURSOR_MODE_ON, "on"); CONFIG_CHKD(tooltip_delay, 0); CONFIG_CHKB(cursor_engine_only, 0); CONFIG_CHKD(scale, 0); @@ -95,7 +103,7 @@ EFL_START_TEST(efl_config_eoapi) CONFIG_CHKB(focus_highlight_enabled, !old); CONFIG_CHKB(focus_highlight_animate, 0); CONFIG_CHKB(focus_highlight_clip_disabled, !old); - CONFIG_CHKE(focus_move_policy, EFL_UI_FOCUS_MOVE_POLICY_MOVE_IN, "in"); + CONFIG_CHKE(focus_move_policy, ELM_FOCUS_MOVE_POLICY_IN, "in"); CONFIG_CHKB(item_select_on_focus_disabled, !old); CONFIG_CHKB(first_item_focus_on_first_focusin, 0); CONFIG_CHKB(mirrored, 0); @@ -134,7 +142,7 @@ EFL_START_TEST(efl_config_eoapi) Eina_Bool b = elm_config_audio_mute_get(channels[i].chan); if (b != efl_config_bool_get(cfg, channels[i].name)) fail(channels[i].name); - efl_config_bool_set(cfg, channels[i].name, !b); + fail_unless(efl_config_bool_set(cfg, channels[i].name, !b)); if(efl_config_bool_get(cfg, channels[i].name) != !b) fail(channels[i].name); if(elm_config_audio_mute_get(channels[i].chan) != !b) diff --git a/src/tests/elementary/efl_ui_test_focus.c b/src/tests/elementary/efl_ui_test_focus.c index 814ab5c690..3b66515d31 100644 --- a/src/tests/elementary/efl_ui_test_focus.c +++ b/src/tests/elementary/efl_ui_test_focus.c @@ -83,9 +83,15 @@ EFL_START_TEST(pos_check) EFL_END_TEST static Eina_Bool -_equal_set(Eina_List *elems, Efl_Ui_Focus_Object *lst[]) +_equal_set(Eina_Iterator *elems, Efl_Ui_Focus_Object *lst[]) { unsigned int i = 0; + Eina_List *tmp = NULL; + Efl_Gfx_Entity *object; + Eina_Bool r = EINA_FALSE; + + EINA_ITERATOR_FOREACH(elems, object) + tmp = eina_list_append(tmp, object); for (i = 0; lst[i]; ++i) { @@ -93,7 +99,7 @@ _equal_set(Eina_List *elems, Efl_Ui_Focus_Object *lst[]) Eina_List *n; Efl_Ui_Focus_Object *elem; - EINA_LIST_FOREACH(elems, n, elem) + EINA_LIST_FOREACH(tmp, n, elem) { if (lst[i] != elem) continue; @@ -101,11 +107,13 @@ _equal_set(Eina_List *elems, Efl_Ui_Focus_Object *lst[]) break; } - if (!found) return EINA_FALSE; + if (!found) goto end; } - if (eina_list_count(elems) != i) return EINA_FALSE; - return EINA_TRUE; + if (eina_list_count(tmp) == i) r = EINA_TRUE; + end: + eina_list_free(tmp); + return r; } EFL_START_TEST(pos_check2) diff --git a/src/tests/elementary/efl_ui_test_focus_common.h b/src/tests/elementary/efl_ui_test_focus_common.h index ceda6a0074..bf6cf44cb0 100644 --- a/src/tests/elementary/efl_ui_test_focus_common.h +++ b/src/tests/elementary/efl_ui_test_focus_common.h @@ -16,6 +16,8 @@ Efl_Ui_Focus_Object* name; \ name = focus_test_object_new("" #name "",x, y, w, h); \ +/* This is an internal function at the moment, but an exported symbol and can be used by tests */ +Eina_Bool efl_ui_focus_manager_calc_update_children(Eo *obj, Efl_Ui_Focus_Object *parent, Eina_List *children EFL_TRANSFER_OWNERSHIP); Efl_Ui_Focus_Object* focus_test_object_new(const char *name, int x, int y, int w, int h); diff --git a/src/tests/elementary/efl_ui_test_gesture.c b/src/tests/elementary/efl_ui_test_gesture.c new file mode 100644 index 0000000000..0805cd82ee --- /dev/null +++ b/src/tests/elementary/efl_ui_test_gesture.c @@ -0,0 +1,769 @@ +#ifdef HAVE_CONFIG_H +# include "elementary_config.h" +#endif + +#include <Efl_Ui.h> +#include "efl_ui_suite.h" +/* mouse feeding */ +#include <Evas_Legacy.h> +#include <evas_canvas_eo.h> + +#include "custom_gesture.eo.h" +#include "custom_recognizer.eo.h" +#include "custom_recognizer2.eo.h" + +/* +typedef enum +{ + EFL_GESTURE_STATE_NONE = 0, + EFL_GESTURE_STATE_STARTED = 1, + EFL_GESTURE_STATE_UPDATED, + EFL_GESTURE_STATE_FINISHED, + EFL_GESTURE_STATE_CANCELED +} Efl_Canvas_Gesture_State; +*/ + +enum +{ + TAP, + LONG_PRESS, + DOUBLE_TAP, + TRIPLE_TAP, + MOMENTUM, + FLICK, + ROTATE, + ZOOM, + CUSTOM, + CUSTOM2, + LAST +}; + +static int count[LAST][4] = {0}; + +/* macros to simplify checking gesture counts */ +#define CHECK_START(type, val) \ + ck_assert_int_eq(count[(type)][EFL_GESTURE_STATE_STARTED - 1], (val)) +#define CHECK_UPDATE(type, val) \ + ck_assert_int_eq(count[(type)][EFL_GESTURE_STATE_UPDATED - 1], (val)) +#define CHECK_FINISH(type, val) \ + ck_assert_int_eq(count[(type)][EFL_GESTURE_STATE_FINISHED - 1], (val)) +#define CHECK_CANCEL(type, val) \ + ck_assert_int_eq(count[(type)][EFL_GESTURE_STATE_CANCELED - 1], (val)) +#define CHECK_ALL(type, ...) \ + do {\ + int state_vals[] = {__VA_ARGS__}; \ + for (int i = 0; i < 4; i++) \ + ck_assert_int_eq(count[(type)][i], state_vals[i]); \ + } while (0) +#define CHECK_NONZERO(type) \ + do {\ + for (int i = 0; i < 4; i++) \ + ck_assert_int_ne(count[(type)][i], 0); \ + } while (0) +#define CHECK_ZERO(type) CHECK_ALL((type), 0, 0, 0, 0) +#define RESET memset(count, 0, sizeof(count)) + +static void +gesture_cb(void *data , const Efl_Event *ev) +{ + Efl_Canvas_Gesture *g = ev->info; + int *count = data; + /* increment counter for event state which has been processed */ + count[efl_gesture_state_get(g) - 1]++; +} + +static Eo * +setup(void) +{ + Eo *win, *rect; + + RESET; + + win = win_add(); + efl_gfx_entity_size_set(win, EINA_SIZE2D(1000, 1000)); + + rect = efl_add(EFL_CANVAS_RECTANGLE_CLASS, win); + efl_content_set(win, rect); + +#define WATCH(type) \ + efl_event_callback_add(rect, EFL_EVENT_GESTURE_##type, gesture_cb, &count[(type)]) + WATCH(TAP); + WATCH(LONG_PRESS); + WATCH(DOUBLE_TAP); + WATCH(TRIPLE_TAP); + WATCH(MOMENTUM); + WATCH(FLICK); + WATCH(ROTATE); + WATCH(ZOOM); + + get_me_to_those_events(win); + return rect; +} + +EFL_START_TEST(test_efl_ui_gesture_taps) +{ + Eo *rect = setup(); + + /* basic tap */ + click_object(rect); + CHECK_ALL(TAP, 1, 0, 1, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + CHECK_ALL(DOUBLE_TAP, 1, 1, 0, 0); + CHECK_ALL(TRIPLE_TAP, 1, 1, 0, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* add a second tap */ + click_object(rect); + CHECK_ALL(TAP, 1, 0, 1, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* UPDATE -> FINISH */ + CHECK_ALL(DOUBLE_TAP, 0, 1, 1, 0); + CHECK_ALL(TRIPLE_TAP, 0, 2, 0, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* add a third tap */ + click_object(rect); + CHECK_ALL(TAP, 1, 0, 1, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* UPDATE -> FINISH */ + CHECK_ALL(DOUBLE_TAP, 1, 1, 0, 0); + CHECK_ALL(TRIPLE_TAP, 0, 1, 1, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + /* clear states */ + wait_timer(0.4); + RESET; + + /* verify finger size */ + click_object_at(rect, 500, 500); + click_object_at(rect, 505, 505); + CHECK_ALL(TAP, 2, 0, 2, 0); + CHECK_ALL(LONG_PRESS, 2, 0, 0, 2); + /* UPDATE -> FINISH */ + CHECK_ALL(DOUBLE_TAP, 1, 2, 1, 0); + CHECK_ALL(TRIPLE_TAP, 1, 3, 0, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + /* clear states */ + wait_timer(0.4); + RESET; + + /* verify multiple simultaneous presses treated as same press */ + multi_click_object(rect, 2); + CHECK_ALL(TAP, 1, 0, 1, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + CHECK_ALL(DOUBLE_TAP, 1, 1, 0, 0); + CHECK_ALL(TRIPLE_TAP, 1, 1, 0, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + /* this is two fingers, so we have a rotate start */ + CHECK_ALL(ROTATE, 1, 0, 0, 1); + /* this is two fingers, so we have a zoom start */ + CHECK_ALL(ZOOM, 1, 0, 0, 1); + + RESET; + + multi_click_object(rect, 2); + CHECK_ALL(TAP, 1, 0, 1, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* UPDATE -> FINISH */ + CHECK_ALL(DOUBLE_TAP, 0, 1, 1, 0); + CHECK_ALL(TRIPLE_TAP, 0, 2, 0, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + /* this is two fingers, so we have a rotate start */ + CHECK_ALL(ROTATE, 1, 0, 0, 1); + /* this is two fingers, so we have a zoom start */ + CHECK_ALL(ZOOM, 1, 0, 0, 1); + + RESET; + + multi_click_object(rect, 2); + CHECK_ALL(TAP, 1, 0, 1, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* UPDATE -> FINISH */ + CHECK_ALL(DOUBLE_TAP, 1, 1, 0, 0); + CHECK_ALL(TRIPLE_TAP, 0, 1, 1, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + /* this is two fingers, so we have a rotate start */ + CHECK_ALL(ROTATE, 1, 0, 0, 1); + /* this is two fingers, so we have a zoom start */ + CHECK_ALL(ZOOM, 1, 0, 0, 1); + /* clear states */ + wait_timer(0.4); + RESET; + + multi_click_object(rect, 10); + CHECK_ALL(TAP, 1, 0, 1, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + /* this is two fingers, so we have a rotate start */ + CHECK_ALL(ROTATE, 1, 0, 0, 1); + /* this is two fingers, so we have a zoom start */ + CHECK_ALL(ZOOM, 1, 0, 0, 1); + RESET; + +} +EFL_END_TEST + +EFL_START_TEST(test_efl_ui_gesture_long_press) +{ + Eo *rect = setup(); + double timeout = 1.2; + Eina_Value *val; + Eo *e = efl_provider_find(rect, EVAS_CANVAS_CLASS); + + val = efl_config_get(efl_provider_find(rect, EFL_CONFIG_INTERFACE), "glayer_long_tap_start_timeout"); + eina_value_get(val, &timeout); + + /* press */ + press_object(rect); + CHECK_ALL(TAP, 1, 0, 0, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 0); + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 0); + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 0); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + wait_timer(timeout + 0.01); + + /* verify longpress */ + CHECK_ALL(TAP, 0, 0, 0, 1); + CHECK_ALL(LONG_PRESS, 0, 1, 0, 0); + CHECK_ALL(DOUBLE_TAP, 0, 0, 0, 1); + CHECK_ALL(TRIPLE_TAP, 0, 0, 0, 1); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + evas_event_feed_mouse_up(e, 1, 0, 2, NULL); + + CHECK_ZERO(TAP); + CHECK_ALL(LONG_PRESS, 0, 0, 1, 0); + CHECK_ZERO(DOUBLE_TAP); + CHECK_ZERO(TRIPLE_TAP); + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + press_object_at(rect, 0, 0); + RESET; + + /* move off-canvas */ + evas_event_feed_mouse_move(e, -1, 0, 2, NULL); + wait_timer(timeout + 0.01); + + /* verify longpress */ + CHECK_ALL(TAP, 0, 1, 0, 0); + CHECK_ALL(LONG_PRESS, 0, 1, 0, 0); + CHECK_ALL(DOUBLE_TAP, 0, 0, 0, 1); + CHECK_ALL(TRIPLE_TAP, 0, 0, 0, 1); + CHECK_ALL(MOMENTUM, 1, 0, 0, 0); + CHECK_ALL(FLICK, 1, 0, 0, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + evas_event_feed_mouse_up(e, 1, 0, 3, NULL); +} +EFL_END_TEST + +EFL_START_TEST(test_efl_ui_gesture_flick) +{ + int moves, i, single = 0; + Eo *rect = setup(); + + /* add extra random cb to verify that we get exactly 1 event */ + efl_event_callback_add(rect, EFL_EVENT_GESTURE_MOMENTUM, (void*)event_callback_that_increments_an_int_when_called, &single); + + /* basic flick */ + drag_object(rect, 0, 0, 75, 0, EINA_FALSE); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + /* updated but canceled */ + CHECK_ALL(MOMENTUM, 1, DRAG_OBJECT_NUM_MOVES - 1, 0, 1); + /* triggered */ + CHECK_ALL(FLICK, 1, DRAG_OBJECT_NUM_MOVES - 1, 1, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + efl_event_callback_del(rect, EFL_EVENT_GESTURE_MOMENTUM, (void*)event_callback_that_increments_an_int_when_called, &single); + ck_assert_int_ge(single, 0); + + /* reverse flick */ + drag_object(rect, 75, 0, -75, 0, EINA_FALSE); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + /* updated but canceled */ + CHECK_ALL(MOMENTUM, 1, DRAG_OBJECT_NUM_MOVES - 1, 0, 1); + /* triggered */ + CHECK_ALL(FLICK, 1, DRAG_OBJECT_NUM_MOVES - 1, 1, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* vertical flick */ + drag_object(rect, 0, 0, 0, 75, EINA_FALSE); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + /* updated but canceled */ + CHECK_ALL(MOMENTUM, 1, DRAG_OBJECT_NUM_MOVES - 1, 0, 1); + /* triggered */ + CHECK_ALL(FLICK, 1, DRAG_OBJECT_NUM_MOVES - 1, 1, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* reverse vertical flick */ + drag_object(rect, 0, 75, 0, -75, EINA_FALSE); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + /* updated but canceled */ + CHECK_ALL(MOMENTUM, 1, DRAG_OBJECT_NUM_MOVES - 1, 0, 1); + /* triggered */ + CHECK_ALL(FLICK, 1, DRAG_OBJECT_NUM_MOVES - 1, 1, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + + /* diagonal flick */ + drag_object(rect, 0, 0, 75, 75, EINA_FALSE); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + /* updated but canceled */ + CHECK_ALL(MOMENTUM, 1, DRAG_OBJECT_NUM_MOVES - 1, 0, 1); + /* triggered */ + CHECK_ALL(FLICK, 1, DRAG_OBJECT_NUM_MOVES - 1, 1, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* off-canvas flick */ + drag_object(rect, 999, 0, 50, 0, EINA_FALSE); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + CHECK_START(MOMENTUM, 1); + CHECK_FINISH(MOMENTUM, 0); + CHECK_CANCEL(MOMENTUM, 1); + CHECK_START(FLICK, 1); + CHECK_FINISH(FLICK, 1); + CHECK_CANCEL(FLICK, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* definitely not a flick */ + moves = drag_object_around(rect, 500, 500, 450, 180); + for (i = 0; i <= TRIPLE_TAP; i++) + { + /* canceled */ + CHECK_START(TAP, 1); + CHECK_CANCEL(TAP, 1); + } + /* completed: a momentum gesture is any completed motion */ + CHECK_ALL(MOMENTUM, 1, moves - 2, 1, 0); + /* NOT triggered; this is going to have some crazy number of update events since it ignores a bunch */ + CHECK_FINISH(FLICK, 0); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* definitely not a flick, also outside canvas */ + moves = drag_object_around(rect, 25, 50, 50, 180); + for (i = 0; i <= TRIPLE_TAP; i++) + { + /* canceled */ + CHECK_START(TAP, 1); + CHECK_CANCEL(TAP, 1); + } + /* momentum should only begin at the initial press or if canceled due to timeout */ + CHECK_START(MOMENTUM, 1); + CHECK_FINISH(MOMENTUM, 1); + /* canceled: the motion ends outside the canvas, so there is no momentum */ + CHECK_CANCEL(MOMENTUM, 0); + + /* flick checks a tolerance value for straight lines, so "start" will be >= 1 */ + ck_assert_int_ge(count[FLICK][EFL_GESTURE_STATE_STARTED - 1], 1); + CHECK_FINISH(FLICK, 0); + /* flick checks a tolerance value for straight lines, so "start" will be >= 1 */ + ck_assert_int_ge(count[FLICK][EFL_GESTURE_STATE_CANCELED - 1], 1); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + /* definitely not a flick, test re-entering canvas */ + moves = drag_object_around(rect, 500, 750, 400, 180); + for (i = 0; i <= TRIPLE_TAP; i++) + { + /* canceled */ + CHECK_START(TAP, 1); + CHECK_CANCEL(TAP, 1); + } + /* momentum should only begin at the initial press or if canceled due to timeout */ + CHECK_START(MOMENTUM, 1); + /* finished: the motion ends outside the canvas, but we still count it */ + CHECK_FINISH(MOMENTUM, 1); + CHECK_CANCEL(MOMENTUM, 0); + + /* flick checks a tolerance value for straight lines, so "start" will be >= 1 */ + ck_assert_int_ge(count[FLICK][EFL_GESTURE_STATE_STARTED - 1], 1); + CHECK_FINISH(FLICK, 0); + /* flick checks a tolerance value for straight lines, so "start" will be >= 1 */ + ck_assert_int_ge(count[FLICK][EFL_GESTURE_STATE_CANCELED - 1], 1); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; +} +EFL_END_TEST + +EFL_START_TEST(test_efl_ui_gesture_zoom) +{ + Eo *rect = setup(); + int moves; + + moves = pinch_object(rect, 500, 500, 501, 501, -250, -250, 250, 250); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + + CHECK_START(MOMENTUM, 1); + CHECK_UPDATE(MOMENTUM, 0); + CHECK_FINISH(MOMENTUM, 0); + CHECK_CANCEL(MOMENTUM, 1); + + /* only finish is verifiable */ + CHECK_FINISH(FLICK, 0); + /* started then canceled */ + CHECK_ALL(ROTATE, 1, 0, 0, 1); + /* started 1x */ + CHECK_START(ZOOM, 1); + /* 2 touch points tracked, so this will be roughly (2 * moves) but probably less */ + ck_assert_int_ge(count[ZOOM][EFL_GESTURE_STATE_UPDATED - 1], moves); + /* finished 1x */ + CHECK_FINISH(ZOOM, 1); + CHECK_CANCEL(ZOOM, 0); + + RESET; + + + moves = pinch_object(rect, 250, 250, 750, 750, 250, 250, -250, -250); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + + CHECK_START(MOMENTUM, 1); + CHECK_UPDATE(MOMENTUM, 0); + CHECK_FINISH(MOMENTUM, 0); + CHECK_CANCEL(MOMENTUM, 1); + + /* only finish is verifiable */ + CHECK_FINISH(FLICK, 0); + /* started then canceled */ + CHECK_ALL(ROTATE, 1, 0, 0, 1); + /* started 1x */ + CHECK_START(ZOOM, 1); + /* 2 touch points tracked, so this will be roughly (2 * moves) but probably less */ + ck_assert_int_ge(count[ZOOM][EFL_GESTURE_STATE_UPDATED - 1], moves); + /* finished 1x */ + CHECK_FINISH(ZOOM, 1); + CHECK_CANCEL(ZOOM, 0); + + RESET; + +} +EFL_END_TEST + +EFL_START_TEST(test_efl_ui_gesture_rotate) +{ + Eo *rect = setup(); + int moves, momentum_moves; + + multi_press_object(rect, 1); + CHECK_ALL(TAP, 1, 0, 0, 0); + CHECK_ALL(LONG_PRESS, 1, 0, 0, 0); + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 0); + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 0); + + CHECK_ZERO(MOMENTUM); + CHECK_ZERO(FLICK); + CHECK_ZERO(ROTATE); + CHECK_ZERO(ZOOM); + + RESET; + + + moves = multi_drag_object_around(rect, 1, 500, 500, 250, 180); + CHECK_ALL(TAP, 0, 0, 0, 1); + CHECK_ALL(LONG_PRESS, 0, 0, 0, 1); + CHECK_ALL(DOUBLE_TAP, 0, 0, 0, 1); + CHECK_ALL(TRIPLE_TAP, 0, 0, 0, 1); + + CHECK_START(MOMENTUM, 1); + momentum_moves = count[MOMENTUM][EFL_GESTURE_STATE_UPDATED - 1]; + ck_assert_int_ge(count[MOMENTUM][EFL_GESTURE_STATE_UPDATED - 1], moves - 5); + CHECK_FINISH(MOMENTUM, 1); + CHECK_CANCEL(MOMENTUM, 0); + + /* flick is just going to do flick stuff here, so don't even bother checking much */ + CHECK_FINISH(FLICK, 0); + + CHECK_ALL(ROTATE, 1, moves - 1, 1, 0); + CHECK_ALL(ZOOM, 1, 0, 0, 1); + + RESET; + + /* verify identical motion in reverse */ + moves = multi_drag_object_around(rect, 1, 500, 500, 250, -180); + /* already occurred, first finger still down */ + CHECK_ZERO(TAP); + /* already canceled, first finger still down */ + CHECK_ZERO(LONG_PRESS); + CHECK_ZERO(DOUBLE_TAP); + CHECK_ZERO(TRIPLE_TAP); + + /* continuing gesture, counts as already started */ + CHECK_START(MOMENTUM, 0); + /* should be exactly 1 more than previous time */ + CHECK_UPDATE(MOMENTUM, momentum_moves + 1); + CHECK_FINISH(MOMENTUM, 1); + CHECK_CANCEL(MOMENTUM, 0); + + /* flick is just going to do flick stuff here, so don't even bother checking much */ + CHECK_FINISH(FLICK, 0); + + /* continuing gesture, counts as already started, increment update counter */ + CHECK_ALL(ROTATE, 0, (moves - 1) + 1, 1, 0); + CHECK_ALL(ZOOM, 0, 1, 0, 1); + +} +EFL_END_TEST + +static void +custom_cb(void *data EINA_UNUSED , const Efl_Event *ev) +{ + Efl_Canvas_Gesture *g = ev->info; + + int *count = data; + if (!eina_streq(efl_gesture_custom_gesture_name_get(g), "custom_gesture")) return; + /* increment counter for event state which has been processed */ + count[efl_gesture_state_get(g) - 1]++; +} + +static void +custom_cb2(void *data EINA_UNUSED , const Efl_Event *ev) +{ + Efl_Canvas_Gesture *g = ev->info; + + int *count = data; + if (!eina_streq(efl_gesture_custom_gesture_name_get(g), "custom_gesture2")) return; + /* increment counter for event state which has been processed */ + count[efl_gesture_state_get(g) - 1]++; +} + +static void +custom_gesture_cb(void *data EINA_UNUSED , const Efl_Event *ev) +{ + Efl_Canvas_Gesture *g = ev->info; + + Eina_Position2D *delta = data; + if (!eina_streq(efl_gesture_custom_gesture_name_get(g), "custom_gesture")) return; + delta->x = custom_gesture_x_delta_get(g); + delta->y = custom_gesture_y_delta_get(g); +} + +EFL_START_TEST(test_efl_ui_gesture_custom) +{ + Eo *rect = setup(); + Eo *manager = efl_provider_find(rect, EFL_CANVAS_GESTURE_MANAGER_CLASS); + Eo *recognizer = efl_add(CUSTOM_RECOGNIZER_CLASS, manager); + Eo *recognizer2 = efl_add(CUSTOM_RECOGNIZER2_CLASS, manager); + Eina_Position2D delta = {0}; + + efl_gesture_manager_recognizer_register(manager, recognizer); + efl_gesture_manager_recognizer_register(manager, recognizer2); + efl_event_callback_add(rect, EFL_EVENT_GESTURE_CUSTOM, custom_cb, &count[CUSTOM]); + efl_event_callback_add(rect, EFL_EVENT_GESTURE_CUSTOM, custom_cb2, &count[CUSTOM2]); + + /* verify that we're processing */ + click_object(rect); + CHECK_ALL(CUSTOM, 1, 0, 1, 0); + CHECK_ALL(CUSTOM2, 1, 0, 0, 1); + + RESET; + + /* verify gesture properties */ + efl_event_callback_add(rect, EFL_EVENT_GESTURE_CUSTOM, custom_gesture_cb, &delta); + drag_object(rect, 0, 0, 75, 30, EINA_FALSE); + ck_assert_int_eq(delta.x, 75); + ck_assert_int_eq(delta.y, 30); + efl_event_callback_del(rect, EFL_EVENT_GESTURE_CUSTOM, custom_gesture_cb, &delta); + + RESET; + + /* verify that we aren't still processing */ + efl_gesture_manager_recognizer_unregister(manager, recognizer); + efl_gesture_manager_recognizer_unregister(manager, recognizer2); + click_object(rect); + CHECK_ZERO(CUSTOM); + CHECK_ZERO(CUSTOM2); + + RESET; + + /* verify re-register + early finish from custom2 */ + efl_gesture_manager_recognizer_register(manager, recognizer); + efl_gesture_manager_recognizer_register(manager, recognizer2); + drag_object(rect, 500, 500, 1, 0, EINA_FALSE); + CHECK_ALL(CUSTOM, 1, 1, 1, 0); + CHECK_ALL(CUSTOM2, 1, 0, 1, 0); + + efl_event_callback_del(rect, EFL_EVENT_GESTURE_CUSTOM, custom_cb, &count[CUSTOM]); + efl_event_callback_del(rect, EFL_EVENT_GESTURE_CUSTOM, custom_cb2, &count[CUSTOM2]); + + RESET; + + /* verify we don't have anything totally weird going on */ + click_object(rect); + CHECK_ZERO(CUSTOM); + CHECK_ZERO(CUSTOM2); + + efl_gesture_manager_recognizer_unregister(manager, recognizer); + efl_gesture_manager_recognizer_unregister(manager, recognizer2); +} +EFL_END_TEST + + +EFL_START_TEST(test_efl_ui_gesture_sequence) +{ + Eo *rect = setup(); + int moves; + + multi_click_object(rect, 1); + CHECK_ALL(TAP, 1, 0, 1, 0); + + wait_timer(0.4); + RESET; + + moves = pinch_object(rect, 500, 500, 501, 501, -250, 0, 250, 0); + /* canceled */ + CHECK_ALL(TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(LONG_PRESS, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(DOUBLE_TAP, 1, 0, 0, 1); + /* canceled */ + CHECK_ALL(TRIPLE_TAP, 1, 0, 0, 1); + + + CHECK_START(ZOOM, 1); + /* 2 touch points tracked, so this will be roughly (2 * moves) but probably less */ + ck_assert_int_ge(count[ZOOM][EFL_GESTURE_STATE_UPDATED - 1], moves); + /* finished 1x */ + CHECK_FINISH(ZOOM, 1); + CHECK_CANCEL(ZOOM, 0); + + wait_timer(0.4); + RESET; + + multi_click_object(rect, 1); + CHECK_ALL(TAP, 1, 0, 1, 0); + + RESET; +} +EFL_END_TEST + +void efl_ui_test_gesture(TCase *tc) +{ + tcase_add_test(tc, test_efl_ui_gesture_taps); + tcase_add_test(tc, test_efl_ui_gesture_long_press); + tcase_add_test(tc, test_efl_ui_gesture_flick); + tcase_add_test(tc, test_efl_ui_gesture_zoom); + tcase_add_test(tc, test_efl_ui_gesture_rotate); + tcase_add_test(tc, test_efl_ui_gesture_custom); + tcase_add_test(tc, test_efl_ui_gesture_sequence); +} diff --git a/src/tests/elementary/efl_ui_test_grid.c b/src/tests/elementary/efl_ui_test_grid.c index 7ec1763545..db19e58d87 100644 --- a/src/tests/elementary/efl_ui_test_grid.c +++ b/src/tests/elementary/efl_ui_test_grid.c @@ -89,16 +89,15 @@ EFL_START_TEST(efl_ui_grid_unpack_all) ck_assert(grid_item_pack(grid, count_before, NULL) != EINA_FALSE); - itor = efl_content_iterate(grid); efl_pack_unpack_all(grid); count = efl_content_count(grid); ck_assert(count == 0); + itor = efl_content_iterate(grid); EINA_ITERATOR_FOREACH(itor, item) - efl_del(item); - - free(itor); + ck_assert(EINA_FALSE); + eina_iterator_free(itor); } EFL_END_TEST diff --git a/src/tests/elementary/efl_ui_test_image.c b/src/tests/elementary/efl_ui_test_image.c index 244f1047e4..bd7d125323 100644 --- a/src/tests/elementary/efl_ui_test_image.c +++ b/src/tests/elementary/efl_ui_test_image.c @@ -30,7 +30,34 @@ EFL_START_TEST(efl_ui_image_test_icon) } EFL_END_TEST +extern Eo *elm_image_object_get(Eo*); +EFL_START_TEST(efl_ui_image_test_scale_method) +{ + Eo *win, *image; + Eina_Size2D sz; + + win = win_add(NULL, "image", EFL_UI_WIN_TYPE_BASIC); + efl_gfx_entity_size_set(win, EINA_SIZE2D(100, 100)); + + image = efl_add(EFL_UI_IMAGE_CLASS, win, + efl_file_set(efl_added, ELM_IMAGE_DATA_DIR"/images/logo.png"), + efl_gfx_arrangement_content_align_set(efl_added, 0.5, 0.0), + efl_gfx_image_scale_method_set(efl_added, EFL_GFX_IMAGE_SCALE_METHOD_FIT_WIDTH) + ); + efl_gfx_entity_size_set(image, EINA_SIZE2D(100, 100)); + get_me_to_those_events(win); + sz = efl_gfx_entity_size_get(image); + ck_assert_int_eq(sz.w, 100); + ck_assert_int_eq(sz.h, 100); + /* legacy operation on eo object: very illegal */ + sz = efl_gfx_entity_size_get(elm_image_object_get(image)); + ck_assert_int_eq(sz.w, 100); + ck_assert_int_eq(sz.h, 100); +} +EFL_END_TEST + void efl_ui_test_image(TCase *tc) { tcase_add_test(tc, efl_ui_image_test_icon); + tcase_add_test(tc, efl_ui_image_test_scale_method); } diff --git a/src/tests/elementary/efl_ui_test_layout.c b/src/tests/elementary/efl_ui_test_layout.c index 86f4b1efe8..4e1b117b6c 100644 --- a/src/tests/elementary/efl_ui_test_layout.c +++ b/src/tests/elementary/efl_ui_test_layout.c @@ -195,14 +195,19 @@ EFL_END_TEST EFL_START_TEST(efl_ui_layout_test_api_ordering) { Evas_Object *win, *box; + int count = 0; const char text_text[] = "test text"; win = win_add(NULL, "layout", EFL_UI_WIN_TYPE_BASIC); box = efl_add(EFL_UI_BOX_CLASS, win); Eo *layout = efl_add(EFL_UI_BUTTON_CLASS, win, + efl_layout_signal_callback_add(efl_added, "efl,content,set", "efl", &count, (void*)event_callback_single_call_int_data, NULL), + efl_ui_widget_style_set(efl_added, "anchor"), efl_content_set(efl_added, box), efl_text_set(efl_added, text_text) ); + ecore_main_loop_iterate(); + ck_assert_int_eq(count, 1); ck_assert_ptr_eq(efl_content_get(layout), box); ck_assert_str_eq(efl_text_get(layout), text_text); } @@ -218,6 +223,26 @@ EFL_START_TEST(efl_ui_layout_test_versioning) } EFL_END_TEST +EFL_START_TEST(efl_ui_layout_test_freeze) +{ + Evas_Object *win; + int count = 0; + + win = win_add(NULL, "layout", EFL_UI_WIN_TYPE_BASIC); + efl_gfx_entity_size_set(win, EINA_SIZE2D(100, 100)); + Eo *layout = efl_add(EFL_UI_BUTTON_CLASS, win); + efl_gfx_entity_size_set(layout, EINA_SIZE2D(100, 100)); + efl_text_set(layout, "button"); + get_me_to_those_events(layout); + + efl_event_callback_add(win, EFL_CANVAS_SCENE_EVENT_RENDER_PRE, (void*)event_callback_single_call_int_data, &count); + efl_layout_calc_freeze(layout); + efl_layout_calc_thaw(layout); + force_render(win); + ck_assert_int_eq(count, 0); +} +EFL_END_TEST + void efl_ui_test_layout(TCase *tc) { tcase_add_test(tc, efl_ui_layout_test_property_bind); @@ -229,4 +254,5 @@ void efl_ui_test_layout(TCase *tc) tcase_add_test(tc, efl_ui_layout_test_callback); tcase_add_test(tc, efl_ui_layout_test_property_bind_provider); tcase_add_test(tc, efl_ui_layout_test_versioning); + tcase_add_test(tc, efl_ui_layout_test_freeze); } diff --git a/src/tests/elementary/efl_ui_test_list_collection.c b/src/tests/elementary/efl_ui_test_list_collection.c index 1d4f913901..94bafbd010 100644 --- a/src/tests/elementary/efl_ui_test_list_collection.c +++ b/src/tests/elementary/efl_ui_test_list_collection.c @@ -161,7 +161,7 @@ EFL_START_TEST(placement_test_group) r = efl_gfx_entity_geometry_get(core_item[i]); ck_assert_int_eq(r.x, 1); - ck_assert_int_eq(r.y, 21+(i - 1)*40); + ck_assert_int_eq(r.y, 22+(i - 1)*40); ck_assert_int_eq(r.w, 183); // 200 - 2px border - X for the width of the scrollbar. ck_assert_int_eq(r.h, 40); } @@ -181,7 +181,7 @@ EFL_START_TEST(placement_test_group) r = efl_gfx_entity_geometry_get(core_item[i]); ck_assert_int_eq(r.x, 1); - ck_assert_int_eq(r.y, 1+(i-2)*40); + ck_assert_int_eq(r.y, 2+(i-2)*40); ck_assert_int_eq(r.w, 183); // 200 - 2px border - X for the width of the scrollbar. ck_assert_int_eq(r.h, 40); } diff --git a/src/tests/elementary/efl_ui_test_scroller.c b/src/tests/elementary/efl_ui_test_scroller.c index e1aa4ef53b..78f8bfaf7f 100644 --- a/src/tests/elementary/efl_ui_test_scroller.c +++ b/src/tests/elementary/efl_ui_test_scroller.c @@ -144,7 +144,58 @@ EFL_START_TEST(efl_ui_test_scroller_events) } EFL_END_TEST +EFL_START_TEST(efl_ui_test_scroller_scrollbar) +{ + Eo *sc; + + Eo *win = win_add(); + Eina_Bool hbar_visible = EINA_FALSE, vbar_visible = EINA_FALSE; + efl_gfx_entity_size_set(win, EINA_SIZE2D(500, 500)); + + sc = efl_add(EFL_UI_SCROLLER_CLASS, win, + efl_ui_scrollbar_bar_mode_set(efl_added, EFL_UI_SCROLLBAR_MODE_AUTO, EFL_UI_SCROLLBAR_MODE_AUTO), + efl_content_set(win, efl_added)); + + /*Scrollbar auto mode test.*/ + efl_loop_iterate(efl_main_loop_get()); + + efl_ui_scrollbar_bar_visibility_get(sc, &hbar_visible, &vbar_visible); + ck_assert(hbar_visible == EINA_FALSE); + ck_assert(vbar_visible == EINA_FALSE); + + /*Scrollbar auto mode test.*/ + efl_add(EFL_CANVAS_RECTANGLE_CLASS, evas_object_evas_get(sc), + efl_gfx_entity_size_set(efl_added, EINA_SIZE2D(5000, 5000)), + efl_content_set(sc, efl_added)); + + efl_loop_iterate(efl_main_loop_get()); + + efl_ui_scrollbar_bar_visibility_get(sc, &hbar_visible, &vbar_visible); + ck_assert(hbar_visible == EINA_TRUE); + ck_assert(vbar_visible == EINA_TRUE); + + /*Scrollbar off mode test.*/ + efl_ui_scrollbar_bar_mode_set(sc, EFL_UI_SCROLLBAR_MODE_OFF, EFL_UI_SCROLLBAR_MODE_OFF); + + efl_loop_iterate(efl_main_loop_get()); + + efl_ui_scrollbar_bar_visibility_get(sc, &hbar_visible, &vbar_visible); + ck_assert(hbar_visible == EINA_FALSE); + ck_assert(vbar_visible == EINA_FALSE); + + /*Scrollbar on mode test.*/ + efl_ui_scrollbar_bar_mode_set(sc, EFL_UI_SCROLLBAR_MODE_ON, EFL_UI_SCROLLBAR_MODE_ON); + + efl_loop_iterate(efl_main_loop_get()); + + efl_ui_scrollbar_bar_visibility_get(sc, &hbar_visible, &vbar_visible); + ck_assert(hbar_visible == EINA_TRUE); + ck_assert(vbar_visible == EINA_TRUE); +} +EFL_END_TEST + void efl_ui_test_scroller(TCase *tc) { tcase_add_test(tc, efl_ui_test_scroller_events); + tcase_add_test(tc, efl_ui_test_scroller_scrollbar); } diff --git a/src/tests/elementary/efl_ui_test_select_model.c b/src/tests/elementary/efl_ui_test_select_model.c index 12d5e6e148..78259085a3 100644 --- a/src/tests/elementary/efl_ui_test_select_model.c +++ b/src/tests/elementary/efl_ui_test_select_model.c @@ -102,8 +102,11 @@ EFL_START_TEST(efl_test_select_model) model = efl_add_ref(EFL_UI_SELECT_MODEL_CLASS, efl_main_loop_get(), efl_ui_view_model_set(efl_added, base_model)); ck_assert(!!model); - future = efl_model_property_set(model, "child.selected", eina_value_int_new(2)); + + future = efl_model_property_ready_get(model, "child.selected"); eina_future_then(future, _wait_propagate, NULL, NULL); + + efl_model_property_set(model, "child.selected", eina_value_int_new(2)); ecore_main_loop_begin(); future = efl_model_children_slice_get(model, 0, efl_model_children_count_get(model)); @@ -120,6 +123,8 @@ EFL_START_TEST(efl_test_select_model) EINA_ITERATOR_FOREACH(it, index) fail_if(*index == 2); eina_iterator_free(it); + + efl_model_property_set(model, "child.selected", eina_value_int_new(1)); } EFL_END_TEST diff --git a/src/tests/elementary/efl_ui_test_spin_button.c b/src/tests/elementary/efl_ui_test_spin_button.c index a60314ff21..6df99b340f 100644 --- a/src/tests/elementary/efl_ui_test_spin_button.c +++ b/src/tests/elementary/efl_ui_test_spin_button.c @@ -3,6 +3,7 @@ #endif #include <Elementary.h> +#include "elm_entry_eo.h" //needed to check that spin is in text mode #include <Efl_Ui.h> #include "efl_ui_suite.h" @@ -62,7 +63,7 @@ EFL_START_TEST (spin_wheel_test) get_me_to_those_events(spin); evas_event_feed_mouse_move(evas_object_evas_get(spin), 30, 30, 1234, NULL); evas_event_feed_mouse_wheel(evas_object_evas_get(spin), -1, -1, 12345, NULL); - ck_assert(efl_ui_range_value_get(spin) == 10.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(spin), 10.0)); ck_assert_int_eq(changed, EINA_TRUE); ck_assert_int_eq(min_reached, EINA_FALSE); ck_assert_int_eq(max_reached, EINA_FALSE); @@ -71,7 +72,7 @@ EFL_START_TEST (spin_wheel_test) max_reached = EINA_FALSE; evas_event_feed_mouse_wheel(evas_object_evas_get(spin), -1, 1, 12345, NULL); - ck_assert(efl_ui_range_value_get(spin) == 0.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(spin), 0.0)); ck_assert_int_eq(changed, EINA_TRUE); ck_assert_int_eq(min_reached, EINA_FALSE); ck_assert_int_eq(max_reached, EINA_FALSE); @@ -156,6 +157,111 @@ EFL_START_TEST (spin_value_dec_min) } EFL_END_TEST +EFL_START_TEST (spin_wraparound) +{ + efl_ui_spin_button_wraparound_set(spin, EINA_TRUE); + efl_ui_range_limits_set(spin, 10, 30); + efl_ui_range_step_set(spin, 20); + + efl_ui_range_value_set(spin, 20); + click_spin_part(spin, "efl.inc_button"); + ck_assert_int_eq(efl_ui_range_value_get(spin), 10); + + efl_ui_range_value_set(spin, 20); + click_spin_part(spin, "efl.dec_button"); + ck_assert_int_eq(efl_ui_range_value_get(spin), 30); + +} +EFL_END_TEST + +EFL_START_TEST (spin_double_values) +{ + double step = 0.1; + efl_ui_range_limits_set(spin, 10, 30); + efl_ui_range_value_set(spin, 20); + efl_ui_range_step_set(spin, step); + ck_assert(EINA_DBL_EQ(efl_ui_range_step_get(spin), step)); + get_me_to_those_events(spin); + ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(spin), 20.0)); + + for (int i = 0; i < 5; ++i) + { + click_part(spin, "efl.inc_button"); + get_me_to_those_events(spin); + } + ck_assert_int_eq(EINA_DBL_EQ(efl_ui_range_value_get(spin), 20.5), 1); +} +EFL_END_TEST + +EFL_START_TEST (spin_double_values_hitting_max_with_step) +{ + //idea is to check that spin button can hit max with inc, even if value is not multiple is 2.7 + efl_ui_range_limits_set(spin, 10, 30); + efl_ui_range_value_set(spin, 27); + efl_ui_range_step_set(spin, 2.7); + get_me_to_those_events(spin); + + for (int i = 0; i < 2; ++i) + { + click_part(spin, "efl.inc_button"); + get_me_to_those_events(spin); + } + ck_assert_int_eq(EINA_DBL_EQ(efl_ui_range_value_get(spin), 30), 1); +} +EFL_END_TEST + +static inline void +_try_direct_text_input(const char *text, double result) +{ + Eo *entry; + + efl_ui_focus_util_focus(efl_content_get(efl_part(spin, "efl.text_button"))); + get_me_to_those_events(spin); + entry = efl_content_get(efl_part(spin, "efl.entry")); + elm_object_text_set(entry, ""); + ck_assert_int_eq(efl_isa(entry, ELM_ENTRY_CLASS), 1); + efl_ui_focus_util_focus(entry); + get_me_to_those_events(spin); + + write_key_sequence(spin, text); + get_me_to_those_events(spin); + + efl_ui_focus_util_focus(efl_content_get(efl_part(spin, "efl.inc_button"))); + ck_assert_msg(EINA_DBL_EQ(efl_ui_range_value_get(spin), result), "Values do not match %f - %f (%s)", efl_ui_range_value_get(spin), result, elm_object_text_get(entry)); +} + +EFL_START_TEST (spin_direct_text_input) +{ + efl_ui_spin_button_direct_text_input_set(spin, EINA_TRUE); + efl_ui_range_limits_set(spin, -30, 30); + efl_ui_range_value_set(spin, 20); + get_me_to_those_events(spin); + _try_direct_text_input("1asdf2", 12); + _try_direct_text_input("1-2", 12); + _try_direct_text_input("-12", -12); + _try_direct_text_input("-100", -30); + _try_direct_text_input("1.8", 18); + _try_direct_text_input("12342435", 30); +} +EFL_END_TEST + +EFL_START_TEST (spin_direct_text_input_comma_value) +{ + efl_ui_spin_button_direct_text_input_set(spin, EINA_TRUE); + efl_ui_range_limits_set(spin, -30, 30); + efl_ui_range_value_set(spin, 20); + efl_ui_format_string_set(spin, "%.2f", EFL_UI_FORMAT_STRING_TYPE_SIMPLE); + efl_ui_focus_util_focus(efl_content_get(efl_part(spin, "efl.text_button"))); + get_me_to_those_events(spin); + _try_direct_text_input("1asdf2.1", 12.1); + _try_direct_text_input("1-2.2", 12.2); + _try_direct_text_input("-12.8", -12.8); + _try_direct_text_input("-100", -30); + _try_direct_text_input("10.8", 10.8); + _try_direct_text_input("12342435.12312341342", 30); +} +EFL_END_TEST + void efl_ui_test_spin_button(TCase *tc) { tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown); @@ -164,4 +270,9 @@ void efl_ui_test_spin_button(TCase *tc) tcase_add_test(tc, spin_value_inc); tcase_add_test(tc, spin_value_inc_max); tcase_add_test(tc, spin_value_dec_min); + tcase_add_test(tc, spin_wraparound); + tcase_add_test(tc, spin_double_values); + tcase_add_test(tc, spin_double_values_hitting_max_with_step); + tcase_add_test(tc, spin_direct_text_input); + tcase_add_test(tc, spin_direct_text_input_comma_value); } diff --git a/src/tests/elementary/efl_ui_test_spotlight.c b/src/tests/elementary/efl_ui_test_spotlight.c index 9d5f433e44..2166702797 100644 --- a/src/tests/elementary/efl_ui_test_spotlight.c +++ b/src/tests/elementary/efl_ui_test_spotlight.c @@ -6,8 +6,8 @@ #include "efl_ui_suite.h" #include "eo_internal.h" -EFL_CLASS_SIMPLE_CLASS(efl_ui_spotlight_manager, "efl_ui_spotlight_manager", EFL_UI_SPOTLIGHT_MANAGER_CLASS); -EFL_CLASS_SIMPLE_CLASS(efl_ui_spotlight_indicator, "efl_ui_spotlight_indicator", EFL_UI_SPOTLIGHT_INDICATOR_CLASS); +EFL_CLASS_SIMPLE_CLASS(efl_ui_spotlight_manager, "Efl.Ui.Spotlight.Manager", EFL_UI_SPOTLIGHT_MANAGER_CLASS); +EFL_CLASS_SIMPLE_CLASS(efl_ui_spotlight_indicator, "Efl.Ui.Spotlight.Indicator", EFL_UI_SPOTLIGHT_INDICATOR_CLASS); static Efl_Ui_Win *win; static Efl_Ui_Spotlight_Container *container; @@ -127,7 +127,7 @@ static void _emit_pos(Eo *obj, double d) { printf("EMITTING %f %f\n", d, transition_calls.last_position); - if (d == transition_calls.last_position) return; + if (EINA_DBL_EQ(d, transition_calls.last_position)) return; efl_event_callback_call(obj, EFL_UI_SPOTLIGHT_MANAGER_EVENT_POS_UPDATE, &d); transition_calls.last_position = d; @@ -403,7 +403,7 @@ _verify_indicator_calls(void) ck_assert_ptr_eq(indicator_calls.content_add.subobj, w); ck_assert_int_eq(indicator_calls.content_del.called, 0); ck_assert_int_eq(indicator_calls.position_update.called, 1); - ck_assert(indicator_calls.position_update.position == 0.0); + ck_assert(EINA_DBL_EQ(indicator_calls.position_update.position, 0.0)); indicator_calls.content_add.called = 0; indicator_calls.position_update.called = 0; @@ -414,7 +414,7 @@ _verify_indicator_calls(void) ck_assert_ptr_eq(indicator_calls.content_add.subobj, w1); ck_assert_int_eq(indicator_calls.content_del.called, 0); ck_assert_int_eq(indicator_calls.position_update.called, 1); - ck_assert(indicator_calls.position_update.position == 1.0); + ck_assert(EINA_DBL_EQ(indicator_calls.position_update.position, 1.0)); indicator_calls.content_add.called = 0; indicator_calls.position_update.called = 0; @@ -435,7 +435,7 @@ _verify_indicator_calls(void) ck_assert_int_eq(indicator_calls.content_del.index, 0); ck_assert_ptr_eq(indicator_calls.content_del.subobj, w1); ck_assert_int_eq(indicator_calls.position_update.called, 1); - ck_assert(indicator_calls.position_update.position == 0.0); + ck_assert(EINA_DBL_EQ(indicator_calls.position_update.position, 0.0)); indicator_calls.content_del.called = 0; indicator_calls.position_update.called = 0; } @@ -645,7 +645,7 @@ EFL_START_TEST (efl_ui_spotlight_animated_transition) ck_assert_int_eq(efl_ui_spotlight_manager_animated_transition_get(efl_ui_spotlight_manager_get(container)), EINA_FALSE); //now check with a real spotlight manager - efl_ui_spotlight_manager_set(container, efl_new(EFL_UI_SPOTLIGHT_MANAGER_STACK_CLASS)); + efl_ui_spotlight_manager_set(container, efl_new(EFL_UI_SPOTLIGHT_FADE_MANAGER_CLASS)); efl_ui_spotlight_animated_transition_set(container, EINA_TRUE); ck_assert_int_eq(efl_ui_spotlight_animated_transition_get(container), EINA_TRUE); ck_assert_int_eq(efl_ui_spotlight_manager_animated_transition_get(efl_ui_spotlight_manager_get(container)), EINA_TRUE); @@ -654,7 +654,7 @@ EFL_START_TEST (efl_ui_spotlight_animated_transition) ck_assert_int_eq(efl_ui_spotlight_animated_transition_get(container), EINA_FALSE); ck_assert_int_eq(efl_ui_spotlight_manager_animated_transition_get(efl_ui_spotlight_manager_get(container)), EINA_FALSE); - Eo *manager2 = efl_new(EFL_UI_SPOTLIGHT_MANAGER_STACK_CLASS); + Eo *manager2 = efl_new(EFL_UI_SPOTLIGHT_FADE_MANAGER_CLASS); Eina_Bool animated_transition_manager; efl_add(EFL_UI_SPOTLIGHT_CONTAINER_CLASS, win, efl_ui_spotlight_manager_set(efl_added, manager2), diff --git a/src/tests/elementary/efl_ui_test_text.c b/src/tests/elementary/efl_ui_test_text.c index 5c26e6f528..521bf1339c 100644 --- a/src/tests/elementary/efl_ui_test_text.c +++ b/src/tests/elementary/efl_ui_test_text.c @@ -5,6 +5,7 @@ #define EFL_LAYOUT_CALC_PROTECTED #include <Efl_Ui.h> #include "efl_ui_suite.h" +#include "Evas_Legacy.h" static void increment_int_changed(void *data EINA_UNUSED, const Efl_Event *ev EINA_UNUSED) @@ -29,6 +30,18 @@ EFL_START_TEST(text_cnp) efl_text_set(txt, "Hello"); efl_text_interactive_all_select(txt); efl_ui_textbox_selection_copy(txt); + efl_text_interactive_all_unselect(txt); + efl_text_cursor_object_text_insert(efl_text_interactive_main_cursor_get(txt), "X"); + efl_ui_textbox_selection_paste(txt); + ecore_main_loop_iterate(); + ck_assert_int_eq(i_copy, 1); + ck_assert_int_eq(i_paste, 1); + ck_assert_str_eq(efl_text_get(txt), "HelloXHello"); + + i_copy = i_cut = i_paste= 0; + efl_text_set(txt, "Hello"); + efl_text_interactive_all_select(txt); + efl_ui_textbox_selection_copy(txt); efl_text_interactive_all_select(txt); efl_ui_textbox_selection_cut(txt); efl_ui_textbox_selection_paste(txt); @@ -43,9 +56,15 @@ EFL_START_TEST(text_cnp) } EFL_END_TEST +static void +_stop_event_soon(void *data EINA_UNUSED, const Efl_Event *ev) +{ + efl_event_callback_stop(ev->object); +} + EFL_START_TEST(text_all_select_all_unselect) { - Eo *txt; + Eo *txt, *txt2; Eo *win = win_add(); int i_have_selection = 0, i_selection = 0; @@ -56,22 +75,65 @@ EFL_START_TEST(text_all_select_all_unselect) efl_event_callback_add(efl_added, EFL_TEXT_INTERACTIVE_EVENT_SELECTION_CHANGED, increment_int_changed, &i_selection) ); - + efl_event_callback_priority_add(txt, EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _stop_event_soon, NULL); efl_text_set(txt, "Hello"); efl_text_interactive_all_select(txt); - Efl_Text_Cursor *c1=NULL, *c2 =NULL; + Efl_Text_Cursor_Object *c1=NULL, *c2 =NULL; efl_text_interactive_selection_cursors_get(txt, &c1, &c2); ck_assert_ptr_ne(c1, NULL); ck_assert_ptr_ne(c2, NULL); fail_if(!efl_text_interactive_have_selection_get(txt)); - ck_assert_int_eq(efl_text_cursor_position_get(c1), 0); - ck_assert_int_eq(efl_text_cursor_position_get(c2), 5); + ck_assert_int_eq(efl_text_cursor_object_position_get(c1), 0); + ck_assert_int_eq(efl_text_cursor_object_position_get(c2), 5); efl_text_interactive_all_unselect(txt); fail_if(efl_text_interactive_have_selection_get(txt)); ecore_main_loop_iterate(); ck_assert_int_eq(i_have_selection, 2); ck_assert_int_eq(i_selection, 1); + + /*Partial select, the select all*/ + Eo *sel1, *sel2; + i_selection = 0; + efl_text_interactive_selection_cursors_get(txt, &sel1, &sel2); + efl_text_cursor_object_position_set(sel1, 1); + efl_text_cursor_object_position_set(sel2, 2); + ck_assert_int_eq(i_selection, 2); + efl_text_interactive_all_select(txt); + ck_assert_int_eq(i_selection, 3); + ck_assert_int_eq(efl_text_cursor_object_position_get(sel1), 0); + ck_assert_int_eq(efl_text_cursor_object_position_get(sel2), 5); + + Eo *cur1 = efl_ui_textbox_cursor_create(txt); + Eo *cur2 = efl_ui_textbox_cursor_create(txt); + efl_text_cursor_object_position_set(cur1, 1); + efl_text_cursor_object_position_set(cur2, 2); + efl_text_interactive_selection_cursors_set(txt, cur1, cur2); + ck_assert_int_eq(i_selection, 4); + efl_text_interactive_selection_cursors_get(txt, &sel1, &sel2); + ck_assert_int_eq(efl_text_cursor_object_position_get(sel1),1); + ck_assert_int_eq(efl_text_cursor_object_position_get(sel2),2); + + + /*Select part then select all*/ + efl_text_interactive_all_unselect(txt); + i_have_selection = 0, i_selection = 0; + efl_text_cursor_object_position_set(cur1, 1); + efl_text_cursor_object_position_set(cur2, 2); + efl_text_interactive_selection_cursors_set(txt, cur1, cur2); + ck_assert_int_eq(i_selection, 1); + ck_assert_int_eq(i_have_selection, 1); + efl_text_interactive_all_select(txt); + ck_assert_int_eq(i_selection, 2); + ck_assert_int_eq(i_have_selection, 1); + efl_text_interactive_all_unselect(txt); + ck_assert_int_eq(i_have_selection, 2); + + //cursor selection change on efl_markup_set + txt2 = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_text_markup_set(txt2, "<ps>"); + efl_del(txt); + efl_del(txt2); efl_del(win); } EFL_END_TEST @@ -82,18 +144,19 @@ EFL_START_TEST(text_selection) Eo *win = win_add(); txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_event_callback_priority_add(txt, EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _stop_event_soon, NULL); efl_gfx_entity_size_set(txt, EINA_SIZE2D(300, 300)); efl_text_set(txt, "Hello"); get_me_to_those_events(txt); drag_object(txt, 2, 2, 295, 295, EINA_TRUE); ecore_main_loop_iterate(); - Efl_Text_Cursor *c1=NULL, *c2 =NULL; + Efl_Text_Cursor_Object *c1=NULL, *c2 =NULL; efl_text_interactive_selection_cursors_get(txt, &c1, &c2); ck_assert_ptr_ne(c1, NULL); ck_assert_ptr_ne(c2, NULL); fail_if(!efl_text_interactive_have_selection_get(txt)); - ck_assert_int_eq(efl_text_cursor_position_get(c1), 0); - ck_assert_int_eq(efl_text_cursor_position_get(c2), 5); + ck_assert_int_eq(efl_text_cursor_object_position_get(c1), 0); + ck_assert_int_eq(efl_text_cursor_object_position_get(c2), 5); efl_text_interactive_all_unselect(txt); fail_if(efl_text_interactive_have_selection_get(txt)); efl_text_interactive_selection_allowed_set(txt, EINA_FALSE); @@ -120,7 +183,7 @@ EFL_START_TEST(text_user_change) txt = efl_add(EFL_UI_TEXTBOX_CLASS, win, efl_event_callback_add(efl_added, EFL_TEXT_INTERACTIVE_EVENT_CHANGED_USER, user_changed, &info) ); - + efl_event_callback_priority_add(txt, EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _stop_event_soon, NULL); efl_text_set(txt, "Hello"); efl_gfx_entity_size_set(txt, EINA_SIZE2D(300, 300)); efl_text_interactive_all_select(txt); @@ -137,15 +200,16 @@ EFL_START_TEST(text_scroll_mode) Eo *txt, *win, *cur; win = win_add(); txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_event_callback_priority_add(txt, EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _stop_event_soon, NULL); cur = efl_text_interactive_main_cursor_get(txt); efl_text_set(txt, "Hello"); /*scroll mode is false by default*/ fail_if(efl_ui_textbox_scrollable_get(txt)); efl_ui_textbox_scrollable_set(txt, !efl_ui_textbox_scrollable_get(txt)); - efl_text_cursor_text_insert(cur, "World"); + efl_text_cursor_object_text_insert(cur, "World"); fail_if(!efl_ui_textbox_scrollable_get(txt)); efl_ui_textbox_scrollable_set(txt, !efl_ui_textbox_scrollable_get(txt)); - efl_text_cursor_text_insert(cur, "!!!"); + efl_text_cursor_object_text_insert(cur, "!!!"); ck_assert_str_eq(efl_text_get(txt),"HelloWorld!!!"); efl_del(txt); @@ -153,6 +217,315 @@ EFL_START_TEST(text_scroll_mode) } EFL_END_TEST +EFL_START_TEST(text_change_event) +{ + Eo *txt; + Eo *win = win_add(); + + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_event_callback_priority_add(txt, EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _stop_event_soon, NULL); + efl_gfx_entity_size_set(txt, EINA_SIZE2D(300, 300)); + efl_text_set(txt, "Hello"); + int i_changed = 0; + efl_event_callback_add(txt, EFL_UI_TEXTBOX_EVENT_CHANGED, increment_int_changed, &i_changed); + efl_gfx_entity_visible_set(txt, EINA_TRUE); + Evas *e = evas_object_evas_get(txt); + efl_ui_focus_util_focus(txt); + evas_event_feed_key_down(e, "s", "s", "s", "s", time(NULL), NULL); + ecore_main_loop_iterate(); + ck_assert_str_eq(efl_text_get(txt),"Hellos"); + ck_assert_int_eq(i_changed,1); + ecore_main_loop_iterate(); + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST + +EFL_START_TEST(text_keys_handler) +{ + Eo *txt; + Eo *win = win_add(); + + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_event_callback_priority_add(txt, EFL_UI_SELECTION_EVENT_WM_SELECTION_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _stop_event_soon, NULL); + efl_gfx_entity_size_set(txt, EINA_SIZE2D(300, 300)); + efl_text_set(txt, "Hello"); + + efl_gfx_entity_visible_set(txt, EINA_TRUE); + Evas *e = evas_object_evas_get(txt); + efl_ui_focus_util_focus(txt); + + efl_text_cursor_object_move(efl_text_interactive_main_cursor_get(txt), EFL_TEXT_CURSOR_MOVE_TYPE_LAST); + evas_key_modifier_on(e, "Control"); + evas_event_feed_key_down(e, "BackSpace", "BackSpace", "\b", "\b", time(NULL), NULL); + ecore_main_loop_iterate(); + ck_assert_str_eq(efl_text_get(txt),""); + ck_assert_int_eq(efl_text_cursor_object_position_get(efl_text_interactive_main_cursor_get(txt)), 0); + evas_event_feed_key_up(e, "BackSpace", "BackSpace", "\b", "\b", time(NULL), NULL); + ecore_main_loop_iterate(); + + efl_text_set(txt, "Hello"); + efl_text_cursor_object_position_set(efl_text_interactive_main_cursor_get(txt), 0); + evas_key_modifier_on(e, "Control"); + evas_event_feed_key_down(e, "Delete", "Delete", "\177", "\177", time(NULL), NULL); + ecore_main_loop_iterate(); + ck_assert_str_eq(efl_text_get(txt),""); + ck_assert_int_eq(efl_text_cursor_object_position_get(efl_text_interactive_main_cursor_get(txt)), 0); + evas_event_feed_key_up(e, "Delete", "Delete", "\177", "\177", time(NULL), NULL); + ecore_main_loop_iterate(); + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST + +EFL_START_TEST(text_editable) +{ + Eo *txt, *win; + win = win_add(); + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_text_font_size_set(txt, 100); + efl_text_font_family_set(txt, "Arial"); + efl_text_interactive_editable_set(txt, !efl_text_interactive_editable_get(txt)); + ck_assert_int_eq(efl_text_font_size_get(txt), 100); + ck_assert_str_eq(efl_text_font_family_get(txt), "Arial"); + + efl_ui_widget_disabled_set(txt, EINA_TRUE); + ck_assert_int_eq(efl_text_font_size_get(txt), 100); + ck_assert_str_eq(efl_text_font_family_get(txt), "Arial"); + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST + +EFL_START_TEST(text_on_startup) +{ + Eo *txt, *win; + win = win_add(); + unsigned char r,g,b,a; + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win, + efl_text_color_set(efl_added, 0, 255, 0, 255), + efl_text_font_size_set(efl_added, 50), + efl_text_font_family_set(efl_added, "Arial")); + + ck_assert_int_eq(efl_text_font_size_get(txt), 50); + ck_assert_str_eq(efl_text_font_family_get(txt), "Arial"); + efl_text_color_get(txt, &r, &g, &b, &a); + ck_assert_int_eq(r, 0); + ck_assert_int_eq(g, 255); + ck_assert_int_eq(b, 0); + ck_assert_int_eq(a, 255); + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST + +EFL_START_TEST(text_multiline_selection) +{ + Eo *txt, *win; + Eo *cursor1, *cursor2; + Eina_Rect rc1, rc2; + win = win_add(); + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_text_markup_set(txt, "p1<ps/>p2<ps/>p3"); + efl_text_multiline_set(txt, EINA_FALSE); + ecore_main_loop_iterate(); + efl_text_interactive_all_select(txt); + efl_text_interactive_selection_cursors_get(txt, &cursor1, &cursor2); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor1, EFL_TEXT_CURSOR_TYPE_BEFORE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor2, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_ne(rc1.x, rc2.x); + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST + +EFL_START_TEST(text_singleline_cursor_movement) +{ + Eo *txt, *win; + Eo *cursor; + Eina_Rect rc1, rc2; + win = win_add(); + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_text_markup_set(txt, "p1<ps>p<b>2</b>2<ps>p3"); + efl_text_multiline_set(txt, EINA_FALSE); + ecore_main_loop_iterate(); + + cursor = efl_text_interactive_main_cursor_get(txt); + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_FIRST); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 0); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_LAST); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 9); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_ne(rc1.x, rc2.x); + + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_START); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 0); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_LINE_END); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 9); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_ne(rc1.x, rc2.x); + + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_NEXT); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 9); //do not move + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_PREVIOUS); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 9); //do not move + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_eq(rc1.x, rc2.x); + + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_START); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 0); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_PARAGRAPH_END); + ck_assert_int_eq(efl_text_cursor_object_position_get(cursor), 9); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_ne(rc1.x, rc2.x); + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST + +EFL_START_TEST(text_multiline_singleline_cursor_pos) +{ + Eo *txt, *win; + Eo *cursor, *cursor1, *cursor2; + Eina_Rect rc1, rc2; + win = win_add(); + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_text_markup_set(txt, "p1<ps>p<b>2</b>2<ps>p3<ps>"); + cursor = efl_text_interactive_main_cursor_get(txt); + cursor1 = efl_ui_textbox_cursor_create(txt); + efl_text_cursor_object_position_set(cursor1, 4); + cursor2 = efl_ui_textbox_cursor_create(txt); + efl_text_cursor_object_position_set(cursor2, 8); + + efl_text_multiline_set(txt, EINA_FALSE); + ck_assert_uint_eq(efl_text_cursor_object_content_get(cursor1), '2'); + ck_assert_uint_eq(efl_text_cursor_object_content_get(cursor2), '3'); + + efl_text_cursor_object_position_set(cursor, 0); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + efl_text_multiline_set(txt, EINA_TRUE); + ck_assert_uint_eq(efl_text_cursor_object_content_get(cursor1), '2'); + ck_assert_uint_eq(efl_text_cursor_object_content_get(cursor2), '3'); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_eq(rc1.x, rc2.x); + + efl_text_multiline_set(txt, EINA_FALSE); + efl_text_cursor_object_position_set(cursor, 2); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + efl_text_multiline_set(txt, EINA_TRUE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_eq(rc1.x, rc2.x); + efl_text_multiline_set(txt, EINA_FALSE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_eq(rc1.x, rc2.x); + + efl_text_multiline_set(txt, EINA_FALSE); + efl_text_cursor_object_position_set(cursor, 3); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + efl_text_multiline_set(txt, EINA_TRUE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_ne(rc1.y, rc2.y); + ck_assert_int_ne(rc1.x, rc2.x); + efl_text_multiline_set(txt, EINA_FALSE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_eq(rc1.x, rc2.x); + + efl_text_multiline_set(txt, EINA_FALSE); + efl_text_cursor_object_position_set(cursor, 4); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + efl_text_multiline_set(txt, EINA_TRUE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_ne(rc1.y, rc2.y); + ck_assert_int_ne(rc1.x, rc2.x); + efl_text_multiline_set(txt, EINA_FALSE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_eq(rc1.x, rc2.x); + + efl_text_multiline_set(txt, EINA_FALSE); + efl_text_cursor_object_position_set(cursor, 10); + rc1 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + efl_text_multiline_set(txt, EINA_TRUE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_ne(rc1.y, rc2.y); + ck_assert_int_ne(rc1.x, rc2.x); + efl_text_multiline_set(txt, EINA_FALSE); + rc2 = efl_text_cursor_object_cursor_geometry_get(cursor, EFL_TEXT_CURSOR_TYPE_BEFORE); + ck_assert_int_eq(rc1.y, rc2.y); + ck_assert_int_eq(rc1.x, rc2.x); + + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST + +/* +EFL_START_TEST(text_keyboard_mouse_cluster_cursor_movement) +{ + Eo *txt; + Eo *cursor; + Eo *win = win_add(); + Evas *e; + Eina_Rect rc, rc2; + + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + + efl_gfx_entity_size_set(win, EINA_SIZE2D(300, 300)); + efl_gfx_entity_size_set(txt, EINA_SIZE2D(300, 300)); + efl_ui_textbox_scrollable_set(txt, EINA_TRUE); + get_me_to_those_events(txt); + + efl_text_markup_set(txt, "A\u1100\u1161\u11AA"); + cursor = efl_text_interactive_main_cursor_get(txt); + efl_text_cursor_object_position_set(cursor, 1); + + e = evas_object_evas_get(txt); + efl_ui_focus_util_focus(txt); + evas_event_feed_key_down(e, "Right", "Right", "Right", "Right", time(NULL), NULL); + + ck_assert_int_eq(4, efl_text_cursor_object_position_get(cursor)); + + efl_text_cursor_object_position_set(cursor, 1); + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_CHARACTER_NEXT); + efl_text_cursor_object_move(cursor, EFL_TEXT_CURSOR_MOVE_TYPE_CHARACTER_NEXT); + rc = efl_text_cursor_object_content_geometry_get(cursor); + rc2 = efl_ui_scrollable_viewport_geometry_get(txt); + + efl_text_cursor_object_position_set(cursor, 0); + click_object_at(win, rc2.x + rc.x + (rc.w/2), rc2.y + rc.y + (rc.h/2)); + + ck_assert_int_eq(4, efl_text_cursor_object_position_get(cursor)); + + efl_del(txt); + efl_del(win); +} +EFL_END_TEST +*/ + void efl_ui_test_text(TCase *tc) { tcase_add_test(tc, text_cnp); @@ -160,4 +533,14 @@ void efl_ui_test_text(TCase *tc) tcase_add_test(tc, text_selection); tcase_add_test(tc, text_user_change); tcase_add_test(tc, text_scroll_mode); + tcase_add_test(tc, text_change_event); + tcase_add_test(tc, text_keys_handler); + tcase_add_test(tc, text_editable); + tcase_add_test(tc, text_multiline_selection); + tcase_add_test(tc, text_singleline_cursor_movement); + tcase_add_test(tc, text_multiline_singleline_cursor_pos); + tcase_add_test(tc, text_on_startup); +// works on some systemd and not others - is suepct font or harfbuzz system +// dependency issue... for now - disable. +// tcase_add_test(tc, text_keyboard_mouse_cluster_cursor_movement); } diff --git a/src/tests/elementary/efl_ui_test_timepicker.c b/src/tests/elementary/efl_ui_test_timepicker.c new file mode 100644 index 0000000000..1aca88cc23 --- /dev/null +++ b/src/tests/elementary/efl_ui_test_timepicker.c @@ -0,0 +1,45 @@ +#define EFL_NOLEGACY_API_SUPPORT +#ifdef HAVE_CONFIG_H +# include "elementary_config.h" +#endif +#define EFL_LAYOUT_CALC_PROTECTED +#include <Efl_Ui.h> +#include "efl_ui_suite.h" + +EFL_START_TEST(check_all_times) +{ + Eo *win = win_add(); + Eo *timepicker = efl_add(EFL_UI_TIMEPICKER_CLASS, win); + + for (int min = 0; min < 60; ++min) + { + for (int hour = 0; hour < 24; ++hour) + { + efl_ui_timepicker_time_set(timepicker, hour, min); + } + } +} +EFL_END_TEST + +EFL_START_TEST(check_all_times_24_mode) +{ + Eo *win = win_add(); + Eo *timepicker = efl_add(EFL_UI_TIMEPICKER_CLASS, win, + efl_ui_timepicker_is_24hour_set(efl_added, EINA_TRUE)); + + for (int min = 0; min < 60; ++min) + { + for (int hour = 0; hour < 24; ++hour) + { + efl_ui_timepicker_time_set(timepicker, hour, min); + } + } +} +EFL_END_TEST + +void efl_ui_test_timepicker(TCase *tc) +{ + tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown); + tcase_add_test(tc, check_all_times); + tcase_add_test(tc, check_all_times_24_mode); +} diff --git a/src/tests/elementary/efl_ui_test_vg_animation.c b/src/tests/elementary/efl_ui_test_vg_animation.c new file mode 100644 index 0000000000..2909ede100 --- /dev/null +++ b/src/tests/elementary/efl_ui_test_vg_animation.c @@ -0,0 +1,122 @@ +#ifdef HAVE_CONFIG_H +# include "elementary_config.h" +#endif + +#include <Efl_Ui.h> +#include "efl_ui_suite.h" + +#ifdef BUILD_VG_LOADER_JSON + +EFL_START_TEST(vg_anim_playing_control) +{ + Evas_Object *win, *vg_anim; + win = efl_add(EFL_UI_WIN_CLASS, efl_main_loop_get(), + efl_text_set(efl_added, "Efl_Ui_Vg_Animation demo"), + efl_ui_win_autodel_set(efl_added, EINA_TRUE)); + vg_anim = efl_add(EFL_UI_VG_ANIMATION_CLASS, win, + efl_content_set(win, efl_added)); + + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_NOT_READY); + + // File load + efl_file_simple_load(vg_anim, TESTS_SRC_DIR"/emoji_wink.json", NULL); + ck_assert(efl_file_loaded_get(vg_anim)); + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_STOPPED); + + // Play start + efl_player_playing_set(vg_anim, EINA_TRUE); + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_PLAYING); + + // Play pause + efl_player_paused_set(vg_anim, EINA_TRUE); + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_PAUSED); + + // Play resume + efl_player_paused_set(vg_anim, EINA_FALSE); + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_PLAYING); + + // Playback speed + efl_player_playback_speed_set(vg_anim, 2.0); + ck_assert(EINA_DBL_EQ(efl_player_playback_speed_get(vg_anim), 2.0)); + + efl_player_playback_speed_set(vg_anim, -2.0); + ck_assert(EINA_DBL_EQ(efl_player_playback_speed_get(vg_anim), -2.0)); + + // playing backwards + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_PLAYING_BACKWARDS); + + // Play stop + efl_player_playing_set(vg_anim, EINA_FALSE); + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_STOPPED); + + // Auto repeat + efl_player_playback_loop_set(vg_anim, EINA_TRUE); + ck_assert_int_eq(efl_player_playback_loop_get(vg_anim), EINA_TRUE); + + // Auto play + efl_player_autoplay_set(vg_anim, EINA_TRUE); + ck_assert_int_eq(efl_player_autoplay_get(vg_anim), EINA_TRUE); +} +EFL_END_TEST + +EFL_START_TEST(vg_anim_frame_control) +{ + Evas_Object *win, *vg_anim; + int frame_count = 0; + + win = efl_add(EFL_UI_WIN_CLASS, efl_main_loop_get(), + efl_text_set(efl_added, "Efl_Ui_Vg_Animation demo"), + efl_ui_win_autodel_set(efl_added, EINA_TRUE)); + vg_anim = efl_add(EFL_UI_VG_ANIMATION_CLASS, win, + efl_content_set(win, efl_added)); + + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_NOT_READY); + + // File load + // emoji_wink.json is 60 frames sample. + efl_file_simple_load(vg_anim, TESTS_SRC_DIR"/emoji_wink.json", NULL); + ck_assert(efl_file_loaded_get(vg_anim)); + ck_assert_int_eq(efl_ui_vg_animation_state_get(vg_anim), EFL_UI_VG_ANIMATION_STATE_STOPPED); + + // Total frame + frame_count = efl_ui_vg_animation_frame_count_get(vg_anim); + ck_assert_int_eq(frame_count, 60); + + // Frame set, get + efl_ui_vg_animation_frame_set(vg_anim, 30); + ck_assert_int_eq(efl_ui_vg_animation_frame_get(vg_anim), 30); + + // Frame set, get + efl_player_playback_progress_set(vg_anim, 0.3); + ck_assert(EINA_DBL_EQ(efl_player_playback_progress_get(vg_anim), 0.3)); + + // Min/Max frame set,get + efl_ui_vg_animation_min_frame_set(vg_anim, 5); + ck_assert_int_eq(efl_ui_vg_animation_min_frame_get(vg_anim), 5); + efl_ui_vg_animation_frame_set(vg_anim, 1); + ck_assert_int_eq(efl_ui_vg_animation_frame_get(vg_anim), 5); + + efl_ui_vg_animation_max_frame_set(vg_anim, 55); + ck_assert_int_eq(efl_ui_vg_animation_max_frame_get(vg_anim), 55); + efl_ui_vg_animation_frame_set(vg_anim, 60); + ck_assert_int_eq(efl_ui_vg_animation_frame_get(vg_anim), 55); + + // Min/Max progress set,get + efl_ui_vg_animation_min_progress_set(vg_anim, 0.2); + ck_assert(EINA_DBL_EQ(efl_ui_vg_animation_min_progress_get(vg_anim), 0.2)); + + efl_ui_vg_animation_max_progress_set(vg_anim, 0.8); + ck_assert(EINA_DBL_EQ(efl_ui_vg_animation_max_progress_get(vg_anim), 0.8)); +} +EFL_END_TEST + +#endif + +void efl_ui_test_vg_animation(TCase *tc) +{ + tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown); +#ifdef BUILD_VG_LOADER_JSON + tcase_add_test(tc, vg_anim_playing_control); + tcase_add_test(tc, vg_anim_frame_control); +#endif +} diff --git a/src/tests/elementary/efl_ui_test_widget.c b/src/tests/elementary/efl_ui_test_widget.c index 74e8f2eac9..39d6be4137 100644 --- a/src/tests/elementary/efl_ui_test_widget.c +++ b/src/tests/elementary/efl_ui_test_widget.c @@ -93,7 +93,7 @@ resize_object(Efl_Canvas_Object *o) { Efl_Ui_Widget_Data *pd = efl_data_scope_safe_get(o, EFL_UI_WIDGET_CLASS); - return eina_list_data_get(pd->subobjs); + return eina_array_data_get(pd->children, 0); } EFL_START_TEST(efl_ui_test_widget_widget_sub_iterator) @@ -182,16 +182,16 @@ EFL_START_TEST(efl_ui_test_widget_sub_object_add_del) State s; _small_ui(&s); - DISABLE_ABORT_ON_CRITICAL_START; + EXPECT_ERROR_START; ck_assert(!efl_ui_widget_sub_object_add(s.btn1, s.btn1)); - DISABLE_ABORT_ON_CRITICAL_END; + EXPECT_ERROR_END; ck_assert(efl_ui_widget_sub_object_add(s.box, s.btn1)); - DISABLE_ABORT_ON_CRITICAL_START; + EXPECT_ERROR_START; ck_assert(!efl_ui_widget_sub_object_add(s.box, NULL)); ck_assert(!efl_ui_widget_sub_object_del(s.btn1, s.btn1)); ck_assert(!efl_ui_widget_sub_object_del(s.box, NULL)); ck_assert(!efl_ui_widget_sub_object_del(s.btn1, s.box)); - DISABLE_ABORT_ON_CRITICAL_END; + EXPECT_ERROR_END; ck_assert(efl_ui_widget_sub_object_del(s.box, s.btn1)); } EFL_END_TEST @@ -332,6 +332,116 @@ EFL_START_TEST(efl_ui_test_widget_win_provider_find) } EFL_END_TEST +#define CHECK_UNFOCUSABLE_STATE(x) \ + CHECK_UNFOCUSABLE_STATE_VEC(x, x, x, x, x) + +#define CHECK_UNFOCUSABLE_STATE_VEC(x1, x2, x3, x4, x5) \ + ck_assert_int_eq(elm_widget_tree_unfocusable_get(s.win), x1); \ + ck_assert_int_eq(elm_widget_tree_unfocusable_get(s.ic), x2); \ + ck_assert_int_eq(elm_widget_tree_unfocusable_get(s.box), x3); \ + ck_assert_int_eq(elm_widget_tree_unfocusable_get(s.btn1), x4); \ + ck_assert_int_eq(elm_widget_tree_unfocusable_get(s.btn2), x5) + + +EFL_START_TEST(efl_ui_test_widget_tree_unfocusable) +{ + State s; + + _small_ui(&s); + CHECK_UNFOCUSABLE_STATE(0); + + elm_widget_tree_unfocusable_set(s.win, EINA_TRUE); + CHECK_UNFOCUSABLE_STATE(1); + + elm_widget_tree_unfocusable_set(s.win, EINA_FALSE); + CHECK_UNFOCUSABLE_STATE(0); + + elm_widget_tree_unfocusable_set(s.win, EINA_TRUE); + CHECK_UNFOCUSABLE_STATE(1); + + elm_widget_tree_unfocusable_set(s.win, EINA_TRUE); + CHECK_UNFOCUSABLE_STATE(1); + + elm_widget_tree_unfocusable_set(s.win, EINA_FALSE); + CHECK_UNFOCUSABLE_STATE(0); +} +EFL_END_TEST + +EFL_START_TEST(efl_ui_test_widget_tree_unfocusable_nested_calls) +{ + State s; + + _small_ui(&s); + CHECK_UNFOCUSABLE_STATE(0); + + elm_widget_tree_unfocusable_set(s.win, EINA_TRUE); + CHECK_UNFOCUSABLE_STATE(1); + + elm_widget_tree_unfocusable_set(s.box, EINA_TRUE); + CHECK_UNFOCUSABLE_STATE(1); + + elm_widget_tree_unfocusable_set(s.win, EINA_FALSE); + CHECK_UNFOCUSABLE_STATE_VEC(0, 0, 1, 1, 1); + + elm_widget_tree_unfocusable_set(s.box, EINA_FALSE); + CHECK_UNFOCUSABLE_STATE(0); +} +EFL_END_TEST + +#define CHECK_DISABLED_STATE(x) CHECK_DISABLED_STATE_VEC(x,x,x,x,x) + +#define CHECK_DISABLED_STATE_VEC(x1,x2,x3,x4,x5) \ + ck_assert_int_eq(efl_ui_widget_disabled_get(s.win), x1); \ + ck_assert_int_eq(efl_ui_widget_disabled_get(s.ic), x2); \ + ck_assert_int_eq(efl_ui_widget_disabled_get(s.box), x3); \ + ck_assert_int_eq(efl_ui_widget_disabled_get(s.btn1), x4); \ + ck_assert_int_eq(efl_ui_widget_disabled_get(s.btn2), x5) + +EFL_START_TEST(efl_ui_test_widget_disabled_repeat_call) +{ + State s; + + _small_ui(&s); + CHECK_DISABLED_STATE(0); + + efl_ui_widget_disabled_set(s.win, EINA_TRUE); + CHECK_DISABLED_STATE(1); + + efl_ui_widget_disabled_set(s.win, EINA_FALSE); + CHECK_DISABLED_STATE(0); + + efl_ui_widget_disabled_set(s.win, EINA_TRUE); + CHECK_DISABLED_STATE(1); + + efl_ui_widget_disabled_set(s.win, EINA_TRUE); + CHECK_DISABLED_STATE(1); + + efl_ui_widget_disabled_set(s.win, EINA_FALSE); + CHECK_DISABLED_STATE(0); +} +EFL_END_TEST + +EFL_START_TEST(efl_ui_test_widget_disabled_nested_calls) +{ + State s; + + _small_ui(&s); + CHECK_DISABLED_STATE(0); + + efl_ui_widget_disabled_set(s.win, EINA_TRUE); + CHECK_DISABLED_STATE(1); + + efl_ui_widget_disabled_set(s.box, EINA_TRUE); + CHECK_DISABLED_STATE(1); + + efl_ui_widget_disabled_set(s.win, EINA_FALSE); + CHECK_DISABLED_STATE_VEC(0, 0, 1, 1, 1); + + efl_ui_widget_disabled_set(s.box, EINA_FALSE); + CHECK_DISABLED_STATE(0); +} +EFL_END_TEST + void efl_ui_test_widget(TCase *tc) { tcase_add_checked_fixture(tc, fail_on_errors_setup, fail_on_errors_teardown); @@ -346,4 +456,8 @@ void efl_ui_test_widget(TCase *tc) tcase_add_test(tc, efl_ui_test_widget_disabled_parent); tcase_add_test(tc, efl_ui_test_widget_disabled_behaviour); tcase_add_test(tc, efl_ui_test_widget_win_provider_find); + tcase_add_test(tc, efl_ui_test_widget_tree_unfocusable); + tcase_add_test(tc, efl_ui_test_widget_tree_unfocusable_nested_calls); + tcase_add_test(tc, efl_ui_test_widget_disabled_repeat_call); + tcase_add_test(tc, efl_ui_test_widget_disabled_nested_calls); } diff --git a/src/tests/elementary/efl_ui_window_cnp_dnd_slave.c b/src/tests/elementary/efl_ui_window_cnp_dnd_slave.c new file mode 100644 index 0000000000..43aafa5470 --- /dev/null +++ b/src/tests/elementary/efl_ui_window_cnp_dnd_slave.c @@ -0,0 +1,191 @@ +#define EFL_BETA_API_SUPPORT 1 + +#include <Efl.h> +#include <Efl_Ui.h> +#include <Elementary.h> +#include "efl_ui_grid_view.eo.h" + +static Ecore_Evas *ee; + +static Eina_Value +_deliverty_cb(void *data, const Eina_Value value, const Eina_Future *dead_future EINA_UNUSED) +{ + Ecore_Evas_Selection_Buffer buffer = (intptr_t)data; + Eina_Content *content; + + if (eina_value_type_get(&value) != EINA_VALUE_TYPE_CONTENT) + { + char *error = eina_value_to_string(&value); + printf("Value not a content, message: \"%s\"\n", error); + return EINA_VALUE_EMPTY; + } + + content = eina_value_to_content(&value); + printf("Got Content of selection %d with type %s\n", buffer, eina_content_type_get(content)); + if (eina_str_has_prefix(eina_content_type_get(content),"text")) + { + printf("Content: %s\n", (char*)eina_content_data_get(content).mem); + } + + return EINA_VALUE_EMPTY; +} + +static void +_selection_changed(Ecore_Evas *ee, unsigned int seat EINA_UNUSED, Ecore_Evas_Selection_Buffer selection) +{ + printf("Selection %d of %p has changed\n", selection, ee); +} + +static void +_request_selection(Ecore_Evas *ee, unsigned int seat EINA_UNUSED, Ecore_Evas_Selection_Buffer selection) +{ + const char *types[] = {eina_stringshare_add("text/plain"), eina_stringshare_add("text/plain;charset=utf-8")}; + printf("Selection %d of %p has changed\n", selection, ee); + Eina_Future *future = ecore_evas_selection_get(ee, 0, selection, EINA_C_ARRAY_ITERATOR_NEW(types)); + eina_future_then(future, _deliverty_cb, .data = ((void*)(intptr_t)selection)); +} + +static void +_motion_cb(Ecore_Evas *ee, unsigned int seat EINA_UNUSED, Eina_Position2D p) +{ + printf("Drag and Drop has moved on the window %p (%d, %d)\n", ee, p.x, p.y); +} + +static void +_enter_state_change_cb(Ecore_Evas *ee, unsigned int seat EINA_UNUSED, Eina_Position2D p, Eina_Bool inside) +{ + if (inside) + printf("Drag and Drop has entered the window %p (%d, %d)\n", ee, p.x, p.y); + else + printf("Drag and Drop has left the window %p (%d, %d)\n", ee, p.x, p.y); +} + +static void +_drop_cb(Ecore_Evas *ee, unsigned int seat EINA_UNUSED, Eina_Position2D p, const char *action EINA_UNUSED) +{ + const char *types[] = {eina_stringshare_add("text/plain")}; + printf("Drag and Drop has droped on the window %p (%d, %d)\n", ee, p.x, p.y); + Eina_Future *f = ecore_evas_selection_get(ee, 0, ECORE_EVAS_SELECTION_BUFFER_DRAG_AND_DROP_BUFFER, EINA_C_ARRAY_ITERATOR_NEW(types)); + eina_future_then(f, _deliverty_cb, .data = ((void*)(intptr_t)ECORE_EVAS_SELECTION_BUFFER_DRAG_AND_DROP_BUFFER)); +} + +static void +_efl_ui_terminated(Ecore_Evas *ee EINA_UNUSED, unsigned int seat EINA_UNUSED, void *data, Eina_Bool accepted EINA_UNUSED) +{ + efl_del(data); +} + +static Eo* +_start_dnd(Ecore_Evas *ee) +{ + Ecore_Evas *ee2; + Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL("This is sample content"), "text/plain"); + Efl_Ui_Win *win; + Efl_Ui_Button *btn; + + win = efl_add(EFL_UI_WIN_CLASS, efl_main_loop_get()); + ee2 = ecore_evas_ecore_evas_get(evas_object_evas_get(win)); + + btn = efl_add(EFL_UI_BUTTON_CLASS, win); + efl_text_set(btn, "Test"); + efl_content_set(win, btn); + + evas_object_geometry_set(win, 0, 0, 100, 100); + + ecore_evas_drag_start(ee, 0, content, ee2, "copy", _efl_ui_terminated, win); + + return win; +} + +static void +_start_op(void *data, const Efl_Event *ev EINA_UNUSED) +{ + _start_dnd(data); +} + +static Eina_Value +_delete_cb(Eo *obj, void *data EINA_UNUSED, const Eina_Value value EINA_UNUSED) +{ + Ecore_Evas *ee ; + ee = ecore_evas_ecore_evas_get(evas_object_evas_get(obj)); + + ecore_evas_drag_cancel(ee, 0); + + return EINA_VALUE_EMPTY; +} + +static void +_start_delayed_del_op(void *data, const Efl_Event *ev EINA_UNUSED) +{ + _start_dnd(data); + efl_future_then(ev->object, efl_loop_timeout(efl_main_loop_get(), 2.0), _delete_cb); +} + +EAPI_MAIN void +efl_main(void *data EINA_UNUSED, const Efl_Event *ev) +{ + Efl_Ui_Textbox *txt, *win, *bx, *btn; + Efl_Loop_Arguments *args = ev->info; + char *goal; + + win = efl_add(EFL_UI_WIN_CLASS, efl_main_loop_get()); + ee = ecore_evas_ecore_evas_get(evas_object_evas_get(win)); + + bx = efl_add(EFL_UI_BOX_CLASS, win); + + txt = efl_add(EFL_UI_TEXTBOX_CLASS, win); + efl_text_set(txt, "Sample for CNP and DND interaction"); + efl_pack_end(bx, txt); + + btn = efl_add(EFL_UI_BUTTON_CLASS, win); + efl_gfx_hint_weight_set(btn, 1.0, 0.0); + efl_event_callback_add(btn, EFL_INPUT_EVENT_PRESSED, _start_op, ee); + efl_text_set(btn, "Start DND op"); + efl_pack_end(bx, btn); + + btn = efl_add(EFL_UI_BUTTON_CLASS, win); + efl_gfx_hint_weight_set(btn, 1.0, 0.0); + efl_event_callback_add(btn, EFL_INPUT_EVENT_PRESSED, _start_delayed_del_op, ee); + efl_text_set(btn, "Start DND op self destroy after 2 sec"); + efl_pack_end(bx, btn); + + efl_content_set(win, bx); + efl_gfx_entity_size_set(win, EINA_SIZE2D(320, 320)); + + goal = eina_array_data_get(args->argv, 1); + + if (eina_streq(goal, "--monitor")) + { + ecore_evas_callback_selection_changed_set(ee, _selection_changed); + ecore_evas_callback_drop_drop_set(ee, _drop_cb); + ecore_evas_callback_drop_motion_set(ee, _motion_cb); + ecore_evas_callback_drop_state_changed_set(ee, _enter_state_change_cb); + } + else if (eina_streq(goal, "--show-selections")) + { + ecore_evas_callback_selection_changed_set(ee, _request_selection); + } + else if (eina_streq(goal, "--set-selection")) + { + if (eina_array_count(args->argv) < 3) + { + printf("Error, --set-selection only requires exactly 1 keyword (The selection to set).\n"); + return; + } + char *selection = eina_array_data_get(args->argv, 2); + Eina_Content *content = eina_content_new((Eina_Slice)EINA_SLICE_STR_FULL(selection), "text/plain"); + ecore_evas_selection_set(ee, 0, ECORE_EVAS_SELECTION_BUFFER_COPY_AND_PASTE_BUFFER, content); + } + else if (eina_streq(goal, "--show-owner")) + { + for (int i = 0; i < ECORE_EVAS_SELECTION_BUFFER_LAST; ++i) + { + printf("Selection buffer %d : %d\n", i, ecore_evas_selection_exists(ee, 0, i)); + } + } + else + { + printf("Error, goal %s not found\n", goal); + } +} +EFL_MAIN() diff --git a/src/tests/elementary/elm_code_file_test_load.c b/src/tests/elementary/elm_code_file_test_load.c index 31539e9666..44803ba77e 100644 --- a/src/tests/elementary/elm_code_file_test_load.c +++ b/src/tests/elementary/elm_code_file_test_load.c @@ -4,6 +4,10 @@ #include <libgen.h> +#ifdef _WIN32 +# include <evil_private.h> /* realpath() */ +#endif + #include "elm_suite.h" #include "Elementary.h" diff --git a/src/tests/elementary/elm_code_test_basic.c b/src/tests/elementary/elm_code_test_basic.c index 8d4012eef9..e264e62011 100644 --- a/src/tests/elementary/elm_code_test_basic.c +++ b/src/tests/elementary/elm_code_test_basic.c @@ -4,6 +4,10 @@ #include <stdlib.h> +#ifdef _WIN32 +# include <evil_private.h> /* realpath() */ +#endif + #include "elm_suite.h" #include "Elementary.h" diff --git a/src/tests/elementary/elm_test_entry.c b/src/tests/elementary/elm_test_entry.c index 1b383b2936..85ada68a49 100644 --- a/src/tests/elementary/elm_test_entry.c +++ b/src/tests/elementary/elm_test_entry.c @@ -155,28 +155,28 @@ EFL_START_TEST(elm_entry_atspi_text_string_get_char) elm_object_text_set(entry, txt); start = 1; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end, &val); ck_assert_str_eq(val, "o"); ck_assert(start == 1); ck_assert(end == 2); if (val) free(val); start = 8; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end, &val); ck_assert_str_eq(val, "ś"); ck_assert(start == 8); ck_assert(end == 9); if (val) free(val); start = 11; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end, &val); ck_assert_str_eq(val, " "); ck_assert(start == 11); ck_assert(end == 12); if (val) free(val); start = 111; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_CHAR, &start, &end, &val); ck_assert(start == -1); ck_assert(end == -1); ck_assert(val == NULL); @@ -198,28 +198,28 @@ EFL_START_TEST(elm_entry_atspi_text_string_get_word) elm_object_text_set(entry, txt); start = 1; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end, &val); ck_assert_str_eq(val, "Lorem"); ck_assert(start == 0); ck_assert(end == 5); if (val) free(val); start = 6; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end, &val); ck_assert_str_eq(val, "ipśum"); ck_assert(start == 6); ck_assert(end == 11); if (val) free(val); start = 19; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end, &val); ck_assert_str_eq(val, "dolor"); ck_assert(start == 14); ck_assert(end == 19); if (val) free(val); start = 111; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end, &val); ck_assert(start == -1); ck_assert(end == -1); ck_assert(val == NULL); @@ -242,28 +242,28 @@ EFL_START_TEST(elm_entry_atspi_text_string_get_paragraph) elm_object_text_set(entry, txt); start = 1; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_PARAGRAPH, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_PARAGRAPH, &start, &end, &val); ck_assert_str_eq(val, "Lorem ipśum"); ck_assert(start == 0); ck_assert(end == 11); if (val) free(val); start = 20; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_PARAGRAPH, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_PARAGRAPH, &start, &end, &val); ck_assert_str_eq(val, " dolor sit"); ck_assert(start == 12); ck_assert(end == 24); if (val) free(val); start = 25; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_PARAGRAPH, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_PARAGRAPH, &start, &end, &val); ck_assert_str_eq(val, " amęt"); ck_assert(start == 25); ck_assert(end == 30); if (val) free(val); start = 111; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_WORD, &start, &end, &val); ck_assert(start == -1); ck_assert(end == -1); ck_assert(val == NULL); @@ -288,7 +288,7 @@ EFL_START_TEST(elm_entry_atspi_text_string_get_line) elm_object_text_set(entry, txt); start = 1; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_LINE, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_LINE, &start, &end, &val); ck_assert_str_eq(val, "Lorem ipśum"); ck_assert(start == 0); @@ -296,7 +296,7 @@ EFL_START_TEST(elm_entry_atspi_text_string_get_line) if (val) free(val); start = 13; - val = efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_LINE, &start, &end); + efl_access_text_string_get(entry, EFL_ACCESS_TEXT_GRANULARITY_LINE, &start, &end, &val); ck_assert_str_eq(val, " dolor sit amęt"); ck_assert(start == 12); ck_assert(end == 29); @@ -480,6 +480,26 @@ EFL_START_TEST(elm_entry_text_set) } EFL_END_TEST +EFL_START_TEST(elm_entry_guide_text_set) +{ + Evas_Object *win, *entry; + const char *markup_text = "<font_size=32 color=#FFF>markup_test</font_size>"; + const char *markup_text2 = "<font_size=24 color=#FFF>test_markup</font_size>"; + + win = win_add(NULL, "entry", ELM_WIN_BASIC); + + entry = elm_entry_add(win); + + elm_object_part_text_set(entry, "elm.guide", markup_text); + elm_entry_editable_set(entry, EINA_FALSE); + ck_assert_str_eq(elm_object_part_text_get(entry, "elm.guide"), markup_text); + + elm_object_part_text_set(entry, "elm.guide", markup_text2); + elm_entry_single_line_set(entry, EINA_FALSE); + ck_assert_str_eq(elm_object_part_text_get(entry, "elm.guide"), markup_text2); +} +EFL_END_TEST + EFL_START_TEST(elm_entry_file_get_set) { Evas_Object *win, *entry; @@ -518,6 +538,143 @@ EFL_START_TEST(elm_entry_file_get_set) } EFL_END_TEST +EFL_START_TEST(elm_entry_test_text_class) +{ + Evas_Object *win, *entry1, *entry2, *entry3, *entry4; + const char *filename = NULL; + int w1 = 0, h1 = 0, w2 = 0, h2 = 0, w3 = 0, h3 = 0; + const char *font; + int font_size; + + win = win_add(NULL, "entry", ELM_WIN_BASIC); + entry1 = elm_entry_add(win); + entry2 = elm_entry_add(win); + entry3 = elm_entry_add(win); + + elm_object_text_set(entry1, "hello"); + elm_object_text_set(entry2, "hello"); + elm_object_text_set(entry3, "hello"); + + edje_object_file_get(elm_layout_edje_get(entry1), &filename, NULL); + ck_assert(filename != NULL); + + ck_assert(edje_file_text_class_set(filename, "entry_text", "Serif:Style=Bold", 24)); + + ck_assert(edje_object_text_class_get(elm_layout_edje_get(entry1), "entry_text", &font, &font_size)); + ck_assert_int_eq(font_size, 24); + ck_assert_str_eq(font, "Serif:Style=Bold"); + ck_assert(edje_object_text_class_get(elm_layout_edje_get(entry2), "entry_text", &font, &font_size)); + ck_assert_int_eq(font_size, 24); + ck_assert_str_eq(font, "Serif:Style=Bold"); + ck_assert(edje_object_text_class_get(elm_layout_edje_get(entry3), "entry_text", &font, &font_size)); + ck_assert_int_eq(font_size, 24); + ck_assert_str_eq(font, "Serif:Style=Bold"); + + evas_object_textblock_size_formatted_get(elm_entry_textblock_get(entry1), &w1, &h1); + evas_object_textblock_size_formatted_get(elm_entry_textblock_get(entry2), &w2, &h2); + evas_object_textblock_size_formatted_get(elm_entry_textblock_get(entry3), &w3, &h3); + + ck_assert_int_eq(w1, w2); + ck_assert_int_eq(h1, h2); + ck_assert_int_eq(w2, w3); + ck_assert_int_eq(h2, h3); + + ck_assert(edje_object_text_class_set(elm_layout_edje_get(entry1), "entry_text", "Sans", 50)); + ck_assert(edje_object_text_class_set(elm_layout_edje_get(entry2), "entry_text", "Serif", 20)); + + ck_assert(edje_object_text_class_get(elm_layout_edje_get(entry1), "entry_text", &font, &font_size)); + ck_assert_int_eq(font_size, 50); + ck_assert_str_eq(font, "Sans"); + ck_assert(edje_object_text_class_get(elm_layout_edje_get(entry2), "entry_text", &font, &font_size)); + ck_assert_int_eq(font_size, 20); + ck_assert_str_eq(font, "Serif"); + ck_assert(edje_object_text_class_get(elm_layout_edje_get(entry3), "entry_text", &font, &font_size)); + ck_assert_int_eq(font_size, 24); + ck_assert_str_eq(font, "Serif:Style=Bold"); + + evas_object_textblock_size_formatted_get(elm_entry_textblock_get(entry1), &w1, &h1); + evas_object_textblock_size_formatted_get(elm_entry_textblock_get(entry2), &w2, &h2); + evas_object_textblock_size_formatted_get(elm_entry_textblock_get(entry3), &w3, &h3); + + ck_assert_int_ne(w1, w2); + ck_assert_int_ne(h1, h2); + ck_assert_int_ne(w2, w3); + ck_assert_int_ne(h2, h3); + + entry4 = elm_entry_add(win); + + elm_object_text_set(entry4, "hello"); + ck_assert(edje_object_text_class_get(elm_layout_edje_get(entry4), "entry_text", &font, &font_size)); + ck_assert_int_eq(font_size, 24); + ck_assert_str_eq(font, "Serif:Style=Bold"); +} +EFL_END_TEST + +EFL_START_TEST(elm_entry_test_burmese) +{ + Evas_Object *win, *textblock; + Evas_Textblock_Style *style; + int w; + + win = win_add(NULL, "entry", ELM_WIN_BASIC); + textblock = evas_object_textblock_add(win); + + style = evas_textblock_style_new(); + evas_textblock_style_set(style, "DEFAULT='font=arial font_size=20 color=red'"); + evas_object_textblock_style_set(textblock, style); + evas_textblock_style_free(style); + style = NULL; + + evas_object_textblock_text_markup_set(textblock, "\u1006\u200C\u1031\u200C\u1031\u200C\u1031"); + evas_object_textblock_size_native_get(textblock, &w, NULL); + ck_assert_int_ne(w, 0); +} +EFL_END_TEST + +EFL_START_TEST(elm_entry_keycode) +{ + Evas_Object *win, *entry; + + win = win_add(NULL, "entry", ELM_WIN_BASIC); + entry = elm_entry_add(win); + evas_object_show(entry); + + elm_entry_entry_set(entry, "Hello World"); + Evas *e = evas_object_evas_get(entry); + elm_object_focus_set(entry, EINA_TRUE); + evas_key_modifier_on(e, "Control"); + evas_event_feed_key_down_with_keycode(e, "", "a", "", "", time(NULL), NULL, 38); + ecore_main_loop_iterate(); + evas_event_feed_key_down(e, "BackSpace", "BackSpace", "\b", "\b", time(NULL), NULL); + ck_assert_str_eq(elm_object_text_get(entry), ""); + + evas_object_del(entry); + evas_object_del(win); +} +EFL_END_TEST + +EFL_START_TEST(elm_entry_textnodes_with_no_format) +{ + Evas_Object *win, *entry; + + win = win_add(NULL, "entry", ELM_WIN_BASIC); + entry = elm_entry_add(win); + evas_object_show(entry); + + elm_entry_entry_set(entry, "<br/><br/>"); + Evas_Object *tb = elm_entry_textblock_get(entry); + Evas_Textblock_Cursor *c1 = evas_object_textblock_cursor_new(tb); + Evas_Textblock_Cursor *c2 = evas_object_textblock_cursor_new(tb); + evas_textblock_cursor_char_next(c2); + evas_textblock_cursor_range_delete(c1, c2); + elm_entry_cursor_pos_set(entry, 0); + ck_assert(elm_entry_cursor_down(entry)); + + evas_object_del(entry); + evas_object_del(win); +} +EFL_END_TEST + void elm_test_entry(TCase *tc) { tcase_add_test(tc, elm_entry_legacy_type_check); @@ -533,6 +690,11 @@ void elm_test_entry(TCase *tc) tcase_add_test(tc, elm_entry_atspi_text_selections); tcase_add_test(tc, elm_atspi_role_get); tcase_add_test(tc, elm_entry_text_set); + tcase_add_test(tc, elm_entry_guide_text_set); tcase_add_test(tc, elm_entry_magnifier); tcase_add_test(tc, elm_entry_file_get_set); + tcase_add_test(tc, elm_entry_test_text_class); + tcase_add_test(tc, elm_entry_test_burmese); + tcase_add_test(tc, elm_entry_keycode); + tcase_add_test(tc, elm_entry_textnodes_with_no_format); } diff --git a/src/tests/elementary/elm_test_hover.c b/src/tests/elementary/elm_test_hover.c index de275216f2..323eb5c8d6 100644 --- a/src/tests/elementary/elm_test_hover.c +++ b/src/tests/elementary/elm_test_hover.c @@ -41,8 +41,56 @@ EFL_START_TEST(elm_atspi_role_get) } EFL_END_TEST +EFL_START_TEST(elm_test_hover_behavior) +{ + Evas_Object *win, *hover, *target, *rect; + int count = 0; + int count_dismiss = 0; + int count_clicked = 0; + + win = win_add(NULL, "hover", ELM_WIN_BASIC); + evas_object_resize(win, 100, 100); + + hover = elm_hover_add(win); + evas_object_smart_callback_add(hover, "smart,changed", event_callback_that_increments_an_int_when_called, &count); + evas_object_smart_callback_add(hover, "dismissed", event_callback_single_call_int_data, &count_dismiss); + evas_object_smart_callback_add(hover, "clicked", event_callback_single_call_int_data, &count_clicked); + + target = elm_box_add(win); + + elm_hover_parent_set(hover, win); + elm_hover_target_set(hover, target); + + rect = evas_object_rectangle_add(evas_object_evas_get(win)); + evas_object_size_hint_min_set(rect, 20, 20); + evas_object_show(rect); + elm_object_part_content_set(hover, "smart", rect); + + evas_object_move(target, 40, 40); + evas_object_show(win); + evas_object_show(hover); + get_me_to_those_events(hover); + + /* 1 from setting content, 1 from moving target object */ + ck_assert_int_eq(count, 2); + + assert_object_size_eq(rect, 20, 20); + assert_object_size_eq(hover, 0, 0); + assert_object_pos_eq(hover, 40, 40); + /* using non-centered slot */ + assert_object_pos_eq(rect, 40, 30); + + elm_hover_dismiss(hover); + get_me_to_those_events(hover); + /* these are both triggered on dismiss */ + ck_assert_int_eq(count_dismiss, 1); + ck_assert_int_eq(count_clicked, 1); +} +EFL_END_TEST + void elm_test_hover(TCase *tc) { tcase_add_test(tc, elm_hover_legacy_type_check); tcase_add_test(tc, elm_atspi_role_get); + tcase_add_test(tc, elm_test_hover_behavior); } diff --git a/src/tests/elementary/elm_test_hoversel.c b/src/tests/elementary/elm_test_hoversel.c index 91de6afee0..e00a073b09 100644 --- a/src/tests/elementary/elm_test_hoversel.c +++ b/src/tests/elementary/elm_test_hoversel.c @@ -6,6 +6,9 @@ #include <Elementary.h> #include "elm_suite.h" +#include "elm_priv.h" +#include "elm_widget_hoversel.h" + EFL_START_TEST(elm_hoversel_legacy_type_check) { Evas_Object *win, *hoversel; @@ -41,8 +44,115 @@ EFL_START_TEST(elm_atspi_role_get) } EFL_END_TEST +EFL_START_TEST(elm_test_hoversel_behavior) +{ + Eo *hoversel, *win = win_add(); + unsigned int i; + const char *callbacks[] = + { + "expanded", + "clicked", + "selected", + "item,focused", + "item,unfocused", + "dismissed", + }; + int count[EINA_C_ARRAY_LENGTH(callbacks)] = {0}; + + evas_object_resize(win, 500, 500); + hoversel = elm_hoversel_add(win); + evas_object_geometry_set(hoversel, 25, 25, 50, 50); + elm_hoversel_hover_parent_set(hoversel, win); + elm_object_text_set(hoversel, "Vertical"); + elm_hoversel_item_add(hoversel, "Item 1", NULL, ELM_ICON_NONE, NULL, NULL); + elm_hoversel_item_add(hoversel, "Item 2", NULL, ELM_ICON_NONE, NULL, NULL); + elm_hoversel_item_add(hoversel, "Item 3", NULL, ELM_ICON_NONE, NULL, NULL); + elm_hoversel_item_add(hoversel, "Item 4 - Long Label Here", "close", ELM_ICON_STANDARD, NULL, NULL); + + evas_object_show(win); + evas_object_show(hoversel); + elm_object_focus_set(hoversel, EINA_TRUE); + for (i = 0; i < EINA_C_ARRAY_LENGTH(count); i++) + { + evas_object_smart_callback_add(hoversel, callbacks[i], + (void*)event_callback_single_call_int_data, &count[i]); + } + evas_object_smart_callback_add(hoversel, "dismissed", + (void*)event_callback_that_quits_the_main_loop_when_called, NULL); + get_me_to_those_events(win); + assert_object_size_eq(hoversel, 50, 50); + click_object(hoversel); + get_me_to_those_events(win); + + /* expanded */ + ck_assert_int_eq(count[0], 1); + wait_timer(0.6); // from default theme + ecore_main_loop_iterate(); + + ELM_HOVERSEL_DATA_GET(hoversel, sd); + click_object(eina_list_data_get(elm_box_children_get(sd->bx))); + get_me_to_those_events(win); + + /* clicked */ + ck_assert_int_eq(count[1], 1); + /* selected */ + ck_assert_int_eq(count[2], 1); + /* item,focused */ + ck_assert_int_eq(count[3], 1); + /* item,focused */ + ck_assert_int_eq(count[4], 1); + ecore_main_loop_begin(); + + /* dismissed */ + ck_assert_int_eq(count[5], 1); +} +EFL_END_TEST + +EFL_START_TEST(elm_test_hoversel_position) +{ + Eo *hoversel, *win = win_add(); + + evas_object_resize(win, 500, 500); + hoversel = elm_hoversel_add(win); + evas_object_geometry_set(hoversel, 450, 450, 50, 50); + elm_hoversel_hover_parent_set(hoversel, win); + elm_object_text_set(hoversel, "Vertical"); + elm_hoversel_item_add(hoversel, "Item 1", NULL, ELM_ICON_NONE, NULL, NULL); + elm_hoversel_item_add(hoversel, "Item 2", NULL, ELM_ICON_NONE, NULL, NULL); + elm_hoversel_item_add(hoversel, "Item 3", NULL, ELM_ICON_NONE, NULL, NULL); + elm_hoversel_item_add(hoversel, "Item 4 - Long Label Here", "close", ELM_ICON_STANDARD, NULL, NULL); + + evas_object_show(win); + evas_object_show(hoversel); + elm_object_focus_set(hoversel, EINA_TRUE); + + get_me_to_those_events(win); + assert_object_size_eq(hoversel, 50, 50); + click_object(hoversel); + get_me_to_those_events(win); + + wait_timer(0.6); // from default theme + ecore_main_loop_iterate(); + + ELM_HOVERSEL_DATA_GET(hoversel, sd); + { + int x, y, w, h; + Eo *item = eina_list_data_get(elm_box_children_get(sd->bx)); + evas_object_geometry_get(item, &x, &y, &w, &h); + + /* verify that all buttons are in-canvas */ + ck_assert_int_le(x + w, 500); + ck_assert_int_le(y + h, 500); + } + + evas_object_del(hoversel); +} +EFL_END_TEST + void elm_test_hoversel(TCase *tc) { tcase_add_test(tc, elm_hoversel_legacy_type_check); tcase_add_test(tc, elm_atspi_role_get); + tcase_add_test(tc, elm_test_hoversel_behavior); + tcase_add_test(tc, elm_test_hoversel_position); } diff --git a/src/tests/elementary/elm_test_icon.c b/src/tests/elementary/elm_test_icon.c index 517ace64a2..cf5329cc25 100644 --- a/src/tests/elementary/elm_test_icon.c +++ b/src/tests/elementary/elm_test_icon.c @@ -41,8 +41,34 @@ EFL_START_TEST(elm_atspi_role_get) } EFL_END_TEST +EFL_START_TEST(elm_test_icon_set) +{ + Evas_Object *win, *image; + Eina_Bool ok; + const char *icon_name; + + win = win_add(NULL, "icon", ELM_WIN_BASIC); + + image = elm_icon_add(win); + evas_object_show(image); + + ok = elm_icon_standard_set(image, "folder"); + ck_assert(ok); + icon_name = elm_icon_standard_get(image); + ck_assert_str_eq(icon_name, "folder"); + + ok = elm_icon_standard_set(image, "None"); + ck_assert(ok == 0); + icon_name = elm_icon_standard_get(image); + /* elm_icon only changes internal name on success */ + ck_assert_str_eq(icon_name, "folder"); + +} +EFL_END_TEST + void elm_test_icon(TCase *tc) { tcase_add_test(tc, elm_icon_legacy_type_check); tcase_add_test(tc, elm_atspi_role_get); + tcase_add_test(tc, elm_test_icon_set); } diff --git a/src/tests/elementary/elm_test_image.c b/src/tests/elementary/elm_test_image.c index 6d6ff52f6f..25aac89a42 100644 --- a/src/tests/elementary/elm_test_image.c +++ b/src/tests/elementary/elm_test_image.c @@ -18,6 +18,34 @@ struct _Test_Data int success; }; +static int +_file_to_memory(const char *filename, char **result) +{ + int size; + FILE *f; + + f = fopen(filename, "rb"); + if (f == NULL) + { + *result = NULL; + return -1; + } + + fseek(f, 0, SEEK_END); + size = ftell(f); + fseek(f, 0, SEEK_SET); + *result = (char *)malloc(size + 1); + if ((size_t)size != fread(*result, sizeof(char), size, f)) + { + free(*result); + fclose(f); + return -1; + } + fclose(f); + (*result)[size] = 0; + return size; +} + EFL_START_TEST(elm_image_legacy_type_check) { Evas_Object *win, *image; @@ -227,30 +255,109 @@ EFL_START_TEST(elm_image_evas_image_get) } EFL_END_TEST -EFL_START_TEST(efl_ui_image_icon) +EFL_START_TEST(elm_image_test_memfile_set) +{ + Evas_Object *win, *image, *image2; + char *mem; + int size; + const char *file = NULL; + int error_called = 0; + + win = win_add(NULL, "image", ELM_WIN_BASIC); + + image = elm_image_add(win); + ck_assert(elm_image_file_set(image, ELM_IMAGE_DATA_DIR"/images/icon_01.png", NULL)); + size = _file_to_memory(ELM_IMAGE_DATA_DIR"/images/icon_02.png", &mem); + ck_assert_int_ge(size, 0); + ck_assert(elm_image_memfile_set(image, mem, size, "png", NULL)); + elm_image_file_get(image, &file, NULL); + ck_assert_str_ne(file, ELM_IMAGE_DATA_DIR"/images/icon_01.png"); + ck_assert(elm_image_file_set(image, ELM_IMAGE_DATA_DIR"/images/icon_01.png", NULL)); + elm_image_file_get(image, &file, NULL); + ck_assert_str_eq(file, ELM_IMAGE_DATA_DIR"/images/icon_01.png"); + + image2 = elm_image_add(win); + evas_object_smart_callback_add(image2, "load,ready", event_callback_that_quits_the_main_loop_when_called, NULL); + evas_object_smart_callback_add(image2, "load,error", event_callback_single_call_int_data, &error_called); + ck_assert(elm_image_memfile_set(image2, mem, size, "png", NULL)); + ck_assert_int_eq(error_called, 0); + ecore_main_loop_begin(); + + ck_assert_int_eq(error_called, 0); +} +EFL_END_TEST + +EFL_START_TEST(elm_image_test_scale_method) { Evas_Object *win, *image; - Eina_Bool ok; - const char *icon_name; + int w, h; win = win_add(NULL, "image", ELM_WIN_BASIC); + evas_object_resize(win, 100, 100); - image = efl_add(EFL_UI_IMAGE_CLASS, win); + image = elm_image_add(win); + ck_assert(elm_image_file_set(image, ELM_IMAGE_DATA_DIR"/images/logo.png", NULL)); + evas_object_size_hint_align_set(image, 0.5, 0.0); + efl_gfx_image_scale_method_set(image, EFL_GFX_IMAGE_SCALE_METHOD_FIT_WIDTH); + evas_object_resize(image, 100, 100); evas_object_show(image); + evas_object_show(win); + get_me_to_those_events(win); + evas_object_geometry_get(image, NULL, NULL, &w, &h); + ck_assert_int_eq(w, 100); + ck_assert_int_eq(h, 100); + evas_object_geometry_get(elm_image_object_get(image), NULL, NULL, &w, &h); + ck_assert_int_eq(w, 100); + ck_assert_int_eq(h, 100); +} +EFL_END_TEST - ok = efl_ui_image_icon_set(image, "folder"); - ck_assert(ok); - icon_name = efl_ui_image_icon_get(image); - ck_assert_str_eq(icon_name, "folder"); +#ifdef BUILD_LOADER_GIF +static void +_test_render(void *data, Evas *e EINA_UNUSED, void *event_info) +{ + int *pass = data; + Evas_Event_Render_Post *ev = event_info; + *pass = eina_list_count(ev->updated_area); + ecore_main_loop_quit(); +} + +static void +_test_preload(void *data, Evas *e, Evas_Object *obj, void *event_info EINA_UNUSED) +{ + if (evas_object_image_load_error_get(obj) == EVAS_LOAD_ERROR_NONE) + evas_event_callback_add(e, EVAS_CALLBACK_RENDER_POST, _test_render, data); + else + ecore_main_loop_quit(); +} - ok = efl_ui_image_icon_set(image, "None"); - ck_assert(ok == 0); - icon_name = efl_ui_image_icon_get(image); - ck_assert(icon_name == NULL); +EFL_START_TEST(elm_image_test_gif) +{ + Evas_Object *win, *image; + int pass = 0; + + win = win_add(NULL, "image", ELM_WIN_BASIC); + + image = elm_image_add(win); + evas_object_resize(win, 100, 100); + evas_object_resize(image, 100, 100); + evas_object_show(win); + evas_object_show(image); + get_me_to_those_events(win); + ck_assert(elm_image_file_set(image, ELM_IMAGE_DATA_DIR"/images/fire.gif", NULL)); + elm_image_animated_set(image, EINA_TRUE); + elm_image_animated_play_set(image, EINA_TRUE); + evas_object_event_callback_add(elm_image_object_get(image), EVAS_CALLBACK_IMAGE_PRELOADED, _test_preload, &pass); + /* verify that we haven't tried to set a frame with index 0, as this is an error */ + ck_assert_int_gt(evas_object_image_animated_frame_get(elm_image_object_get(image)), 0); + ecore_main_loop_begin(); + ck_assert_int_gt(pass, 0); } EFL_END_TEST +#endif + void elm_test_image(TCase *tc) { tcase_add_test(tc, elm_image_legacy_type_check); @@ -259,5 +366,9 @@ void elm_test_image(TCase *tc) tcase_add_test(tc, elm_image_async_mmap); tcase_add_test(tc, elm_image_evas_object_color_set); tcase_add_test(tc, elm_image_evas_image_get); - tcase_add_test(tc, efl_ui_image_icon); + tcase_add_test(tc, elm_image_test_memfile_set); + tcase_add_test(tc, elm_image_test_scale_method); +#ifdef BUILD_LOADER_GIF + tcase_add_test(tc, elm_image_test_gif); +#endif } diff --git a/src/tests/elementary/elm_test_list.c b/src/tests/elementary/elm_test_list.c index d15fb249f7..ab5b5ed20c 100644 --- a/src/tests/elementary/elm_test_list.c +++ b/src/tests/elementary/elm_test_list.c @@ -242,6 +242,100 @@ EFL_START_TEST(elm_atspi_children_parent) } EFL_END_TEST +#define NUM_ITEMS 10 +EFL_START_TEST(elm_list_test_callbacks) +{ + Evas_Object *win, *list; + unsigned int i; + int count[NUM_ITEMS] = {0}; + Elm_Object_Item *it; + int selected = 0, unselected = 0; + int highlighted = 0, unhighlighted = 0; + + win = win_add(NULL, "list", ELM_WIN_BASIC); + evas_object_resize(win, 100, 100); + + list = elm_list_add(win); + evas_object_smart_callback_add(list, "selected", (void*)event_callback_that_increments_an_int_when_called, &selected); + evas_object_smart_callback_add(list, "unselected", (void*)event_callback_that_increments_an_int_when_called, &unselected); + evas_object_smart_callback_add(list, "highlighted", (void*)event_callback_that_increments_an_int_when_called, &highlighted); + evas_object_smart_callback_add(list, "unhighlighted", (void*)event_callback_that_increments_an_int_when_called, &unhighlighted); + evas_object_resize(list, 100, 100); + for (i = 0; i < NUM_ITEMS; i++) + elm_list_item_append(list, "item", NULL, NULL, (void*)event_callback_single_call_int_data, &(count[i])); + + elm_list_go(list); + evas_object_show(list); + evas_object_show(win); + get_me_to_those_events(win); + + for (i = 0, it = elm_list_first_item_get(list); i < NUM_ITEMS; i++, it = elm_list_item_next(it)) + { + elm_list_item_selected_set(it, EINA_TRUE); + ck_assert_int_eq(count[i], 1); + + ck_assert_int_eq(selected, i + 1); + ck_assert_int_eq(unselected, i); + + ck_assert_int_eq(highlighted, i + 1); + ck_assert_int_eq(unhighlighted, i); + } + ck_assert_int_eq(selected, 10); + ck_assert_int_eq(unselected, 9); + + ck_assert_int_eq(highlighted, 10); + ck_assert_int_eq(unhighlighted, 9); + + /* weird SIGILL in shutdown if the list isn't deleted here */ + evas_object_del(list); +} +EFL_END_TEST + +static Eo * +create_content_with_size(Eo *parent, int mw, int mh) +{ + Evas *e = evas_object_evas_get(parent); + Eo *rect = evas_object_rectangle_add(e); + + evas_object_size_hint_min_set(rect, mw, mh); + evas_object_show(rect); + + return rect; +} + +EFL_START_TEST(elm_list_test_sizing) +{ + Evas_Object *win, *list; + unsigned int i; + int count[NUM_ITEMS] = {0}; + Elm_Object_Item *it; + + win = win_add(NULL, "list", ELM_WIN_BASIC); + evas_object_resize(win, 100, 100); + + list = elm_list_add(win); + evas_object_resize(list, 100, 100); + for (i = 0; i < NUM_ITEMS; i++) + elm_list_item_append(list, "item", create_content_with_size(list, i * 5, i * 5), NULL, (void*)event_callback_single_call_int_data, &(count[i])); + + elm_list_go(list); + evas_object_show(list); + evas_object_show(win); + get_me_to_those_events(win); + + for (i = 0, it = elm_list_first_item_get(list); i < NUM_ITEMS; i++, it = elm_list_item_next(it)) + { + Eo *rect = elm_object_item_content_get(it); + ck_assert(rect); + /* list is always homogeneous, so these should all have the size of the largest min size */ + assert_object_size_eq(rect, (NUM_ITEMS - 1) * 5, (NUM_ITEMS - 1) * 5); + } + + /* weird SIGILL in shutdown if the list isn't deleted here */ + evas_object_del(list); +} +EFL_END_TEST + void elm_test_list(TCase *tc) { tcase_add_test(tc, elm_list_legacy_type_check); @@ -256,4 +350,6 @@ void elm_test_list(TCase *tc) tcase_add_test(tc, elm_list_atspi_selection_child_deselect); #endif tcase_add_test(tc, elm_atspi_children_parent); + tcase_add_test(tc, elm_list_test_callbacks); + tcase_add_test(tc, elm_list_test_sizing); } diff --git a/src/tests/elementary/elm_test_naviframe.c b/src/tests/elementary/elm_test_naviframe.c index 01f5dfc011..4f1b6d29ae 100644 --- a/src/tests/elementary/elm_test_naviframe.c +++ b/src/tests/elementary/elm_test_naviframe.c @@ -110,10 +110,68 @@ EFL_START_TEST(elm_naviframe_test_content_preserve_on_pop) } EFL_END_TEST +static Eo * +create_content(Eo *parent) +{ + Eo *content = elm_layout_add(parent); + + evas_object_size_hint_min_set(content, 50, 50); + + return content; +} + +#define NUM_ITEMS 10 +EFL_START_TEST(elm_naviframe_test_behavior) +{ + Evas_Object *win, *naviframe; + //int title_transition = 0; + int title_clicked = 0; + Elm_Object_Item *active_it = NULL; + Elm_Object_Item *it[NUM_ITEMS]; + int i; + + win = win_add(NULL, "naviframe", ELM_WIN_BASIC); + evas_object_resize(win, 500, 500); + + naviframe = elm_naviframe_add(win); + //this seems broken beyond space and time + //evas_object_smart_callback_add(naviframe, "title,transition,finished", event_callback_single_call_int_data, &title_transition); + evas_object_smart_callback_add(naviframe, "title,clicked", event_callback_single_call_int_data, &title_clicked); + evas_object_smart_callback_add(naviframe, "transition,finished", event_callback_that_quits_the_main_loop_when_called, NULL); + evas_object_smart_callback_add(naviframe, "item,activated", smart_callback_that_stores_event_info_to_data, &active_it); + evas_object_resize(naviframe, 500, 500); + evas_object_show(naviframe); + + for (i = 0; i < NUM_ITEMS; i++) + { + char buf[12]; + snprintf(buf, sizeof(buf), "page%d", i); + it[i] = elm_naviframe_item_push(naviframe, buf, NULL, NULL, create_content(naviframe), NULL); + elm_naviframe_item_title_enabled_set(it[i], EINA_TRUE, EINA_TRUE); + } + ck_assert_ptr_eq(it[0], active_it); + + evas_object_show(win); + get_me_to_those_events(win); + + ecore_main_loop_begin(); + + ck_assert_ptr_eq(it[9], active_it); + click_part(naviframe, "elm.text.title"); + get_me_to_those_events(win); + ck_assert_int_eq(title_clicked, 1); + + click_part(naviframe, "elm.swallow.prev_btn"); + ecore_main_loop_begin(); + /* reaching this point verifies that the back button works */ +} +EFL_END_TEST + void elm_test_naviframe(TCase *tc) { tcase_add_test(tc, elm_naviframe_test_legacy_type_check); tcase_add_test(tc, elm_naviframe_test_atspi_role_get); tcase_add_test(tc, elm_naviframe_test_content_preserve_on_pop); + tcase_add_test(tc, elm_naviframe_test_behavior); } diff --git a/src/tests/elementary/elm_test_slider.c b/src/tests/elementary/elm_test_slider.c index 337b75444c..50f806994f 100644 --- a/src/tests/elementary/elm_test_slider.c +++ b/src/tests/elementary/elm_test_slider.c @@ -43,7 +43,7 @@ EFL_END_TEST EFL_START_TEST(elm_slider_in_scroller) { - Evas_Object *win, *slider, *box, *scroller, *fslider; + Evas_Object *win, *slider, *box, *scroller, *fslider = NULL; Evas *e; win = win_add(NULL, "slider", ELM_WIN_BASIC); diff --git a/src/tests/elementary/elm_test_spinner.c b/src/tests/elementary/elm_test_spinner.c index 99c3696188..76ec9d34e4 100644 --- a/src/tests/elementary/elm_test_spinner.c +++ b/src/tests/elementary/elm_test_spinner.c @@ -65,11 +65,11 @@ EFL_START_TEST(elm_spinner_focus_next_object) elm_object_focus_set(spinner, EINA_TRUE); - elm_object_focus_next_object_set(spinner, btn, EFL_UI_FOCUS_DIRECTION_UP); - o = elm_object_focus_next_object_get(spinner, EFL_UI_FOCUS_DIRECTION_UP); + elm_object_focus_next_object_set(spinner, btn, ELM_FOCUS_UP); + o = elm_object_focus_next_object_get(spinner, ELM_FOCUS_UP); ck_assert_ptr_eq(o, btn); - elm_object_focus_next(win, EFL_UI_FOCUS_DIRECTION_UP); + elm_object_focus_next(win, ELM_FOCUS_UP); ck_assert_ptr_eq(elm_object_focused_object_get(win), btn); } EFL_END_TEST diff --git a/src/tests/elementary/emoji_wink.json b/src/tests/elementary/emoji_wink.json new file mode 100644 index 0000000000..29b39a5369 --- /dev/null +++ b/src/tests/elementary/emoji_wink.json @@ -0,0 +1 @@ +{"v":"4.5.7","fr":30,"ip":0,"op":60,"w":100,"h":100,"ddd":0,"assets":[{"id":"comp_38","layers":[{"ddd":0,"ind":0,"ty":4,"nm":"round_normal","ks":{"o":{"a":0,"k":100},"r":{"a":0,"k":0},"p":{"a":0,"k":[50,50,0]},"a":{"a":0,"k":[-252,-412,0]},"s":{"a":0,"k":[100,100,100]}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ks":{"a":0,"k":{"i":[[-17.673,0],[0,-17.673],[17.673,0],[0,17.673]],"o":[[17.673,0],[0,17.673],[-17.673,0],[0,-17.673]],"v":[[-252,-444],[-220,-412],[-252,-380],[-284,-412]],"c":true}},"nm":"Path 1","mn":"ADBE Vector Shape - Group"},{"ty":"fl","c":{"a":0,"k":[1,0.88,0.59,1]},"o":{"a":0,"k":100},"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill"},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":3,"mn":"ADBE Vector Group"}],"ip":0,"op":300,"st":0,"bm":0,"sr":1}]}],"layers":[{"ddd":0,"ind":0,"ty":4,"nm":"eyes_normal","parent":2,"ks":{"o":{"a":0,"k":100},"r":{"a":0,"k":0},"p":{"a":0,"k":[50,45.5,0]},"a":{"a":0,"k":[-252,-416.5,0]},"s":{"a":1,"k":[{"i":{"x":[0.516,0.831,0.667],"y":[0.516,1,0.667]},"o":{"x":[0.75,0.705,0.333],"y":[0.75,0,0.333]},"n":["0p516_0p516_0p75_0p75","0p831_1_0p705_0","0p667_0p667_0p333_0p333"],"t":40,"s":[100,100,100],"e":[100,0,100]},{"i":{"x":[0.667,0.667,0.667],"y":[0.667,1,0.667]},"o":{"x":[0.333,0.333,0.333],"y":[0.333,0,0.333]},"n":["0p667_0p667_0p333_0p333","0p667_1_0p333_0","0p667_0p667_0p333_0p333"],"t":45,"s":[100,0,100],"e":[100,110,100]},{"i":{"x":[0.298,0.276,0.667],"y":[0.298,1,0.667]},"o":{"x":[0.038,0.105,0.333],"y":[0.038,0,0.333]},"n":["0p298_0p298_0p038_0p038","0p276_1_0p105_0","0p667_0p667_0p333_0p333"],"t":50,"s":[100,110,100],"e":[100,98,100]},{"i":{"x":[0.667,0.667,0.667],"y":[0.667,1,0.667]},"o":{"x":[0.333,0.333,0.333],"y":[0.333,0,0.333]},"n":["0p667_0p667_0p333_0p333","0p667_1_0p333_0","0p667_0p667_0p333_0p333"],"t":55,"s":[100,98,100],"e":[100,100,100]},{"t":60}]}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ks":{"a":1,"k":[{"i":{"x":0.313,"y":1},"o":{"x":0.467,"y":0},"n":"0p313_1_0p467_0","t":6,"s":[{"i":[[-1.933,0],[0,-1.933],[1.933,0],[0,1.933]],"o":[[1.933,0],[0,1.933],[-1.933,0],[0,-1.933]],"v":[[-237.5,-420],[-234,-416.5],[-237.5,-413],[-241,-416.5]],"c":true}],"e":[{"i":[[-1.933,0],[-0.312,-1.313],[1.933,0],[0,1.062]],"o":[[1.933,0],[0.174,0.732],[-1.933,0],[0,-1.25]],"v":[[-237.437,-418],[-231.25,-415.875],[-237.5,-416.938],[-243.188,-415.937]],"c":true}]},{"i":{"x":0.395,"y":1},"o":{"x":0.716,"y":0},"n":"0p395_1_0p716_0","t":16,"s":[{"i":[[-1.933,0],[-0.312,-1.313],[1.933,0],[0,1.062]],"o":[[1.933,0],[0.174,0.732],[-1.933,0],[0,-1.25]],"v":[[-237.437,-418],[-231.25,-415.875],[-237.5,-416.938],[-243.188,-415.937]],"c":true}],"e":[{"i":[[-1.933,0],[0,-1.933],[1.933,0],[0,1.933]],"o":[[1.933,0],[0,1.933],[-1.933,0],[0,-1.933]],"v":[[-237.5,-420],[-234,-416.5],[-237.5,-413],[-241,-416.5]],"c":true}]},{"t":29}]},"nm":"Path 1","mn":"ADBE Vector Shape - Group"},{"ind":1,"ty":"sh","ks":{"a":0,"k":{"i":[[-1.933,0],[0,-1.933],[1.933,0],[0,1.933]],"o":[[1.933,0],[0,1.933],[-1.933,0],[0,-1.933]],"v":[[-266.5,-420],[-263,-416.5],[-266.5,-413],[-270,-416.5]],"c":true}},"nm":"Path 2","mn":"ADBE Vector Shape - Group"},{"ty":"fl","c":{"a":0,"k":[0.33,0.33,0.28,1]},"o":{"a":0,"k":100},"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill"},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":4,"mn":"ADBE Vector Group"}],"ip":0,"op":61,"st":0,"bm":0,"sr":1},{"ddd":0,"ind":1,"ty":4,"nm":"mouth_smile","parent":2,"ks":{"o":{"a":0,"k":100},"r":{"a":1,"k":[{"i":{"x":[0.25],"y":[1]},"o":{"x":[0.75],"y":[0]},"n":["0p25_1_0p75_0"],"t":4,"s":[0],"e":[-15]},{"i":{"x":[0.25],"y":[1]},"o":{"x":[0.75],"y":[0]},"n":["0p25_1_0p75_0"],"t":15,"s":[-15],"e":[0]},{"t":30}]},"p":{"a":0,"k":[50.862,57.489,0]},"a":{"a":0,"k":[-251.138,-404.511,0]},"s":{"a":0,"k":[100,100,100]}},"ao":0,"shapes":[{"ty":"gr","it":[{"ind":0,"ty":"sh","ks":{"a":1,"k":[{"i":{"x":0.292,"y":1},"o":{"x":0.506,"y":0},"n":"0p292_1_0p506_0","t":0,"s":[{"i":[[6.254,0],[2.91,1.715],[-0.616,0.558],[-0.707,-0.436],[-2.276,0],[-3.615,1.995],[-0.52,-0.71],[0.737,-0.384]],"o":[[-6.249,0],[-0.716,-0.422],[0.615,-0.558],[3.273,2.017],[2.662,0],[0.728,-0.402],[0.324,0.602],[-3.252,1.696]],"v":[[-252.006,-391.01],[-263.629,-394.434],[-263.522,-396.373],[-261.398,-396.454],[-252.006,-394.02],[-242.635,-396.433],[-240.261,-396.227],[-240.405,-394.414]],"c":true}],"e":[{"i":[[6.233,0],[4.195,4.639],[-0.616,0.558],[-0.558,-0.615],[-5.401,0],[-3.206,6.717],[-0.615,-0.557],[0.338,-0.759]],"o":[[-6.249,0],[-0.557,-0.616],[0.615,-0.558],[3.626,4.01],[4.636,0],[0.358,-0.75],[0.616,0.557],[-2.811,6.323]],"v":[[-252.044,-390.197],[-266.129,-396.746],[-266.022,-398.873],[-263.898,-398.767],[-252.076,-392.959],[-239.687,-401.031],[-237.564,-401.138],[-237.457,-399.012]],"c":true}]},{"i":{"x":0.564,"y":1},"o":{"x":0.571,"y":0},"n":"0p564_1_0p571_0","t":15,"s":[{"i":[[6.233,0],[4.195,4.639],[-0.616,0.558],[-0.558,-0.615],[-5.401,0],[-3.206,6.717],[-0.615,-0.557],[0.338,-0.759]],"o":[[-6.249,0],[-0.557,-0.616],[0.615,-0.558],[3.626,4.01],[4.636,0],[0.358,-0.75],[0.616,0.557],[-2.811,6.323]],"v":[[-252.044,-390.197],[-266.129,-396.746],[-266.022,-398.873],[-263.898,-398.767],[-252.076,-392.959],[-239.687,-401.031],[-237.564,-401.138],[-237.457,-399.012]],"c":true}],"e":[{"i":[[6.254,0],[2.91,1.715],[-0.616,0.558],[-0.707,-0.436],[-2.276,0],[-3.615,1.995],[-0.52,-0.71],[0.737,-0.384]],"o":[[-6.249,0],[-0.716,-0.422],[0.615,-0.558],[3.273,2.017],[2.662,0],[0.728,-0.402],[0.324,0.602],[-3.252,1.696]],"v":[[-252.006,-391.01],[-263.629,-394.434],[-263.522,-396.373],[-261.398,-396.454],[-252.006,-394.02],[-242.635,-396.433],[-240.261,-396.227],[-240.405,-394.414]],"c":true}]},{"i":{"x":0.681,"y":0.833},"o":{"x":0.546,"y":0},"n":"0p681_0p833_0p546_0","t":30,"s":[{"i":[[6.254,0],[2.91,1.715],[-0.616,0.558],[-0.707,-0.436],[-2.276,0],[-3.615,1.995],[-0.52,-0.71],[0.737,-0.384]],"o":[[-6.249,0],[-0.716,-0.422],[0.615,-0.558],[3.273,2.017],[2.662,0],[0.728,-0.402],[0.324,0.602],[-3.252,1.696]],"v":[[-252.006,-391.01],[-263.629,-394.434],[-263.522,-396.373],[-261.398,-396.454],[-252.006,-394.02],[-242.635,-396.433],[-240.261,-396.227],[-240.405,-394.414]],"c":true}],"e":[{"i":[[6.254,0],[2.91,1.715],[-0.616,0.558],[-0.734,-0.389],[-2.276,0],[-3.487,2.248],[-0.52,-0.71],[0.673,-0.488]],"o":[[-6.249,0],[-0.716,-0.422],[0.615,-0.558],[3.089,1.638],[2.662,0],[0.699,-0.451],[0.324,0.602],[-2.905,2.105]],"v":[[-252.006,-391.01],[-264.507,-394.555],[-264.401,-396.494],[-262.276,-396.576],[-252.006,-394.02],[-242.076,-396.998],[-239.702,-396.793],[-239.845,-394.98]],"c":true}]},{"i":{"x":0.667,"y":1},"o":{"x":0.497,"y":0.261},"n":"0p667_1_0p497_0p261","t":40,"s":[{"i":[[6.254,0],[2.91,1.715],[-0.616,0.558],[-0.734,-0.389],[-2.276,0],[-3.487,2.248],[-0.52,-0.71],[0.673,-0.488]],"o":[[-6.249,0],[-0.716,-0.422],[0.615,-0.558],[3.089,1.638],[2.662,0],[0.699,-0.451],[0.324,0.602],[-2.905,2.105]],"v":[[-252.006,-391.01],[-264.507,-394.555],[-264.401,-396.494],[-262.276,-396.576],[-252.006,-394.02],[-242.076,-396.998],[-239.702,-396.793],[-239.845,-394.98]],"c":true}],"e":[{"i":[[6.254,0],[2.91,1.715],[-0.616,0.558],[-0.707,-0.436],[-2.276,0],[-3.615,1.995],[-0.52,-0.71],[0.737,-0.384]],"o":[[-6.249,0],[-0.716,-0.422],[0.615,-0.558],[3.273,2.017],[2.662,0],[0.728,-0.402],[0.324,0.602],[-3.252,1.696]],"v":[[-252.006,-391.01],[-263.629,-394.434],[-263.522,-396.373],[-261.398,-396.454],[-252.006,-394.02],[-242.635,-396.433],[-240.261,-396.227],[-240.405,-394.414]],"c":true}]},{"t":60}]},"nm":"Path 1","mn":"ADBE Vector Shape - Group"},{"ty":"fl","c":{"a":0,"k":[0.33,0.33,0.28,1]},"o":{"a":0,"k":100},"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill"},{"ty":"tr","p":{"a":0,"k":[0,0],"ix":2},"a":{"a":0,"k":[0,0],"ix":1},"s":{"a":0,"k":[100,100],"ix":3},"r":{"a":0,"k":0,"ix":6},"o":{"a":0,"k":100,"ix":7},"sk":{"a":0,"k":0,"ix":4},"sa":{"a":0,"k":0,"ix":5},"nm":"Transform"}],"nm":"Shape 1","np":3,"mn":"ADBE Vector Group"}],"ip":0,"op":61,"st":0,"bm":0,"sr":1},{"ddd":0,"ind":2,"ty":0,"nm":"base_normal","refId":"comp_38","ks":{"o":{"a":0,"k":100},"r":{"a":1,"k":[{"i":{"x":[0.273],"y":[1]},"o":{"x":[0.464],"y":[0]},"n":["0p273_1_0p464_0"],"t":4,"s":[0],"e":[13]},{"i":{"x":[0.532],"y":[1]},"o":{"x":[0.578],"y":[0]},"n":["0p532_1_0p578_0"],"t":19,"s":[13],"e":[0]},{"t":40}]},"p":{"a":0,"k":[50,50,0]},"a":{"a":0,"k":[50,50,0]},"s":{"a":0,"k":[100,100,100]}},"ao":0,"w":100,"h":100,"ip":0,"op":61,"st":0,"bm":0,"sr":1}]}
\ No newline at end of file diff --git a/src/tests/elementary/meson.build b/src/tests/elementary/meson.build index 7c7c62fdac..273ee418dc 100644 --- a/src/tests/elementary/meson.build +++ b/src/tests/elementary/meson.build @@ -1,4 +1,7 @@ priv_eo_files = [ + 'custom_gesture.eo', + 'custom_recognizer.eo', + 'custom_recognizer2.eo', 'focus_test.eo', 'focus_test_sub_main.eo', 'focus_manager_test.eo' @@ -105,7 +108,7 @@ elementary_suite_src = [ elementary_suite = executable('elementary_suite', elementary_suite_src, - dependencies: [check, eina, elementary, elementary_deps], + dependencies: [check, eina, elementary, elementary_deps, intl], include_directories : [config_dir] + [elementary_config_dir], c_args : [ '-DTESTS_BUILD_DIR="'+meson.current_build_dir()+'"', @@ -129,6 +132,7 @@ efl_ui_suite_src = [ 'efl_ui_test_focus_common.h', 'efl_ui_test_focus.c', 'efl_ui_test_focus_sub.c', + 'efl_ui_test_gesture.c', 'efl_ui_test_box.c', 'efl_ui_test_box_flow.c', 'efl_ui_test_box_stack.c', @@ -150,6 +154,7 @@ efl_ui_suite_src = [ 'efl_ui_test_slider.c', 'efl_ui_test_collection_common.c', 'efl_ui_test_collection.c', + 'efl_ui_test_collection_view.c', 'efl_ui_test_list_collection.c', 'efl_ui_test_grid_collection.c', 'efl_ui_test_position_manager_common.c', @@ -159,11 +164,15 @@ efl_ui_suite_src = [ 'efl_ui_test_view_model.c', 'efl_ui_test_group_item.c', 'efl_ui_test_text.c', + 'efl_ui_test_vg_animation.c', + 'custom_gesture.c', + 'custom_recognizer.c', + 'custom_recognizer2.c', ] efl_ui_suite = executable('efl_ui_suite', efl_ui_suite_src, priv_eo_file_target, - dependencies: [check, eina, elementary, elementary_deps], + dependencies: [check, eina, elementary, elementary_deps, intl], include_directories : [config_dir] + [elementary_config_dir], c_args : [ '-DTESTS_BUILD_DIR="'+meson.current_build_dir()+'"', @@ -178,6 +187,11 @@ efl_ui_compile_test = executable('efl_ui_compile_test', dependencies: [elementary, eio], ) +executable('efl_ui_window_cnp_dnd_slave', + 'efl_ui_window_cnp_dnd_slave.c', + dependencies: [elementary], +) + test('elementary-suite', elementary_suite, env : test_env ) diff --git a/src/tests/elementary/spec/efl_test_basics.c b/src/tests/elementary/spec/efl_test_basics.c index b14e18a568..603c094ce0 100644 --- a/src/tests/elementary/spec/efl_test_basics.c +++ b/src/tests/elementary/spec/efl_test_basics.c @@ -45,11 +45,12 @@ "Efl.Ui.Timepicker", "Efl.Ui.Navigation_Bar", "Efl.Ui.Relative_Container", - "Efl.Ui.Animation_View", + "Efl.Ui.Vg_Animation", "Efl.Ui.Table", "Efl.Ui.Flip", "Efl.Ui.Stack", - "Efl.Ui.Pager" + "Efl.Ui.Pager", + "Efl.Ui.Separator" ], "custom-mapping" : { "Efl.Ui.Grid" : "EFL_UI_GRID_DEFAULT_ITEM_CLASS", @@ -66,7 +67,12 @@ EFL_START_TEST(no_leaking_canvas_object) Eina_Iterator *iter = eo_objects_iterator_new(); Eo *obj; - if (efl_isa(widget, EFL_UI_FLIP_CLASS)) return; //FIXME Flip needs more work for this. However, flip should be redone as a spotlight manager, When this is done, we can add these classes to the check here. + if (efl_isa(widget, EFL_UI_FLIP_CLASS)) + { + //FIXME Flip needs more work for this. However, flip should be redone as a spotlight manager, When this is done, we can add these classes to the check here. + eina_iterator_free(iter); + return; + } EINA_ITERATOR_FOREACH(iter, obj) { diff --git a/src/tests/elementary/spec/efl_test_gfx_arrangement.c b/src/tests/elementary/spec/efl_test_gfx_arrangement.c index 7c0367b147..417a12bae5 100644 --- a/src/tests/elementary/spec/efl_test_gfx_arrangement.c +++ b/src/tests/elementary/spec/efl_test_gfx_arrangement.c @@ -18,8 +18,8 @@ EFL_START_TEST(pack_align) double v, h; \ efl_gfx_arrangement_content_align_set(widget, H, V); \ efl_gfx_arrangement_content_align_get(widget, &h, &v); \ - ck_assert(v == rv); \ - ck_assert(h == rh); \ + ck_assert(EINA_DBL_EQ(v, rv)); \ + ck_assert(EINA_DBL_EQ(h, rh)); \ } while(0); TUPLE_CHECK( 1.0, 1.0, 1.0, 1.0); diff --git a/src/tests/elementary/spec/efl_test_gfx_view.c b/src/tests/elementary/spec/efl_test_gfx_view.c index fc411138b6..e87419f283 100644 --- a/src/tests/elementary/spec/efl_test_gfx_view.c +++ b/src/tests/elementary/spec/efl_test_gfx_view.c @@ -8,7 +8,7 @@ /* spec-meta-start {"test-interface":"Efl.Gfx.View", - "test-widgets": ["Efl.Ui.Animation_View"]} + "test-widgets": ["Efl.Ui.Vg_Animation"]} spec-meta-end */ EFL_START_TEST(view_size) diff --git a/src/tests/elementary/spec/efl_test_range_display.c b/src/tests/elementary/spec/efl_test_range_display.c index f072e02c10..49b1c769a3 100644 --- a/src/tests/elementary/spec/efl_test_range_display.c +++ b/src/tests/elementary/spec/efl_test_range_display.c @@ -19,12 +19,12 @@ EFL_START_TEST(value_setting_limits) EXPECT_ERROR_START; efl_ui_range_value_set(widget, -25.0); EXPECT_ERROR_END; - ck_assert(efl_ui_range_value_get(widget) == 10.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(widget), 10.0)); EXPECT_ERROR_START; efl_ui_range_value_set(widget, 25.0); EXPECT_ERROR_END; - ck_assert(efl_ui_range_value_get(widget) == 10.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(widget), 10.0)); } EFL_END_TEST @@ -34,38 +34,38 @@ EFL_START_TEST(limit_setting) efl_ui_range_limits_set(widget, -20.0, 20.0); efl_ui_range_limits_get(widget, &min, &max); - ck_assert(min == -20.0); - ck_assert(max == 20.0); + ck_assert(EINA_DBL_EQ(min, -20.0)); + ck_assert(EINA_DBL_EQ(max, 20.0)); EXPECT_ERROR_START; efl_ui_range_limits_set(widget, -20.0, -20.0); EXPECT_ERROR_END; efl_ui_range_limits_get(widget, &min, &max); - ck_assert(min == -20.0); - ck_assert(max == 20.0); + ck_assert(EINA_DBL_EQ(min, -20.0)); + ck_assert(EINA_DBL_EQ(max, 20.0)); EXPECT_ERROR_START; efl_ui_range_limits_set(widget, 2.0, -20.0); EXPECT_ERROR_END; efl_ui_range_limits_get(widget, &min, &max); - ck_assert(min == -20.0); - ck_assert(max == 20.0); + ck_assert(EINA_DBL_EQ(min, -20.0)); + ck_assert(EINA_DBL_EQ(max, 20.0)); EXPECT_ERROR_START; efl_ui_range_limits_set(widget, 25.0, 20.0); EXPECT_ERROR_END; efl_ui_range_limits_get(widget, &min, &max); - ck_assert(min == -20.0); - ck_assert(max == 20.0); + ck_assert(EINA_DBL_EQ(min, -20.0)); + ck_assert(EINA_DBL_EQ(max, 20.0)); efl_ui_range_limits_set(widget, -25.0, -20.0); efl_ui_range_limits_get(widget, &min, &max); - ck_assert(min == -25.0); - ck_assert(max == -20.0); + ck_assert(EINA_DBL_EQ(min, -25.0)); + ck_assert(EINA_DBL_EQ(max, -20.0)); efl_ui_range_limits_set(widget, 20.0, 25.0); efl_ui_range_limits_get(widget, &min, &max); - ck_assert(min == 20.0); - ck_assert(max == 25.0); + ck_assert(EINA_DBL_EQ(min, 20.0)); + ck_assert(EINA_DBL_EQ(max, 25.0)); } EFL_END_TEST @@ -76,7 +76,7 @@ EFL_START_TEST(value_setting) for (i = -20.0; i <= 20.0; ++i) { efl_ui_range_value_set(widget, i); - ck_assert(efl_ui_range_value_get(widget) == i); + ck_assert(EINA_DBL_EQ(efl_ui_range_value_get(widget), i)); } } EFL_END_TEST @@ -124,6 +124,10 @@ EFL_START_TEST (range_display_value_events) changed = EINA_FALSE; min_reached = EINA_FALSE; max_reached = EINA_FALSE; + efl_event_callback_del(widget, EFL_UI_RANGE_EVENT_CHANGED, _set_flag, &changed); + efl_event_callback_del(widget, EFL_UI_RANGE_EVENT_MIN_REACHED, _set_flag, &min_reached); + efl_event_callback_del(widget, EFL_UI_RANGE_EVENT_MAX_REACHED, _set_flag, &max_reached); + } EFL_END_TEST diff --git a/src/tests/elementary/spec/efl_test_range_interactive.c b/src/tests/elementary/spec/efl_test_range_interactive.c index c900524120..76b266dab0 100644 --- a/src/tests/elementary/spec/efl_test_range_interactive.c +++ b/src/tests/elementary/spec/efl_test_range_interactive.c @@ -16,18 +16,18 @@ EFL_START_TEST(step_setting) { efl_ui_range_step_set(widget, 20.0); - ck_assert(efl_ui_range_step_get(widget) == 20.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_step_get(widget), 20.0)); efl_ui_range_step_set(widget, 100.0); - ck_assert(efl_ui_range_step_get(widget) == 100.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_step_get(widget), 100.0)); EXPECT_ERROR_START; efl_ui_range_step_set(widget, 0.0); - ck_assert(efl_ui_range_step_get(widget) == 100.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_step_get(widget), 100.0)); EXPECT_ERROR_END; EXPECT_ERROR_START; efl_ui_range_step_set(widget, -20.0); - ck_assert(efl_ui_range_step_get(widget) == 100.0); + ck_assert(EINA_DBL_EQ(efl_ui_range_step_get(widget), 100.0)); EXPECT_ERROR_END; } EFL_END_TEST diff --git a/src/tests/elementary/spec/efl_ui_spec_suite.c b/src/tests/elementary/spec/efl_ui_spec_suite.c index d59072b51e..49ca5a993f 100644 --- a/src/tests/elementary/spec/efl_ui_spec_suite.c +++ b/src/tests/elementary/spec/efl_ui_spec_suite.c @@ -13,8 +13,8 @@ Evas_Object *widget = NULL; Eo *collection_grid = NULL; const Efl_Class *test_content_klass = NULL; const Efl_Class *widget_klass = NULL; -EFL_CLASS_SIMPLE_CLASS(efl_ui_widget, "efl_ui_widget", EFL_UI_WIDGET_CLASS); -EFL_CLASS_SIMPLE_CLASS(efl_ui_item, "efl_ui_item", EFL_UI_ITEM_CLASS); +EFL_CLASS_SIMPLE_CLASS(efl_ui_widget, "Efl.Ui.Widget", EFL_UI_WIDGET_CLASS); +EFL_CLASS_SIMPLE_CLASS(efl_ui_item, "Efl.Ui.Item", EFL_UI_ITEM_CLASS); #define EFL_UI_ITEM_REALIZED_CLASS efl_ui_item_realized_class_get() diff --git a/src/tests/elementary/suite_helpers.c b/src/tests/elementary/suite_helpers.c index 53c473a9fa..62fe6deb77 100644 --- a/src/tests/elementary/suite_helpers.c +++ b/src/tests/elementary/suite_helpers.c @@ -19,6 +19,7 @@ static Eina_Bool buffer = EINA_FALSE; static Eina_Bool legacy_mode = EINA_FALSE; static int log_abort; static int log_abort_level; +static unsigned int ts = 1; Eina_Bool abort_on_warnings = EINA_FALSE; @@ -50,6 +51,7 @@ _elm2_suite_init(void) ck_assert_int_eq(elm_init(1, args), 1); if (abort_on_warnings) fail_on_errors_setup(); + ts = 1; } void @@ -142,6 +144,20 @@ real_timer_add(double in, Ecore_Task_Cb cb, void *data) return ecore_timer_add(in, cb, data); } +static Eina_Bool +_timer_quit() +{ + ecore_main_loop_quit(); + return EINA_FALSE; +} + +void +wait_timer(double in) +{ + ecore_timer_add(in, _timer_quit, NULL); + ecore_main_loop_begin(); +} + static void _win_manual_render(void *data, const Efl_Event *event EINA_UNUSED) { @@ -150,7 +166,7 @@ _win_manual_render(void *data, const Efl_Event *event EINA_UNUSED) ecore_loop_time_set(t + LOOP_INCREMENT); ecore_animator_custom_tick(); ecore_evas_render_prepare(ecore_evas_ecore_evas_get(evas_object_evas_get(data))); - evas_norender(evas_object_evas_get(data)); + evas_norender_with_updates(evas_object_evas_get(data)); } static void @@ -320,7 +336,7 @@ suite_setup(Eina_Bool legacy) failed_count = _efl_suite_build_and_run(0, NULL, "Efl_Ui_Init", ui_init, NULL, NULL); - failed_count += !elm_init(1, (char*[]){"exe"}); + failed_count += !elm_init(1, args); if (buffer) { global_win = _elm_suite_win_create(); @@ -450,29 +466,42 @@ attempt_to_find_the_right_point_for_mouse_positioning(Eo *obj, int dir) } static void -click_object_internal(Eo *obj, int dir, int flags) +click_object_internal(Eo *obj, int dir, int flags, Eina_Bool up) { Evas *e = evas_object_evas_get(obj); Eina_Position2D pos = attempt_to_find_the_right_point_for_mouse_positioning(obj, dir); - evas_event_feed_mouse_move(e, pos.x, pos.y, 0, NULL); - evas_event_feed_mouse_down(e, 1, flags, 0, NULL); - evas_event_feed_mouse_up(e, 1, 0, 0, NULL); + evas_event_feed_mouse_move(e, pos.x, pos.y, ts++, NULL); + evas_event_feed_mouse_down(e, 1, flags, ts++, NULL); + if (up) + evas_event_feed_mouse_up(e, 1, 0, ts++, NULL); } void click_object(Eo *obj) { - click_object_internal(obj, NONE, 0); + click_object_internal(obj, NONE, 0, EINA_TRUE); +} + +void +press_object(Eo *obj) +{ + click_object_internal(obj, NONE, 0, EINA_FALSE); } void click_object_flags(Eo *obj, int flags) { - click_object_internal(obj, NONE, flags); + click_object_internal(obj, NONE, flags, EINA_TRUE); } void -click_part_flags(Eo *obj, const char *part, int flags) +press_object_flags(Eo *obj, int flags) +{ + click_object_internal(obj, NONE, flags, EINA_FALSE); +} + +static void +click_part_flags_internal(Eo *obj, const char *part, int flags, Eina_Bool up) { Efl_Part *part_obj = efl_ref(efl_part(obj, part)); Eo *content; @@ -492,19 +521,39 @@ click_part_flags(Eo *obj, const char *part, int flags) else if (strstr(part, "bottom")) dir |= BOTTOM; } - click_object_internal(content, dir, flags); + click_object_internal(content, dir, flags, up); if (efl_isa(content, EFL_LAYOUT_SIGNAL_INTERFACE)) edje_object_message_signal_process(content); - edje_object_message_signal_process(obj); + /* can be false if obj is an elm_widget_item */ + if (efl_isa(obj, EFL_LAYOUT_SIGNAL_INTERFACE)) + edje_object_message_signal_process(obj); efl_unref(part_obj); } void +click_part_flags(Eo *obj, const char *part, int flags) +{ + click_part_flags_internal(obj, part, flags, EINA_TRUE); +} + +void +press_part_flags(Eo *obj, const char *part, int flags) +{ + click_part_flags_internal(obj, part, flags, EINA_FALSE); +} + +void click_part(Eo *obj, const char *part) { click_part_flags(obj, part, 0); } +void +press_part(Eo *obj, const char *part) +{ + press_part_flags(obj, part, 0); +} + static void wheel_object_internal(Eo *obj, int dir, Eina_Bool horiz, Eina_Bool down) { @@ -551,6 +600,7 @@ event_callback_single_call_int_data(void *data, Evas_Object *obj EINA_UNUSED, vo { int *called = data; + if (*called) fprintf(stderr, "TEST FAILURE IN %s\n", __func__); ck_assert_int_eq(*called, 0); *called = 1; } @@ -570,21 +620,88 @@ event_callback_that_quits_the_main_loop_when_called() } void +smart_callback_that_stores_event_info_to_data(void *data, Evas_Object *obj EINA_UNUSED, void *event_info) +{ + void **real_data = data; + + *real_data = event_info; +} + +void click_object_at(Eo *obj, int x, int y) { Evas *e = evas_object_evas_get(obj); - evas_event_feed_mouse_move(e, x, y, 0, NULL); - evas_event_feed_mouse_down(e, 1, 0, 0, NULL); - evas_event_feed_mouse_up(e, 1, 0, 0, NULL); + evas_event_feed_mouse_move(e, x, y, ts++, NULL); + evas_event_feed_mouse_down(e, 1, 0, ts++, NULL); + evas_event_feed_mouse_up(e, 1, 0, ts++, NULL); +} + +void +multi_click_object(Eo *obj, int ids) +{ + Evas *e = evas_object_evas_get(obj); + Eina_Position2D pos = attempt_to_find_the_right_point_for_mouse_positioning(obj, NONE); + for (int i = 0; i < ids; i++) + evas_event_feed_multi_down(e, i, pos.x + i, pos.y + i, 1, 1, 1, 1, 0, pos.x + i, pos.y + i, 0, ts, NULL); + ts++; + for (int i = 0; i < ids; i++) + evas_event_feed_multi_up(e, i, pos.x + i, pos.y + i, 1, 1, 1, 1, 0, pos.x + i, pos.y + i, 0, ts, NULL); +} + +void +multi_press_object(Eo *obj, int ids) +{ + Evas *e = evas_object_evas_get(obj); + Eina_Position2D pos = attempt_to_find_the_right_point_for_mouse_positioning(obj, NONE); + for (int i = 0; i < ids; i++) + evas_event_feed_multi_down(e, i, pos.x + i, pos.y + i, 1, 1, 1, 1, 0, pos.x + i, pos.y + i, 0, ts, NULL); + ts++; +} + +void +multi_click_object_at(Eo *obj, int x, int y, int ids) +{ + Evas *e = evas_object_evas_get(obj); + for (int i = 0; i < ids; i++) + evas_event_feed_multi_down(e, i, x + i, y + i, 1, 1, 1, 1, 0, x + i, y + i, 0, ts, NULL); + ts++; + for (int i = 0; i < ids; i++) + evas_event_feed_multi_up(e, i, x + i, y + i, 1, 1, 1, 1, 0, x + i, y + i, 0, ts, NULL); + ts++; +} + +void +press_object_at(Eo *obj, int x, int y) +{ + Evas *e = evas_object_evas_get(obj); + evas_event_feed_mouse_move(e, x, y, ts++, NULL); + evas_event_feed_mouse_down(e, 1, 0, ts++, NULL); +} + +void +multi_press_object_at(Eo *obj, int x, int y, int ids) +{ + Evas *e = evas_object_evas_get(obj); + for (int i = 0; i < ids; i++) + evas_event_feed_multi_down(e, i, x + i, y + i, 1, 1, 1, 1, 0, x + i, y + i, 0, ts, NULL); + ts++; } void click_object_at_flags(Eo *obj, int x, int y, int flags) { Evas *e = evas_object_evas_get(obj); - evas_event_feed_mouse_move(e, x, y, 0, NULL); - evas_event_feed_mouse_down(e, 1, flags, 0, NULL); - evas_event_feed_mouse_up(e, 1, 0, 0, NULL); + evas_event_feed_mouse_move(e, x, y, ts++, NULL); + evas_event_feed_mouse_down(e, 1, flags, ts++, NULL); + evas_event_feed_mouse_up(e, 1, 0, ts++, NULL); +} + +void +press_object_at_flags(Eo *obj, int x, int y, int flags) +{ + Evas *e = evas_object_evas_get(obj); + evas_event_feed_mouse_move(e, x, y, ts++, NULL); + evas_event_feed_mouse_down(e, 1, flags, ts++, NULL); } void @@ -600,8 +717,8 @@ drag_object(Eo *obj, int x, int y, int dx, int dy, Eina_Bool iterate) { Evas *e = evas_object_evas_get(obj); int i; - evas_event_feed_mouse_move(e, x, y, 0, NULL); - evas_event_feed_mouse_down(e, 1, 0, 0, NULL); + evas_event_feed_mouse_move(e, x, y, ts++, NULL); + evas_event_feed_mouse_down(e, 1, 0, ts++, NULL); if (iterate) { /* iterate twice to trigger timers */ @@ -611,10 +728,112 @@ drag_object(Eo *obj, int x, int y, int dx, int dy, Eina_Bool iterate) /* create DRAG_OBJECT_NUM_MOVES move events distinct from up/down */ for (i = 0; i < DRAG_OBJECT_NUM_MOVES; i++) { - evas_event_feed_mouse_move(e, x + (i * dx / DRAG_OBJECT_NUM_MOVES), y + (i * dy / DRAG_OBJECT_NUM_MOVES), 0, NULL); + evas_event_feed_mouse_move(e, x + (i * dx / DRAG_OBJECT_NUM_MOVES), y + (i * dy / DRAG_OBJECT_NUM_MOVES), ts++, NULL); /* also trigger smart calc if we're iterating just in case that's important */ evas_smart_objects_calculate(e); } - evas_event_feed_mouse_move(e, x + dx, y + dy, 0, NULL); - evas_event_feed_mouse_up(e, 1, 0, 0, NULL); + evas_event_feed_mouse_move(e, x + dx, y + dy, ts++, NULL); + evas_event_feed_mouse_up(e, 1, 0, ts++, NULL); +} + +int +drag_object_around(Eo *obj, int cx, int cy, int radius, int degrees) +{ + Evas *e = evas_object_evas_get(obj); + /* clamp num mouse moves to a vaguely sane value */ + int i, num = MIN(abs(degrees), DRAG_OBJECT_AROUND_NUM_MOVES); + int last_x = round(cx + radius); + int last_y = round(cy); + /* start at 0 degrees */ + evas_event_feed_mouse_move(e, last_x, last_y, ts++, NULL); + evas_event_feed_mouse_down(e, 1, 0, ts++, NULL); + for (i = 1; i < num; i++) + { + /* x = cx + r * cos(a), y = cy + r * sin(a) */ + int ax, ay; + /* each iteration is 1 degree */ + double angle = (i * (degrees / DRAG_OBJECT_AROUND_NUM_MOVES)) * M_PI / 180.0; + ax = round(cx + radius * cos(angle)); + ay = round(cy + radius * sin(angle)); + if ((ax == last_x) && (ay == last_y)) continue; + evas_event_feed_mouse_move(e, ax, ay, ts++, NULL); + last_x = ax, last_y = ay; + } + evas_event_feed_mouse_up(e, 1, 0, ts++, NULL); + /* only count arc motion: subtract initial move, mouse down, mouse up */ + return num; +} + +int +multi_drag_object_around(Eo *obj, int touch_point, int cx, int cy, int radius, int degrees) +{ + Evas *e = evas_object_evas_get(obj); + /* clamp num mouse moves to a vaguely sane value */ + int i, num = MIN(abs(degrees), DRAG_OBJECT_AROUND_NUM_MOVES); + int last_x = round(cx + radius); + int last_y = round(cy); + /* start at 0 degrees */ + evas_event_feed_multi_down(e, touch_point, last_x, last_y, 1, 1, 1, 1, 0, last_x, last_y, 0, ts++, NULL); + for (i = 1; i < num; i++) + { + /* x = cx + r * cos(a), y = cy + r * sin(a) */ + int ax, ay; + /* each iteration is 1 degree */ + double angle = (i * (degrees / DRAG_OBJECT_AROUND_NUM_MOVES)) * M_PI / 180.0; + ax = round(cx + radius * cos(angle)); + ay = round(cy + radius * sin(angle)); + if ((ax == last_x) && (ay == last_y)) continue; + evas_event_feed_multi_move(e, touch_point, ax, ay, 1, 1, 1, 1, 0, ax, ay, ts++, NULL); + last_x = ax, last_y = ay; + } + evas_event_feed_multi_up(e, touch_point, last_x, last_y, 1, 1, 1, 1, 0, last_x, last_y, 0, ts++, NULL); + /* only count arc motion: subtract initial move, mouse down, mouse up */ + return num; +} + +int +pinch_object(Eo *obj, int x, int y, int x2, int y2, int dx, int dy, int dx2, int dy2) +{ + Evas *e = evas_object_evas_get(obj); + int i, idx, idy, idx2, idy2; + idx = idy = idx2 = idy2 = 0; + evas_event_feed_multi_down(e, 0, x, y, 1, 1, 1, 1, 0, x, y, 0, ts, NULL); + evas_event_feed_multi_down(e, 1, x2, y2, 1, 1, 1, 1, 0, x2, y2, 0, ts++, NULL); + for (i = 1; i < abs(dx); i++) + { + idx = (i * dx / abs(dx)); + idy = (i * dy / abs(dx)); + idx2 = (i * dx2 / abs(dx)); + idy2 = (i * dy2 / abs(dx)); + /* move first point along positive vector */ + evas_event_feed_multi_move(e, 0, x + idx, y + idy, 1, 1, 1, 1, 0, x + idx, y + idy, ts, NULL); + /* move second point along negative vector */ + evas_event_feed_multi_move(e, 1, x2 + idx2, y2 + idy2, 1, 1, 1, 1, 0, x2 + idx2, y2 + idy2, ts++, NULL); + /* also trigger smart calc if we're iterating just in case that's important */ + evas_smart_objects_calculate(e); + } + evas_event_feed_multi_up(e, 0, x + idx, y + idy, 1, 1, 1, 1, 0, x + idx, y + idy, 0, ts, NULL); + evas_event_feed_multi_up(e, 1, x2 + idx2, y2 + idy2, 1, 1, 1, 1, 0, x2 + idx2, y2 + idy2, 0, ts++, NULL); + return i - 2; +} + +void +write_key_sequence(Eo *obj, const char *seqence) +{ + Evas *e = evas_object_evas_get(obj); + for (unsigned int i = 0; i < strlen(seqence); ++i) + { + const char part_seq[] = {seqence[i], '\0'}; + + evas_event_feed_key_down(e, part_seq, part_seq, part_seq, part_seq, 0, NULL); + ecore_main_loop_iterate(); + evas_event_feed_key_up(e, part_seq, part_seq, part_seq, part_seq, 0, NULL); + ecore_main_loop_iterate(); + } +} + +void +force_render(Eo *win) +{ + _win_manual_render(win, NULL); } diff --git a/src/tests/elementary/suite_helpers.h b/src/tests/elementary/suite_helpers.h index 40c8dec12b..7e5a0ad105 100644 --- a/src/tests/elementary/suite_helpers.h +++ b/src/tests/elementary/suite_helpers.h @@ -4,11 +4,13 @@ #include <Evas.h> #define DRAG_OBJECT_NUM_MOVES 4 +#define DRAG_OBJECT_AROUND_NUM_MOVES 60 int suite_setup(Eina_Bool legacy); void _elm2_suite_init(void); void _elm_suite_shutdown(void); void *real_timer_add(double in, Ecore_Task_Cb cb, void *data); +void wait_timer(double in); void fail_on_errors_teardown(void); void fail_on_errors_setup(void); Eina_Bool is_forked(void); @@ -22,11 +24,58 @@ void click_part(Eo *obj, const char *part); void click_part_flags(Eo *obj, const char *part, int flags); void click_object_at(Eo *obj, int x, int y); void click_object_at_flags(Eo *obj, int x, int y, int flags); +void press_object(Eo *obj); +void press_object_flags(Eo *obj, int flags); +void press_part(Eo *obj, const char *part); +void press_part_flags(Eo *obj, const char *part, int flags); +void press_object_at(Eo *obj, int x, int y); +void press_object_at_flags(Eo *obj, int x, int y, int flags); +void multi_click_object(Eo *obj, int ids); +void multi_press_object(Eo *obj, int ids); +void multi_click_object_at(Eo *obj, int x, int y, int ids); +void multi_press_object_at(Eo *obj, int x, int y, int ids); +int multi_drag_object_around(Eo *obj, int touch_point, int cx, int cy, int radius, int degrees); +void write_key_sequence(Eo *obj, const char *seqence); void drag_object(Eo *obj, int x, int y, int dx, int dy, Eina_Bool iterate); +int drag_object_around(Eo *obj, int cx, int cy, int radius, int degrees); +int pinch_object(Eo *obj, int x, int y, int x2, int y2, int dx, int dy, int dx2, int dy2); void wheel_object(Eo *obj, Eina_Bool horiz, Eina_Bool down); void wheel_part(Eo *obj, const char *part, Eina_Bool horiz, Eina_Bool down); void wheel_object_at(Eo *obj, int x, int y, Eina_Bool horiz, Eina_Bool down); void event_callback_single_call_int_data(void *data, Evas_Object *obj EINA_UNUSED, void *event_info EINA_UNUSED); void event_callback_that_quits_the_main_loop_when_called(); void event_callback_that_increments_an_int_when_called(void *data, Evas_Object *obj, void *event_info); +void smart_callback_that_stores_event_info_to_data(void *data, Evas_Object *obj EINA_UNUSED, void *event_info); + +void force_render(Eo *win); + +#define assert_object_size_eq(obj, width, height) \ +do \ +{ \ + Eina_Size2D _sz = efl_gfx_entity_size_get((obj)); \ + ck_assert_int_eq(_sz.w, (width)); \ + ck_assert_int_eq(_sz.h, (height)); \ +} while (0) + +#define assert_object_width_eq(obj, width) \ +do \ +{ \ + Eina_Size2D _sz = efl_gfx_entity_size_get((obj)); \ + ck_assert_int_eq(_sz.w, (width)); \ +} while (0) + +#define assert_object_height_eq(obj, height) \ +do \ +{ \ + Eina_Size2D _sz = efl_gfx_entity_size_get((obj)); \ + ck_assert_int_eq(_sz.h, (height)); \ +} while (0) + +#define assert_object_pos_eq(obj, _x, _y) \ +do \ +{ \ + Eina_Position2D _pos = efl_gfx_entity_position_get((obj)); \ + ck_assert_int_eq(_pos.x, (_x)); \ + ck_assert_int_eq(_pos.y, (_y)); \ +} while (0) #endif |