int
main(int argc, char *argv[])
{
int ret = 0;
(void) argc;
(void) argv;
eo_init();
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(my_init_count != 2);
eo_do(obj, simple_a_set(1), simple_b_set(2));
int a, b;
eo_do(obj, simple_a_get(&a), simple_b_get(&b), mixin_add_and_print(5));
eo_unref(obj);
fail_if(my_init_count != 0);
obj = eo_add(SIMPLE2_CLASS, NULL);
fail_if(obj);
obj = eo_add(SIMPLE3_CLASS, NULL);
fail_if(obj);
my_init_count = 0;
obj = eo_add(SIMPLE4_CLASS, NULL);
fail_if(my_init_count != 2);
eo_unref(obj);
fail_if(my_init_count != 0);
obj = eo_add(SIMPLE5_CLASS, NULL);
fail_if(!obj);
eo_unref(obj);
obj = eo_add(SIMPLE6_CLASS, NULL);
fail_if(!obj);
eo_unref(obj);
obj = eo_add(SIMPLE7_CLASS, NULL);
fail_if(obj);
my_init_count = 0;
obj = eo_add_custom(SIMPLE_CLASS, NULL, simple_constructor(7));
fail_if(!obj);
fail_if(my_init_count != 2);
eo_do(obj, simple_a_get(&a));
fail_if(a != 7);
eo_unref(obj);
eo_shutdown();
return ret;
}
int
main(int argc, char *argv[])
{
(void) argc;
(void) argv;
eo_init();
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
eo_do(obj, simple_a_set(1), simple_b_set(2));
int a, b, sum = 0;
eo_do(obj, simple_a_get(&a), simple_b_get(&b), mixin_ab_sum_get(&sum));
fail_if(sum != a + b + 2); /* 2 for the two mixins... */
eo_do(obj, mixin_ab_sum_get(&sum), mixin_ab_sum_get(&sum));
Mixin2_Public_Data *pd2 = eo_data_get(obj, MIXIN2_CLASS);
fail_if(pd2->count != 6);
Mixin3_Public_Data *pd3 = eo_data_get(obj, MIXIN3_CLASS);
fail_if(pd3->count != 9);
eo_unref(obj);
obj = eo_add(INHERIT_CLASS, NULL);
eo_do(obj, simple_a_set(5), simple_a_get(&a));
fail_if(a != 5);
eo_unref(obj);
eo_shutdown();
return 0;
}
int
main(int argc, char *argv[])
{
(void) argc;
(void) argv;
eo_init();
Eo *obj = eo_add(INHERIT2_CLASS, NULL);
eo_do(obj, simple_a_set(1));
Simple_Public_Data *pd = eo_data_get(obj, SIMPLE_CLASS);
fail_if(pd->a != 2);
eo_unref(obj);
obj = eo_add(INHERIT3_CLASS, NULL);
eo_do(obj, simple_a_set(1));
pd = eo_data_get(obj, SIMPLE_CLASS);
fail_if(pd->a != 3);
eo_unref(obj);
obj = eo_add(INHERIT2_CLASS, NULL);
eo_do(obj, inherit2_print());
eo_unref(obj);
obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(eo_do(obj, inherit2_print2()));
fail_if(eo_do_super(obj, simple_a_print()));
fail_if(eo_do(obj, simple_class_print()));
fail_if(!eo_class_do(SIMPLE_CLASS, simple_class_print()));
fail_if(!eo_class_do(INHERIT_CLASS, simple_class_print()));
fail_if(!eo_class_do(INHERIT2_CLASS, simple_class_print()));
fail_if(!eo_class_do(INHERIT3_CLASS, simple_class_print()));
fail_if(eo_class_do(SIMPLE_CLASS, simple_a_print()));
eo_constructor_super(obj);
eo_destructor_super(obj);
eo_unref(obj);
eo_shutdown();
return 0;
}
int
main(int argc, char **argv)
{
double interval = 0.3; // tick each 0.3 seconds
Ecore_Poller *poller1, *poller2, *poller3;
char *str1 = "poller1";
char *str2 = "poller2";
char *str3 = "poller3";
if (!ecore_init())
{
printf("ERROR: Cannot init Ecore!\n");
return -1;
}
_initial_time = ecore_time_get();
ecore_poller_poll_interval_set(ECORE_POLLER_CORE, interval);
// poller1 = ecore_poller_add(ECORE_POLLER_CORE, 4, _poller_print_cb, str1);
// poller2 = ecore_poller_add(ECORE_POLLER_CORE, 8, _poller_print_cb, str2);
// poller3 = ecore_poller_add(ECORE_POLLER_CORE, 30, _poller_quit_cb, str3);
poller1 = eo_add_custom(ECORE_POLLER_CLASS, NULL,
ecore_poller_constructor(ECORE_POLLER_CORE, 4, _poller_print_cb, str1));
poller2 = eo_add_custom(ECORE_POLLER_CLASS, NULL,
ecore_poller_constructor(ECORE_POLLER_CORE, 8, _poller_print_cb, str2));
poller3 = eo_add_custom(ECORE_POLLER_CLASS, NULL,
ecore_poller_constructor(ECORE_POLLER_CORE, 20, _poller_quit_cb, str3));
ecore_main_loop_begin();
printf("changing poller2 interval to 16\n");
// ecore_poller_poller_interval_set(poller2, 16);
eo_do(poller2, ecore_poller_interval_set(16, NULL));
ecore_main_loop_begin();
eo_unref(poller1);
eo_unref(poller2);
eo_unref(poller3);
// ecore_poller_del(poller1);
// ecore_poller_del(poller2);
// ecore_poller_del(poller3);
ecore_shutdown();
}
static Eina_Bool
_event_handler_cb(void *data, int type, void *event) // event callback
{
struct context *ctxt = data;
printf("EVENT: processing callback for the event received.\n");
if (ctxt->count > 100)
{
ecore_idle_enterer_del(ctxt->enterer);
ecore_idle_exiter_del(ctxt->exiter);
// ecore_idler_del(ctxt->idler);
eo_unref(ctxt->idler);
ctxt->enterer = NULL;
ctxt->exiter = NULL;
ctxt->idler = NULL;
if (ctxt->timer)
{
ecore_timer_del(ctxt->timer);
ctxt->timer = NULL;
}
ecore_main_loop_quit();
}
return ECORE_CALLBACK_DONE; // same as EINA_FALSE
}
int
main(int argc, char *argv[])
{
(void) argc;
(void) argv;
eo_init();
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
eo_do(obj, simple_a_set(1), simple_b_set(2));
int a, b, sum = 0;
eo_do(obj, simple_a_get(&a), simple_b_get(&b), interface_ab_sum_get(&sum));
fail_if(sum != a + b);
sum = 0;
eo_do(obj, interface_ab_sum_get(&sum), interface_ab_sum_get(&sum));
fail_if(sum != a + b);
eo_do(obj, interface2_ab_sum_get2(&sum), interface2_ab_sum_get2(&sum));
fail_if(sum != a + b + 1);
eo_unref(obj);
eo_shutdown();
return 0;
}
END_TEST
START_TEST (elm_atspi_description_set)
{
elm_init(0, NULL);
Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
const char *ret = NULL;
const char *desc = "Test description";
eo_do(root, ret = elm_interface_atspi_accessible_description_get());
ck_assert(ret == NULL);
eo_do(root, elm_interface_atspi_accessible_description_set(desc));
eo_do(root, ret = elm_interface_atspi_accessible_description_get());
ck_assert(ret != NULL);
ck_assert_str_eq(ret, "Test description");
eo_unref(root);
elm_shutdown();
}
END_TEST
START_TEST (elm_atspi_children_and_parent2)
{
elm_init(0, NULL);
generate_app();
Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
Eo *win = NULL;
Eina_List *root_children;
eo_do(root, root_children = elm_interface_atspi_accessible_children_get());
win = eina_list_nth(root_children, 0);
Eina_List *win_children;
eo_do(win, win_children = elm_interface_atspi_accessible_children_get());
ck_assert(eina_list_count(win_children) == 2);
Eo *btn = NULL;
btn = eina_list_nth(win_children, 0);
ck_assert(btn != NULL);
ck_assert(btn == g_bg);
btn = eina_list_nth(win_children, 1);
ck_assert(btn != NULL);
ck_assert(btn == g_btn);
eo_unref(root);
elm_shutdown();
}
END_TEST
START_TEST (elm_atspi_children_and_parent)
{
elm_init(0, NULL);
generate_app();
Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
Eina_List *child_list = NULL;
eo_do(root, child_list = elm_interface_atspi_accessible_children_get());
//eo_do(eina_list_nth(child_list, 0), bg_child_list = elm_interface_atspi_accessible_children_get());
ck_assert(eina_list_count(child_list) == 1);
Eo *win = NULL;
win = eina_list_nth(child_list, 0);
ck_assert(win != NULL);
ck_assert(win == g_win);
eo_unref(root);
elm_shutdown();
}
EAPI Evas_Object *
edje_object_add(Evas *evas)
{
Evas_Object *e;
e = eo_add(MY_CLASS, evas);
eo_unref(e);
return e;
}
/**
* Add an idle enterer handler.
* @param func The function to call when entering an idle state.
* @param data The data to be passed to the @p func call
* @return A handle to the idle enterer callback if successful. Otherwise,
* NULL is returned.
* @note The function func will be called every time the main loop is entering
* idle state, as long as it returns 1 (or ECORE_CALLBACK_RENEW). A return of 0
* (or ECORE_CALLBACK_CANCEL) deletes the idle enterer.
*/
EAPI Ecore_Idle_Enterer *
ecore_idle_enterer_add(Ecore_Task_Cb func,
const void *data)
{
Ecore_Idle_Enterer *ie = NULL;
ie = eo_add_custom(MY_CLASS, _ecore_parent, ecore_idle_enterer_after_constructor(func, data));
eo_unref(ie);
return ie;
}
int
main(int argc, char *argv[])
{
Evas_Coord winw, winh;
{
winw = 400;
winh = 400;
}
elm_init(argc, argv);
eo_init();
Eo *win = eo_add(ELW_WIN_CLASS, NULL);
eo_do(win, evas_obj_size_set(winw, winh), evas_obj_visibility_set(EINA_TRUE));
Eo *bt = eo_add(ELW_BUTTON_CLASS, win);
eo_do(bt, evas_obj_position_set(25, 25),
evas_obj_size_set(50, 50),
evas_obj_color_set(255, 0, 0, 255),
elw_button_text_set("Click"),
evas_obj_visibility_set(EINA_TRUE));
eo_do(bt, eo_event_callback_add(EV_CLICKED, _btn_clicked_cb, "btn"));
int r, g, b, a;
eo_do(bt, evas_obj_color_get(&r, &g, &b, &a));
printf("RGBa(%d, %d, %d, %d)\n", r, g, b, a);
Eo *bx = eo_add(ELW_BOXEDBUTTON_CLASS, win);
eo_do(bx, evas_obj_position_set(100, 100),
evas_obj_size_set(70, 70),
evas_obj_color_set(0, 0, 255, 255),
elw_button_text_set("Click2"),
evas_obj_visibility_set(EINA_TRUE));
eo_do(bx, eo_event_callback_add(EV_CLICKED, _btn_clicked_cb, "bxedbtn"));
elm_run();
eo_unref(bx);
eo_unref(bt);
eo_unref(win);
eo_shutdown();
elm_shutdown();
return 0;
}
EAPI Evas_Out *
evas_out_add(Evas *e)
{
MAGIC_CHECK(e, Evas, MAGIC_EVAS);
return NULL;
MAGIC_CHECK_END();
Evas_Object *eo_obj = eo_add(MY_CLASS, e);
eo_unref(eo_obj);
return eo_obj;
}
EAPI Evas_Object *
evas_object_polygon_add(Evas *e)
{
MAGIC_CHECK(e, Evas, MAGIC_EVAS);
return NULL;
MAGIC_CHECK_END();
Evas_Object *eo_obj = eo_add(EVAS_OBJ_POLYGON_CLASS, e);
eo_unref(eo_obj);
return eo_obj;
}
EAPI Evas_Object *
evas_object_rectangle_add(Evas *e)
{
MAGIC_CHECK(e, Evas, MAGIC_EVAS);
return NULL;
MAGIC_CHECK_END();
Evas_Object *eo_obj = eo_add(EVAS_OBJ_RECTANGLE_CLASS, e);
eo_unref(eo_obj);
return eo_obj;
}
static void
bench_eo_do_general(int request)
{
int i;
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
for (i = 0 ; i < request ; i++)
{
eo_do(obj, simple_a_set(i));
}
eo_unref(obj);
}
/**
* Creates a timer to call the given function in the given period of time.
* @param in The interval in seconds.
* @param func The given function. If @p func returns 1, the timer is
* rescheduled for the next interval @p in.
* @param data Data to pass to @p func when it is called.
* @return A timer object on success. @c NULL on failure.
*
* This function adds a timer and returns its handle on success and NULL on
* failure. The function @p func will be called every @p in seconds. The
* function will be passed the @p data pointer as its parameter.
*
* When the timer @p func is called, it must return a value of either 1
* (or ECORE_CALLBACK_RENEW) or 0 (or ECORE_CALLBACK_CANCEL).
* If it returns 1, it will be called again at the next tick, or if it returns
* 0 it will be deleted automatically making any references/handles for it
* invalid.
*/
EAPI Ecore_Timer *
ecore_timer_add(double in,
Ecore_Task_Cb func,
const void *data)
{
Ecore_Timer *timer = NULL;
EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL);
timer = eo_add_custom(MY_CLASS, _ecore_parent, ecore_timer_constructor(in, func, data));
eo_unref(timer);
return timer;
}
END_TEST
START_TEST(eo_stack)
{
eo_init();
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj);
eo_do(obj, simple_recursive(123));
eo_unref(obj);
eo_shutdown();
}
END_TEST
START_TEST (elm_atspi_role_get)
{
elm_init(0, NULL);
Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
Elm_Atspi_Role role;
eo_do(root, role = elm_interface_atspi_accessible_role_get());
ck_assert(role == ELM_ATSPI_ROLE_APPLICATION);
eo_unref(root);
elm_shutdown();
}
END_TEST
START_TEST (elm_atspi_localized_role_name_get)
{
elm_init(0, NULL);
Eo* root = eo_add(ELM_ATSPI_APP_OBJECT_CLASS, NULL);
const char *ret = NULL;
eo_do(root, ret = elm_interface_atspi_accessible_localized_role_name_get());
ck_assert(ret != NULL);
eo_unref(root);
elm_shutdown();
}
END_TEST
START_TEST(eo_op_not_found_in_super)
{
eo_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj);
TEST_EO_ERROR("_eo_call_resolve", "in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'.");
eo_do_super(obj, SIMPLE_CLASS, simple_a_set(10));
fail_unless(ctx.did);
eo_unref(obj);
eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
eo_shutdown();
}
int
main(int argc, char *argv[])
{
(void) argc;
(void) argv;
eo_init();
Eo *obj = eo_add(INHERIT_CLASS, NULL);
eo_do(obj, simple_a_set(1), inherit_prot_print());
Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS);
printf("Pub: %d\n", pd->public_x2);
eo_unref(obj);
eo_shutdown();
return 0;
}
END_TEST
START_TEST(eo_api_not_implemented_call)
{
eo_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx);
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj);
TEST_EO_ERROR("_eo_api_op_id_get", "in %s:%d: unable to resolve %s api func '%s' %p in class '%s'.");
eo_do(obj, simple_no_implementation());
fail_unless(ctx.did);
eo_unref(obj);
eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
eo_shutdown();
}
int
main(int argc, char *argv[])
{
(void) argc;
(void) argv;
eo_init();
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
eo_do(obj, simple_a_set(4));
int a = 0, a2 = 0, a3 = 0;
eo_do(obj, a = simple_a_get(),
a3 = interface_a_power_3_get(),
a2 = mixin_a_square_get());
printf("Got %d %d %d\n", a, a2, a3);
eo_unref(obj);
eo_shutdown();
return 0;
}
int
main(int argc, char *argv[])
{
(void) argc;
(void) argv;
eo_init();
Eo *obj = eo_add(SIMPLE_CLASS, NULL);
Simple_Public_Data *pd = eo_data_get(obj, SIMPLE_CLASS);
/* The order of these two is undetermined. */
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
/* This will be called afterwards. */
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_DEFAULT, _a_changed_cb, (void *) 3));
/* This will never be called because the previous callback returns NULL. */
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_AFTER, _a_changed_cb, (void *) 4));
eo_do(obj, simple_a_set(1));
fail_if(cb_count != 3);
eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 3));
fail_if(pd->cb_count != 3);
eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 12));
fail_if(pd->cb_count != 3);
eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 4));
fail_if(pd->cb_count != 2);
void *ret;
eo_do(obj, eo_event_callback_del_lazy(EV_A_CHANGED, _a_changed_cb, &ret));
fail_if(pd->cb_count != 1);
eo_do(obj, eo_event_callback_del_lazy(EV_A_CHANGED, NULL, &ret));
fail_if(ret);
fail_if(pd->cb_count != 1);
eo_do(obj, eo_event_callback_del(EV_A_CHANGED, NULL, 0));
fail_if(pd->cb_count != 1);
eo_do(obj, eo_event_callback_del_lazy(EV_A_CHANGED, _a_changed_cb, &ret));
fail_if(pd->cb_count != 0);
eo_do(obj, eo_event_callback_del_lazy(EV_A_CHANGED, _a_changed_cb, &ret));
fail_if(ret);
fail_if(pd->cb_count != 0);
/* Freeze/thaw. */
int fcount = 0;
cb_count = 0;
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
fail_if(pd->cb_count != 1);
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 0);
eo_do(obj, eo_event_freeze());
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 1);
eo_do(obj, eo_event_freeze());
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 2);
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
fail_if(pd->cb_count != 1);
eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0);
eo_do(obj, eo_event_thaw());
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 1);
eo_do(obj, eo_event_thaw());
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 0);
eo_do(obj, simple_a_set(3));
fail_if(cb_count != 2);
cb_count = 0;
eo_do(obj, eo_event_thaw());
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 0);
eo_do(obj, eo_event_freeze());
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 1);
eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0);
eo_do(obj, eo_event_thaw());
eo_do(obj, eo_event_freeze_get(&fcount));
fail_if(fcount != 0);
eo_do(obj, eo_event_callback_del_lazy(EV_A_CHANGED, _a_changed_cb, &ret));
fail_if(!ret);
eo_do(obj, eo_event_callback_del_lazy(EV_A_CHANGED, _a_changed_cb, &ret));
fail_if(!ret);
eo_do(obj, eo_event_callback_del_lazy(EV_A_CHANGED, _a_changed_cb, &ret));
fail_if(ret);
/* Global Freeze/thaw. */
fcount = 0;
cb_count = 0;
pd->cb_count = 0;
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
fail_if(pd->cb_count != 1);
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 0);
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze());
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 1);
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze());
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 2);
eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
fail_if(pd->cb_count != 1);
eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0);
eo_class_do(EO_BASE_CLASS, eo_event_global_thaw());
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 1);
eo_class_do(EO_BASE_CLASS, eo_event_global_thaw());
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 0);
eo_do(obj, simple_a_set(3));
fail_if(cb_count != 2);
cb_count = 0;
eo_class_do(EO_BASE_CLASS, eo_event_global_thaw());
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 0);
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze());
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 1);
eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0);
eo_class_do(EO_BASE_CLASS, eo_event_global_thaw());
eo_class_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount));
fail_if(fcount != 0);
eo_unref(obj);
eo_shutdown();
return 0;
}
EAPI void
evas_output_del(Evas_Out *evo)
{
eo_unref(evo);
}
