efl_text_multiline_set(en, EINA_TRUE);
en = _create_label(win, bx);
- markup = efl_text_markup_util_text_to_markup(EFL_TEXT_MARKUP_UTIL_CLASS,
+ markup = efl_text_markup_util_text_to_markup(
"You can use the text -> markup helper\nto make coding easier.");
efl_text_markup_set(en, markup);
free(markup);
efl_text_multiline_set(en, EINA_TRUE);
en = _create_label(win, bx);
- markup = efl_text_markup_util_markup_to_text(EFL_TEXT_MARKUP_UTIL_CLASS,
+ markup = efl_text_markup_util_markup_to_text(
"You can use markup -> text helpers<ps>to make coding easier.");
efl_text_set(en, markup);
free(markup);
eina_stringshare_del(fcn);
Eina_Strbuf *flagbuf = NULL;
- int nidx = !legacy || !eolian_function_is_class(fid);
+ int nidx = !eolian_function_is_class(fid);
eina_strbuf_append_char(buf, '(');
if (nidx)
eina_strbuf_append(params, ", ");
eina_strbuf_append(params, prn);
- eina_strbuf_append_printf(params_full, ", %s", ptn);
- eina_strbuf_append_printf(params_full_imp, ", %s", ptn);
+ if (eina_strbuf_length_get(params_full) || !eolian_function_is_class(fid))
+ {
+ eina_strbuf_append(params_full, ", ");
+ eina_strbuf_append(params_full_imp, ", ");
+ }
+ eina_strbuf_append_printf(params_full, "%s", ptn);
+ eina_strbuf_append_printf(params_full_imp, "%s", ptn);
+
if (ptn[strlen(ptn) - 1] != '*')
{
eina_strbuf_append_char(params_full, ' ');
if (eina_strbuf_length_get(params))
eina_strbuf_append(params, ", ");
- eina_strbuf_append(params_full_imp, ", ");
+ if (eina_strbuf_length_get(params_full_imp) || !eolian_function_is_class(fid))
+ eina_strbuf_append(params_full_imp, ", ");
eina_strbuf_append(params_full_imp, ptn);
if (!had_star)
eina_strbuf_append_char(params_full_imp, ' ');
eina_strbuf_append(params_full_imp, " EINA_UNUSED");
eina_strbuf_append(params, prn);
- eina_strbuf_append(params_full, ", ");
+ if (eina_strbuf_length_get(params_full) || !eolian_function_is_class(fid))
+ eina_strbuf_append(params_full, ", ");
eina_strbuf_append(params_full, ptn);
if (!had_star)
eina_strbuf_append_char(params_full, ' ');
eina_strbuf_append(buf, func_suffix);
/* ([const ]Eo *obj, Data_Type *pd, impl_full_params); */
eina_strbuf_append_char(buf, '(');
- if ((ftype == EOLIAN_PROP_GET) || eolian_function_object_is_const(fid))
- eina_strbuf_append(buf, "const ");
- eina_strbuf_append(buf, "Eo *obj, ");
- eina_strbuf_append(buf, dt);
- eina_strbuf_append(buf, " *pd");
+ if (!eolian_function_is_class(fid))
+ {
+ if ((ftype == EOLIAN_PROP_GET) || eolian_function_object_is_const(fid))
+ eina_strbuf_append(buf, "const ");
+ eina_strbuf_append(buf, "Eo *obj, ");
+ eina_strbuf_append(buf, dt);
+ eina_strbuf_append(buf, " *pd");
+ }
eina_strbuf_append(buf, eina_strbuf_string_get(params_full_imp));
+ if (eina_strbuf_length_get(params_full_imp) == 0 && eolian_function_is_class(fid))
+ eina_strbuf_append(buf, "void");
eina_strbuf_append(buf, ");\n\n");
}
eina_stringshare_del(dt);
}
- if (impl_same_class)
+ if (impl_same_class && !eolian_function_is_class(fid))
{
void *data;
Eina_Iterator *itr = eolian_property_keys_get(fid, ftype);
eina_stringshare_del(lfn);
eina_stringshare_del(eofn);
}
+ if (impl_same_class && eolian_function_is_class(fid))
+ {
+ eina_strbuf_append(buf, "EOAPI ");
+ if (rtp)
+ eina_strbuf_append(buf, eolian_type_c_type_get(rtp, EOLIAN_C_TYPE_RETURN));
+ else
+ eina_strbuf_append(buf, "void");
+ eina_strbuf_append(buf, " ");
+ eina_strbuf_append(buf, eolian_function_full_c_name_get(fid, ftype, EINA_FALSE));
+ eina_strbuf_append(buf, "(");
+ if (eina_strbuf_length_get(params_full) == 0)
+ eina_strbuf_append(buf, "void");
+ else
+ eina_strbuf_append_buffer(buf, params_full);
+ eina_strbuf_append(buf, ")\n");
+ eina_strbuf_append(buf, "{\n");
+ eina_strbuf_append_printf(buf, " %s();\n", eolian_class_c_get_function_name_get(cl));
+ if (rtp)
+ eina_strbuf_append(buf, " return ");
+ else
+ eina_strbuf_append(buf, " ");
+ eina_strbuf_append_printf(buf, "_%s", ocnamel);
+ eina_strbuf_append_char(buf, '_');
+ eina_strbuf_append(buf, eolian_function_name_get(fid));
+ eina_strbuf_append(buf, func_suffix);
+ eina_strbuf_append(buf, "(");
+ eina_strbuf_append_buffer(buf, params);
+ eina_strbuf_append(buf, ");\n");
+ eina_strbuf_append(buf, "}\n");
+ }
free(cname);
free(cnamel);
eina_strbuf_append(buf, "\nstatic Eina_Bool\n_");
eina_strbuf_append(buf, cnamel);
eina_strbuf_append(buf, "_class_initializer(Efl_Class *klass)\n{\n");
- eina_strbuf_append(buf, " const Efl_Object_Ops *opsp = NULL, *copsp = NULL;\n\n");
+ eina_strbuf_append(buf, " const Efl_Object_Ops *opsp = NULL;\n\n");
- Eina_Strbuf *ops = eina_strbuf_new(), *cops = eina_strbuf_new();
+ Eina_Strbuf *ops = eina_strbuf_new();
/* start over with clean itearator */
const Eolian_Implement *imp;
Eolian_Function_Type ftype;
const Eolian_Function *fid = eolian_implement_function_get(imp, &ftype);
+ if (eolian_function_is_class(fid)) continue;
+
Eina_Strbuf *obuf = ops;
- if (eolian_function_is_class(fid))
- obuf = cops;
if (!eina_strbuf_length_get(obuf))
- eina_strbuf_append_printf(obuf, " EFL_OPS_DEFINE(%s,\n",
- (obuf == ops) ? "ops" : "cops");
+ eina_strbuf_append_printf(obuf, " EFL_OPS_DEFINE(ops,\n");
Eina_Bool found_get = !!eina_hash_find(_funcs_params_init_get, &imp);
Eina_Bool found_set = !!eina_hash_find(_funcs_params_init_set, &imp);
eina_strbuf_append(buf, " opsp = &ops;\n");
eina_strbuf_append(buf, "#endif\n\n");
}
- if (eina_strbuf_length_get(cops))
- {
- eina_strbuf_append_printf(buf, "#ifndef %s_EXTRA_CLASS_OPS\n", cnameu);
- eina_strbuf_append_printf(buf, "#define %s_EXTRA_CLASS_OPS\n", cnameu);
- eina_strbuf_append(buf, "#endif\n\n");
-
- eina_strbuf_append_printf(cops, " %s_EXTRA_CLASS_OPS\n );\n", cnameu);
- eina_strbuf_append(buf, eina_strbuf_string_get(cops));
- eina_strbuf_append(buf, " copsp = &cops;\n\n");
- }
- else
- {
- eina_strbuf_append_printf(buf, "#ifdef %s_EXTRA_CLASS_OPS\n", cnameu);
- eina_strbuf_append_printf(buf, " EFL_OPS_DEFINE(cops, %s_EXTRA_CLASS_OPS);\n", cnameu);
- eina_strbuf_append(buf, " copsp = &cops;\n");
- eina_strbuf_append(buf, "#endif\n\n");
- }
- eina_strbuf_append(buf, " return efl_class_functions_set(klass, opsp, copsp, NULL);\n");
+ eina_strbuf_append(buf, " return efl_class_functions_set(klass, opsp, NULL, NULL);\n");
eina_strbuf_free(ops);
- eina_strbuf_free(cops);
eina_strbuf_append(buf, "}\n\n");
<< (do_super ? " protected " : " private ") << "static extern "
<< eolian_mono::marshall_type(true)
<< " " << string
- << "(System.IntPtr obj"
- << *grammar::attribute_reorder<-1, -1>
+ << "(" << (f.is_static ? "" : "System.IntPtr obj")
+ << ((!f.is_static && (f.parameters.size() > 0)) ? ", " : "")
+ << (grammar::attribute_reorder<-1, -1>
(
- (", " << marshall_annotation << " " << marshall_parameter)
- )
+ (marshall_annotation << " " << marshall_parameter)
+ ) % ",")
<< ");\n")
.generate(sink, std::make_tuple(f.return_type, f.return_type, f.c_name, f.parameters), context))
return false;
if (do_super && !f.is_static)
self = "(inherited ? Efl.Eo.Globals.efl_super(" + self + ", this.NativeClass) : " + self + ")";
else if (f.is_static)
- self = name_helpers::klass_get_full_name(f.klass) + "()";
+ self = "";
if(!as_generator
(scope_tab << ((do_super && !f.is_static) ? "virtual " : "") << "public " << (f.is_static ? "static " : "") << return_type << " " << string << "(" << (parameter % ", ")
<< ") {\n "
<< eolian_mono::function_definition_preamble() << string << "("
- << self
- << *(", " << argument_invocation ) << ");\n"
+ << self << ((!f.is_static && (f.parameters.size() > 0)) ? "," : "")
+ << (argument_invocation % ", ") << ");\n"
<< eolian_mono::function_definition_epilogue()
<< " }\n")
.generate(sink, std::make_tuple(name_helpers::managed_method_name(f), f.parameters, f, f.c_name, f.parameters, f), context))
for (i = 1; i < argc; i++)
{
const char *address = argv[i];
- Eo *o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, address);
+ Eo *o = efl_net_ip_address_parse( address);
if (o)
{
_print_ip_addr_info(o);
}
else
{
- Eina_Future *f = efl_net_ip_address_resolve(EFL_NET_IP_ADDRESS_CLASS, address, 0, 0);
+ Eina_Future *f = efl_net_ip_address_resolve( address, 0, 0);
eina_future_then(f, _resolved, address);
printf("INFO: %s is not numeric, resolving...\n", address);
resolving = eina_list_append(resolving, f);
efl_net_ssl_context_hostname_set(efl_added, hostname_override),
efl_net_ssl_context_setup(efl_added, cipher, EINA_TRUE));
#else
- ssl_ctx = efl_net_ssl_context_default_dialer_get(EFL_NET_SSL_CONTEXT_CLASS);
+ ssl_ctx = efl_net_ssl_context_default_dialer_get();
fprintf(stderr, "INFO: using default context for dialers.\n");
#endif
Filter *f;
Ecore_Event_Message_Handler_Data *eemhd;
Eo *ecore_event_handler = efl_loop_message_handler_get
- (EFL_LOOP_CLASS, obj, ECORE_EVENT_MESSAGE_HANDLER_CLASS);
+ (obj, ECORE_EVENT_MESSAGE_HANDLER_CLASS);
if (!ecore_event_handler) return;
eemhd = efl_data_scope_get(ecore_event_handler, MY_CLASS);
if ((!choice) || (!choice[0])) choice = "chained_mempool";
_event_msg_handler =
- efl_loop_message_handler_get(EFL_LOOP_CLASS,
- _mainloop_singleton,
+ efl_loop_message_handler_get(_mainloop_singleton,
ECORE_EVENT_MESSAGE_HANDLER_CLASS);
if (!_event_msg_handler)
{
Efl_Version _app_efl_version = { 0, 0, 0, 0, NULL, NULL };
EOLIAN static Efl_App*
-_efl_app_app_main_get(const Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_app_app_main_get(void)
{
if (_mainloop_singleton) return _mainloop_singleton;
_mainloop_singleton = efl_add_ref(EFL_APP_CLASS, NULL);
}
EOLIAN static Efl_Core_Env*
-_efl_core_proc_env_self(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_core_proc_env_self(void)
{
if (!env)
{
GENERIC_ALLOC_SIZE_DECLARE(Efl_Loop_Promise_Simple_Data);
EOLIAN static Efl_Loop_Message_Handler *
-_efl_loop_message_handler_get(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Efl_Loop *loop, const Efl_Class *klass)
+_efl_loop_message_handler_get(Efl_Loop *loop, const Efl_Class *klass)
{
Message_Handler mh = { 0 }, *mh2;
Efl_Loop_Data *ld = efl_data_scope_get(loop, EFL_LOOP_CLASS);
EAPI Eo *
efl_main_loop_get(void)
{
- return efl_app_main_get(EFL_APP_CLASS);
+ return efl_app_main_get();
}
EOLIAN static void
pd->epoll_fd = -1;
pd->timer_fd = -1;
pd->future_message_handler = efl_loop_message_handler_get
- (EFL_LOOP_CLASS, obj, EFL_LOOP_MESSAGE_FUTURE_HANDLER_CLASS);
+ (obj, EFL_LOOP_MESSAGE_FUTURE_HANDLER_CLASS);
return obj;
}
eina_array_push(cml, arg);
}
- efl_core_command_line_command_array_set(efl_app_main_get(EFL_APP_CLASS), cml);
+ efl_core_command_line_command_array_set(efl_app_main_get(), cml);
efl_future_then(efl_main_loop_get(), efl_loop_job(efl_main_loop_get()),
.success = _efl_loop_arguments_send,
.free = _efl_loop_arguments_cleanup,
if (url_con->time.condition != ECORE_CON_URL_TIME_NONE)
{
- char *ts = efl_net_dialer_http_date_serialize(EFL_NET_DIALER_HTTP_CLASS, url_con->time.stamp);
+ char *ts = efl_net_dialer_http_date_serialize(url_con->time.stamp);
if (ts)
{
efl_net_dialer_http_request_header_add(url_con->dialer,
}
EOLIAN static int64_t
-_efl_net_dialer_http_date_parse(Efl_Class *cls EINA_UNUSED, void *cd EINA_UNUSED, const char *str)
+_efl_net_dialer_http_date_parse(const char *str)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(str, 0);
return curl_getdate(str, NULL);
}
EOLIAN static char *
-_efl_net_dialer_http_date_serialize(Efl_Class *cls EINA_UNUSED, void *cd EINA_UNUSED, int64_t ts)
+_efl_net_dialer_http_date_serialize(int64_t ts)
{
static const char *const wkday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
static const char * const month[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
else
{
if (!pd->ssl_ctx)
- pd->ssl_ctx = efl_ref(efl_net_ssl_context_default_dialer_get(EFL_NET_SSL_CONTEXT_CLASS));
+ pd->ssl_ctx = efl_ref(efl_net_ssl_context_default_dialer_get());
efl_net_socket_ssl_adopt(o, pd->sock, pd->ssl_ctx);
}
}
}
- remote_address = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, addr->ai_addr);
+ remote_address = efl_net_ip_address_create_sockaddr(addr->ai_addr);
if (remote_address)
{
efl_net_socket_udp_init(o, remote_address);
}
EOLIAN static Efl_Net_Ip_Address *
-_efl_net_ip_address_create(Eo *cls, void *pd EINA_UNUSED, uint16_t port, const Eina_Slice address)
+_efl_net_ip_address_create(uint16_t port, const Eina_Slice address)
{
int family;
else
family = AF_INET;
- return efl_add_ref(cls, efl_main_loop_get(),
+ return efl_add_ref(EFL_NET_IP_ADDRESS_CLASS, efl_main_loop_get(),
efl_net_ip_address_family_set(efl_added, family),
efl_net_ip_address_port_set(efl_added, port),
efl_net_ip_address_set(efl_added, address));
}
EOLIAN static Efl_Net_Ip_Address *
-_efl_net_ip_address_create_sockaddr(Eo *cls, void *pd EINA_UNUSED, const void *ptr)
+_efl_net_ip_address_create_sockaddr(const void *ptr)
{
const struct sockaddr *sockaddr = ptr;
EINA_SAFETY_ON_NULL_RETURN_VAL(sockaddr, NULL);
EINA_SAFETY_ON_TRUE_RETURN_VAL((sockaddr->sa_family != AF_INET) && (sockaddr->sa_family != AF_INET6), NULL);
- return efl_add_ref(cls, efl_main_loop_get(),
+ return efl_add_ref(EFL_NET_IP_ADDRESS_CLASS, efl_main_loop_get(),
efl_net_ip_address_sockaddr_set(efl_added, sockaddr));
}
EOLIAN static Efl_Net_Ip_Address *
-_efl_net_ip_address_parse(Eo *cls, void *pd EINA_UNUSED, const char *numeric_address)
+_efl_net_ip_address_parse(const char *numeric_address)
{
struct sockaddr_storage ss;
Eina_Bool r;
return NULL;
}
- return efl_add_ref(cls, efl_main_loop_get(),
+ return efl_add_ref(EFL_NET_IP_ADDRESS_CLASS, efl_main_loop_get(),
efl_net_ip_address_sockaddr_set(efl_added, &ss));
}
if (EINA_UNLIKELY(_efl_net_ip_address_find(&r, a->ai_addr) >= 0))
continue;
- o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, a->ai_addr);
+ o = efl_net_ip_address_create_sockaddr(a->ai_addr);
if (!o) continue ;
eina_value_array_append(&r, o);
}
EOLIAN static Eina_Future *
-_efl_net_ip_address_resolve(Eo *cls EINA_UNUSED, void *pd EINA_UNUSED, const char *address, int family, int flags)
+_efl_net_ip_address_resolve(const char *address, int family, int flags)
{
Efl_Net_Ip_Address_Resolve_Context *ctx;
struct addrinfo hints = { };
}
EOLIAN static Efl_Net_Ssl_Context *
-_efl_net_ssl_context_default_dialer_get(const Efl_Class *klass, void *pd EINA_UNUSED)
+_efl_net_ssl_context_default_dialer_get(void)
{
if (!_efl_net_ssl_context_default_dialer)
{
- _efl_net_ssl_context_default_dialer = efl_add(klass, efl_main_loop_get(),
+ _efl_net_ssl_context_default_dialer = efl_add(EFL_NET_SSL_CONTEXT_CLASS, efl_main_loop_get(),
efl_net_ssl_context_verify_mode_set(efl_added, EFL_NET_SSL_VERIFY_MODE_REQUIRED),
efl_net_ssl_context_hostname_verify_set(efl_added, EINA_TRUE),
efl_net_ssl_context_default_paths_load_set(efl_added, EINA_TRUE),
{
char *mkup;
mkup = efl_text_markup_util_text_to_markup(
- EFL_TEXT_MARKUP_UTIL_CLASS,
text);
rp->typedata.text->text = eina_stringshare_add(mkup);
free(mkup);
}
EOLIAN static char*
-_efl_text_markup_util_text_to_markup(Eo *class EINA_UNUSED,
- void *_pd EINA_UNUSED, const char *text)
+_efl_text_markup_util_text_to_markup(const char *text)
{
Eina_Strbuf *sbuf;
char *str = NULL;
}
static EOLIAN char*
-_efl_text_markup_util_markup_to_text(Eo *class EINA_UNUSED,
- void *_pd EINA_UNUSED, const char *text)
+_efl_text_markup_util_markup_to_text(const char *text)
{
return _text_util_markup_to_text(text);
}
}
EOLIAN void
-_efl_access_object_event_emit(Eo *class EINA_UNUSED, void *pd EINA_UNUSED, Eo *accessible, const Efl_Event_Description *event, void *event_info)
+_efl_access_object_event_emit(Eo *accessible, const Efl_Event_Description *event, void *event_info)
+
{
Eina_List *l;
Efl_Access_Event_Handler *hdl;
}
EOLIAN Efl_Access_Event_Handler *
-_efl_access_object_event_handler_add(Eo *class EINA_UNUSED, void *pd EINA_UNUSED, Efl_Event_Cb cb, void *data)
+_efl_access_object_event_handler_add(Efl_Event_Cb cb, void *data)
{
Efl_Access_Event_Handler *ret = calloc(1, sizeof(Efl_Access_Event_Handler));
if (!ret) return NULL;
}
EOLIAN void
-_efl_access_object_event_handler_del(Eo *class EINA_UNUSED, void *pd EINA_UNUSED, Efl_Access_Event_Handler *handler)
+_efl_access_object_event_handler_del(Efl_Access_Event_Handler *handler)
{
Eina_List *l, *l2;
Efl_Access_Event_Handler *hdl;
//
EOLIAN Eo*
-_efl_access_object_access_root_get(const Eo *class EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_access_object_access_root_get(void)
{
if (!root)
root = efl_add(ELM_ATSPI_APP_OBJECT_CLASS, efl_main_loop_get());
Efl_Access_Event_State_Changed_Data evinfo; \
evinfo.type = (tp); \
evinfo.new_value = (nvl); \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_STATE_CHANGED, (void*)&evinfo); \
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_STATE_CHANGED, (void*)&evinfo); \
} while(0); }
/**
#define efl_access_bounds_changed_signal_emit(obj, x, y, width, height) \
do { \
Efl_Access_Event_Geometry_Changed_Data evinfo = { x, y, width, height }; \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_BOUNDS_CHANGED, (void*)&evinfo); \
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_BOUNDS_CHANGED, (void*)&evinfo); \
} while(0);
//TIZEN_ONLY(20160623): atspi: moved highlight when object is out of screen
#define efl_access_move_outed_signal_emit(obj, type) \
do { \
Efl_Access_Move_Outed_Type evinfo = type; \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_MOVE_OUTED, (void*)&evinfo); \
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_MOVE_OUTED, (void*)&evinfo); \
} while(0);
//
* Emits Accessible 'PropertyChanged' signal for 'Name' property.
*/
#define efl_access_i18n_name_changed_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "i18n_name");
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "i18n_name");
/**
* Emits Accessible 'PropertyChanged' signal for 'Description' property.
*/
#define efl_access_description_changed_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "description");
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "description");
/**
* Emits Accessible 'PropertyChanged' signal for 'Parent' property.
*/
#define efl_access_parent_changed_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "parent");
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "parent");
/**
* Emits Accessible 'PropertyChanged' signal for 'Role' property.
*/
#define efl_access_role_changed_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "role");
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "role");
/**
* Emits Accessible 'PropertyChanged' signal for 'Value' property.
*/
#define efl_access_value_changed_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "value");
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_PROPERTY_CHANGED, "value");
/**
* Emits Accessible 'ChildrenChanged' signal with added child as argument.
#define efl_access_children_changed_added_signal_emit(obj, child) \
do { \
Efl_Access_Event_Children_Changed_Data atspi_data = { EINA_TRUE, child }; \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED, &atspi_data); \
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED, &atspi_data); \
} while(0);
*/
//
#define efl_access_children_changed_del_signal_emit(obj, child) \
do { \
Efl_Access_Event_Children_Changed_Data atspi_data = { EINA_FALSE, child }; \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED, &atspi_data); \
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_CHILDREN_CHANGED, &atspi_data); \
} while(0);
*/
//
* Emits Accessible 'ActiveDescendantChanged' signal.
*/
#define efl_access_active_descendant_changed_signal_emit(obj, child) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_ACTIVE_DESCENDANT_CHANGED, child);
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_ACTIVE_DESCENDANT_CHANGED, child);
/**
* Emits Accessible 'VisibleDataChanged' signal.
*/
#define efl_access_visible_data_changed_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_VISIBLE_DATA_CHANGED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_VISIBLE_DATA_CHANGED, NULL);
/**
* Emits Accessible 'AddAccessible' signal.
#define efl_access_added(obj) ((void)0)/* Empty */
/*
#define efl_access_added(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_ADDED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_ADDED, NULL);
*/
//
#define efl_access_removed(obj) ((void)0)/* Empty */
/*
#define efl_access_removed(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_OBJECT_EVENT_REMOVED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_OBJECT_EVENT_REMOVED, NULL);
*/
//
* Emits 'Window:Activated' accessible signal.
*/
#define efl_access_window_activated_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_ACTIVATED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_ACTIVATED, NULL);
/**
* Emits 'Window:Deactivated' accessible signal.
*/
#define efl_access_window_deactivated_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_DEACTIVATED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_DEACTIVATED, NULL);
/**
* Emits 'Window:Created' accessible signal.
*/
#define efl_access_window_created_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_CREATED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_CREATED, NULL);
/**
* Emits 'Window:Destroyed' accessible signal.
*/
#define efl_access_window_destroyed_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_DESTROYED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_DESTROYED, NULL);
/**
* Emits 'Window:Maximized' accessible signal.
*/
#define efl_access_window_maximized_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_MAXIMIZED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_MAXIMIZED, NULL);
/**
* Emits 'Window:Minimized' accessible signal.
*/
#define efl_access_window_minimized_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_MINIMIZED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_MINIMIZED, NULL);
/**
* Emits 'Window:Restored' accessible signal.
*/
#define efl_access_window_restored_signal_emit(obj) \
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_RESTORED, NULL);
+ efl_access_object_event_emit(obj, EFL_ACCESS_WINDOW_EVENT_WINDOW_RESTORED, NULL);
#endif
// TIZEN_ONLY(20171114): Add accessibility highlight for toolbar items I7892c9433d675d9ba6618991ae46488060752c3c
_efl_ui_selection_manager_get(Eo *obj)
{
if (!efl_isa(obj, EFL_UI_WIDGET_CLASS)) return NULL;
- Eo *app = efl_app_main_get(EFL_APP_CLASS);
+ Eo *app = efl_app_main_get();
Eo *sel_man = efl_key_data_get(app, "__selection_manager");
if (!sel_man)
{
void
_efl_ui_dnd_shutdown(void)
{
- Eo *app = efl_app_main_get(EFL_APP_CLASS);
+ Eo *app = efl_app_main_get();
Eo *sel_man = efl_key_data_get(app, "__selection_manager");
efl_del(sel_man);
pd->registered_manager = elm_widget_top_get(obj);
EINA_SAFETY_ON_FALSE_RETURN(efl_isa(pd->registered_manager, EFL_UI_WIN_CLASS));
- manager = efl_ui_focus_util_active_manager(EFL_UI_FOCUS_UTIL_CLASS, pd->registered_manager);
+ manager = efl_ui_focus_util_active_manager(pd->registered_manager);
efl_ui_focus_manager_calc_register_logical(pd->registered_manager, obj, efl_ui_focus_manager_root_get(pd->registered_manager), obj);
_publish_state_change(obj, NULL, NULL);
EINA_LIST_FREE(border->one_direction, partner)
{
- Border *b = &DIRECTION_ACCESS(partner, efl_ui_focus_util_direction_complement(EFL_UI_FOCUS_UTIL_CLASS,direction));
+ Border *b = &DIRECTION_ACCESS(partner, efl_ui_focus_util_direction_complement(direction));
b->cleanup_nodes = eina_list_remove(b->cleanup_nodes, node);
}
EINA_LIST_FOREACH(border->one_direction, lnode, partner)
{
- Border *comp_border = &DIRECTION_ACCESS(partner,efl_ui_focus_util_direction_complement(EFL_UI_FOCUS_UTIL_CLASS,direction));
+ Border *comp_border = &DIRECTION_ACCESS(partner,efl_ui_focus_util_direction_complement(direction));
comp_border->cleanup_nodes = eina_list_append(comp_border->cleanup_nodes, node);
}
EINA_LIST_FREE(border->cleanup_nodes, partner)
{
- Border *b = &DIRECTION_ACCESS(partner, efl_ui_focus_util_direction_complement(EFL_UI_FOCUS_UTIL_CLASS,direction));
+ Border *b = &DIRECTION_ACCESS(partner, efl_ui_focus_util_direction_complement(direction));
b->one_direction = eina_list_remove(b->one_direction, node);
}
}
static void
_manager_changed(void *data, const Efl_Event *event EINA_UNUSED)
{
- efl_ui_focus_util_focus(EFL_UI_FOCUS_UTIL_CLASS, data);
+ efl_ui_focus_util_focus(data);
}
static Eina_Bool
}
EOLIAN static void
-_efl_ui_focus_util_focus(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Efl_Ui_Focus_Object *user)
+_efl_ui_focus_util_focus(Efl_Ui_Focus_Object *user)
{
Efl_Ui_Focus_Object *entry;
Efl_Ui_Widget *top, *o;
}
EOLIAN static Efl_Ui_Focus_Manager*
-_efl_ui_focus_util_active_manager(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Efl_Ui_Focus_Manager *manager)
+_efl_ui_focus_util_active_manager(Efl_Ui_Focus_Manager *manager)
{
while (efl_ui_focus_manager_redirect_get(manager))
manager = efl_ui_focus_manager_redirect_get(manager);
}
EOLIAN static Efl_Ui_Focus_Direction
-_efl_ui_focus_util_direction_complement(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Efl_Ui_Focus_Direction dir)
+_efl_ui_focus_util_direction_complement(Efl_Ui_Focus_Direction dir)
{
#define COMP(a,b) \
if (dir == a) return b; \
//
if (pd->focus.manager && !pd->focus.logical)
{
- efl_ui_focus_util_focus(EFL_UI_FOCUS_UTIL_CLASS, obj);
+ efl_ui_focus_util_focus(obj);
}
}
//TIZEN_ONLY(20180607): Restore legacy focus
{
Eo *root;
efl_access_window_created_signal_emit(obj);
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
if (root)
efl_access_children_changed_added_signal_emit(root, obj);
}
if (_elm_atspi_enabled())
{
Eo *root;
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
efl_access_window_destroyed_signal_emit(obj);
if (root)
efl_access_children_changed_del_signal_emit(root, obj);
}
if (!_elm_win_list)
{
- efl_event_callback_call(efl_app_main_get(EFL_APP_CLASS), EFL_APP_EVENT_STANDBY, NULL);
+ efl_event_callback_call(efl_app_main_get(), EFL_APP_EVENT_STANDBY, NULL);
if (eina_value_type_get(&exit_on_all_windows_closed))
efl_loop_quit(efl_loop_get(obj), exit_on_all_windows_closed);
}
efl_allow_parent_unref_set(obj, EINA_TRUE);
//TIZEN_ONLY(20181024): Fix parent-children incosistencies in atspi tree
- Eo *root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ Eo *root = efl_access_object_access_root_get();
efl_access_object_access_parent_set(obj, root);
//
}
EOLIAN static const Eina_Value *
-_efl_ui_win_exit_on_all_windows_closed_get(const Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_ui_win_exit_on_all_windows_closed_get(void)
{
return &exit_on_all_windows_closed;
}
EOLIAN static void
-_efl_ui_win_exit_on_all_windows_closed_set(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, const Eina_Value *exit_code)
+_efl_ui_win_exit_on_all_windows_closed_set(const Eina_Value *exit_code)
{
const Eina_Value_Type *type = eina_value_type_get(exit_code);
return (Eo *)obj;
// attach all kinds of windows directly to ATSPI application root object
- if (klass == EFL_ACCESS_OBJECT_MIXIN) return efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ if (klass == EFL_ACCESS_OBJECT_MIXIN) return efl_access_object_access_root_get();
if (klass == EFL_UI_FOCUS_PARENT_PROVIDER_INTERFACE)
return pd->provider;
}
else
{
- efl_ui_focus_util_focus(EFL_UI_FOCUS_UTIL_CLASS, obj);
+ efl_ui_focus_util_focus(obj);
efl_ui_focus_manager_move(elm_widget_top_get(obj), dir);
}
}
EINA_SAFETY_ON_NULL_RETURN_VAL(ret, NULL);
Eldbus_Message_Iter *iter = eldbus_message_iter_get(ret);
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
_bridge_iter_object_reference_append(bridge, iter, root);
return ret;
tmp = path + len; /* Skip over the prefix */
if (!strcmp(ELM_ACCESS_OBJECT_PATH_ROOT, tmp))
{
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
return root;
}
if (!eo)
return ATSPI_DBUS_PATH_NULL;
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
if (eo == root)
snprintf(path, sizeof(path), "%s%s", ELM_ACCESS_OBJECT_PATH_PREFIX, ELM_ACCESS_OBJECT_PATH_ROOT);
Efl_Access_State_Set states;
Efl_Access_Role role;
Eo *root;
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
role = efl_access_object_role_get(data);
iter_array = eldbus_message_iter_container_new(iter, 'a', CACHE_ITEM_SIGNATURE);
EINA_SAFETY_ON_NULL_GOTO(iter_array, fail);
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
to_process = eina_list_append(NULL, root);
while (to_process)
"Embed");
Eldbus_Message_Iter *iter = eldbus_message_iter_get(message);
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
_bridge_iter_object_reference_append(bridge, iter, root);
eldbus_connection_send(pd->a11y_bus, message, _on_elm_atspi_bridge_app_register, NULL, -1);
Eo *root;
ELM_ATSPI_BRIDGE_DATA_GET_OR_RETURN_VAL(bridge, pd, EINA_FALSE);
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
Eldbus_Message *message = eldbus_message_method_call_new(ATSPI_DBUS_NAME_REGISTRY,
ATSPI_DBUS_PATH_ROOT,
ELM_ATSPI_BRIDGE_DATA_GET_OR_RETURN(bridge, pd);
path = _path_from_object(obj);
- root = efl_access_object_access_root_get(EFL_ACCESS_OBJECT_MIXIN);
+ root = efl_access_object_access_root_get();
msg = eldbus_message_signal_new(path, infc, signal->name);
if (!msg) return;
if (pd->event_hash) eina_hash_free(pd->event_hash);
pd->event_hash = NULL;
- efl_access_object_event_handler_del(EFL_ACCESS_OBJECT_MIXIN, pd->event_hdlr);
+ efl_access_object_event_handler_del(pd->event_hdlr);
pd->event_hdlr = NULL;
efl_event_callback_legacy_call(bridge, ELM_ATSPI_BRIDGE_EVENT_DISCONNECTED, NULL);
_elm_atspi_bridge_app_register(obj);
// register accessible object event listener
- pd->event_hdlr = efl_access_object_event_handler_add(EFL_ACCESS_OBJECT_MIXIN, _bridge_accessible_event_dispatch, obj);
+ pd->event_hdlr = efl_access_object_event_handler_add(_bridge_accessible_event_dispatch, obj);
}
atspi_info.content = edje_info->change.insert.content;
atspi_info.pos = edje_info->change.insert.pos;
atspi_info.len = edje_info->change.insert.plain_length;
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_INSERTED, &atspi_info);
+ efl_access_object_event_emit( data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_INSERTED, &atspi_info);
}
else if (edje_info && !edje_info->insert)
{
atspi_info.content = edje_info->change.del.content;
atspi_info.pos = MIN(edje_info->change.del.start, edje_info->change.del.end);
atspi_info.len = MAX(edje_info->change.del.start, edje_info->change.del.end) - atspi_info.pos;
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_REMOVED, &atspi_info);
+ efl_access_object_event_emit( data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_REMOVED, &atspi_info);
}
}
}
atspi_info.content = text;
atspi_info.pos = edje_info->change.insert.pos;
atspi_info.len = edje_info->change.insert.plain_length;
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN,
+ efl_access_object_event_emit(
data,
EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_INSERTED,
&atspi_info);
_selection_store(ELM_SEL_TYPE_PRIMARY, data);
_update_selection_handler(data);
if (_elm_atspi_enabled())
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_SELECTION_CHANGED, NULL);
+ efl_access_object_event_emit(data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_SELECTION_CHANGED, NULL);
}
static void
efl_event_callback_legacy_call(data, ELM_ENTRY_EVENT_CURSOR_CHANGED, NULL);
if (_elm_atspi_enabled())
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_CARET_MOVED, NULL);
+ efl_access_object_event_emit(data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_CARET_MOVED, NULL);
}
static void
efl_event_callback_legacy_call
(data, ELM_ENTRY_EVENT_CURSOR_CHANGED_MANUAL, NULL);
if (_elm_atspi_enabled())
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_CARET_MOVED, NULL);
+ efl_access_object_event_emit(data, EFL_ACCESS_TEXT_EVENT_ACCESS_TEXT_CARET_MOVED, NULL);
/*************************************************************
* TIZEN_ONLY_FEATURE : Tizen Copy & Paste feature with CBHM *
#define MAP(direction, field) if (dir == EFL_UI_FOCUS_DIRECTION_ ##direction) pd->legacy_focus.field = next;
MAPPING()
#undef MAP
- dir = efl_ui_focus_util_direction_complement(EFL_UI_FOCUS_UTIL_CLASS, dir);
+ dir = efl_ui_focus_util_direction_complement(dir);
#define MAP(direction, field) if (dir == EFL_UI_FOCUS_DIRECTION_ ##direction) next_pd->legacy_focus.field = obj;
MAPPING()
#undef MAP
top = elm_object_top_widget_get(obj);
EINA_SAFETY_ON_FALSE_RETURN(efl_isa(top, EFL_UI_WIN_CLASS));
- manager_top = efl_ui_focus_util_active_manager(EFL_UI_FOCUS_UTIL_CLASS, obj);
+ manager_top = efl_ui_focus_util_active_manager(obj);
logical = efl_ui_focus_manager_focus_get(manager_top);
if (elm_widget_is(logical))
if (legacy_target)
{
- efl_ui_focus_util_focus(EFL_UI_FOCUS_UTIL_CLASS, legacy_target);
+ efl_ui_focus_util_focus(legacy_target);
if (elm_object_focused_object_get(top) == legacy_target)
{
legacy_focus_move = EINA_TRUE;
MAPPING()
#undef MAP
- return efl_ui_focus_manager_request_move(efl_ui_focus_util_active_manager(EFL_UI_FOCUS_UTIL_CLASS, top), dir, NULL, EINA_FALSE);
+ return efl_ui_focus_manager_request_move(efl_ui_focus_util_active_manager(top), dir, NULL, EINA_FALSE);
*/
return efl_ui_widget_focus_next_object_get(obj, dir);
//
}
if (focus)
- efl_ui_focus_util_focus(EFL_UI_FOCUS_UTIL_CLASS, obj);
+ efl_ui_focus_util_focus(obj);
else
{
if (efl_ui_focus_manager_focus_get(efl_ui_focus_object_focus_manager_get(obj)) == obj)
if (eo_item2 != EO_OBJ(item))
elm_menu_item_selected_set(eo_item2, 0);
}
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, EO_OBJ(item->parent), EFL_ACCESS_SELECTION_EVENT_SELECTION_CHANGED, NULL);
+ efl_access_object_event_emit(EO_OBJ(item->parent), EFL_ACCESS_SELECTION_EVENT_SELECTION_CHANGED, NULL);
}
else
{
elm_menu_item_selected_set(eo_item2, 0);
}
}
- efl_access_object_event_emit(EFL_ACCESS_OBJECT_MIXIN, WIDGET(item), EFL_ACCESS_SELECTION_EVENT_SELECTION_CHANGED, NULL);
+ efl_access_object_event_emit(WIDGET(item), EFL_ACCESS_SELECTION_EVENT_SELECTION_CHANGED, NULL);
if (sd->menu_bar && was_open)
_menu_item_select_cb(item, NULL, NULL, NULL);
}
}
EOLIAN static Elm_Sys_Notify *
-_elm_sys_notify_singleton_get(Eo *obj EINA_UNUSED,
- void *sd EINA_UNUSED)
+_elm_sys_notify_singleton_get(void)
{
if (!_singleton)
_singleton = efl_add(MY_CLASS, efl_main_loop_get());
void
_elm_unneed_sys_notify(void)
{
- Elm_Sys_Notify *manager = elm_sys_notify_singleton_get();
+ Elm_Sys_Notify *manager = elm_obj_sys_notify_singleton_get();
if (manager)
{
elm_obj_sys_notify_servers_set(manager, ELM_SYS_NOTIFY_SERVER_NONE);
/* In theory, there can be N notification managers, but
* in the implementation there will be only one: the
* singleton which is initialized here. */
- manager = elm_sys_notify_singleton_get();
+ manager = elm_obj_sys_notify_singleton_get();
if (EINA_UNLIKELY(!manager))
{
CRI("Failed to get notification manager");
}
EOLIAN static Efl_Ui_Theme *
-_efl_ui_theme_default_get(const Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_ui_theme_default_get(void)
{
if (theme_default)
return theme_default->eo_theme;
}
EOLIAN static void
-_efl_object_event_global_freeze(Eo *klass EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_object_event_global_freeze(void)
{
event_freeze_count++;
}
EOLIAN static void
-_efl_object_event_global_thaw(Eo *klass EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_object_event_global_thaw(void)
{
if (event_freeze_count > 0)
{
}
EOLIAN static int
-_efl_object_event_global_freeze_count_get(const Eo *klass EINA_UNUSED, void *pd EINA_UNUSED)
+_efl_object_event_global_freeze_count_get(void)
{
return event_freeze_count;
}
<< " __return_value = "
).generate(sink, attributes::unused, ctx)) return false;
- std::string object_flag;
- if (f.is_static) object_flag = "_eo_class()";
- else object_flag = "_eo_ptr()";
+ std::tuple<std::string, std::string, std::vector<attributes::parameter_def> > params;
+ if (f.is_static)
+ params = std::make_tuple(f.c_name, "", f.parameters);
+ else
+ params = std::make_tuple(f.c_name, "_eo_ptr()", f.parameters);
if(!as_generator
- (" ::" << string << "(" << string <<
- *(
- "\n" << scope_tab << scope_tab << ", "
+ (" ::" << string << "(" << string << ((!f.is_static && (f.parameters.size() > 0)) ? "," : "")
+ <<
+ (
+ ("\n" << scope_tab << scope_tab
<<
(
attribute_conditional([] (attributes::parameter_def const& p)
{ return p.direction == attributes::parameter_direction::in; })
[converting_argument]
| ("& __out_param_" << attribute_reorder<2>(string))
- )
+ )) % ","
)
<< ");\n"
- ).generate(sink, std::make_tuple(f.c_name, object_flag, f.parameters), ctx))
+ ).generate(sink, params, ctx))
return false;
auto out_assignments =
/* Internal EO APIs */
EOAPI EFL_FUNC_BODY_CONST(efl_input_legacy_info_get, void *, NULL)
-EOAPI EFL_FUNC_BODYV_CONST(efl_input_instance_get, Efl_Input_Event *, NULL, EFL_FUNC_CALL(owner, priv), Efl_Object *owner, void **priv)
#define EFL_INPUT_EVENT_EXTRA_OPS \
EFL_OBJECT_OP_FUNC(efl_input_legacy_info_get, NULL)
-#define EFL_INPUT_EVENT_EXTRA_CLASS_OPS \
- EFL_OBJECT_OP_FUNC(efl_input_instance_get, NULL)
-
#include "efl_input_event.eo.c"
#include "efl_input_state.eo.c"
#include "efl_input_interface.eo.c"
ecore_init();
- app = efl_app_main_get(EFL_APP_CLASS);
+ app = efl_app_main_get();
fail_if(!efl_isa(app, EFL_APP_CLASS));
efl_build_version_set(EFL_VERSION_MAJOR, EFL_VERSION_MINOR, 0, 0, NULL, EFL_BUILD_ID);
EFL_START_TEST(efl_core_env_test_process)
{
- Efl_Core_Env *env_fork, *env = efl_env_self(EFL_CORE_PROC_ENV_CLASS);
+ Efl_Core_Env *env_fork, *env = efl_env_self();
ck_assert(env);
EFL_START_TEST(efl_core_env_test_undepend_fork)
{
- Efl_Core_Env *env_fork, *env = efl_env_self(EFL_CORE_PROC_ENV_CLASS);
+ Efl_Core_Env *env_fork, *env = efl_env_self();
ck_assert(env);
ecore_init();
- t = efl_provider_find(efl_app_main_get(EFL_APP_CLASS), EFL_LOOP_CLASS);
+ t = efl_provider_find(efl_app_main_get(), EFL_LOOP_CLASS);
fail_if(!efl_isa(t, EFL_LOOP_CLASS));
fail_if(!efl_isa(t, EFL_APP_CLASS));
- t = efl_provider_find(efl_app_main_get(EFL_APP_CLASS), EFL_LOOP_TIMER_CLASS);
+ t = efl_provider_find(efl_app_main_get(), EFL_LOOP_TIMER_CLASS);
fail_if(t != NULL);
- n = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_get(EFL_APP_CLASS),
+ n = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_get(),
efl_loop_timer_interval_set(efl_added, 1.0));
- efl_loop_register(efl_app_main_get(EFL_APP_CLASS), EFL_LOOP_TIMER_CLASS, n);
+ efl_loop_register(efl_app_main_get(), EFL_LOOP_TIMER_CLASS, n);
- t = efl_provider_find(efl_app_main_get(EFL_APP_CLASS), EFL_LOOP_TIMER_CLASS);
+ t = efl_provider_find(efl_app_main_get(), EFL_LOOP_TIMER_CLASS);
fail_if(!efl_isa(t, EFL_LOOP_TIMER_CLASS));
fail_if(t != n);
- efl_loop_unregister(efl_app_main_get(EFL_APP_CLASS), EFL_LOOP_TIMER_CLASS, n);
+ efl_loop_unregister(efl_app_main_get(), EFL_LOOP_TIMER_CLASS, n);
- t = efl_provider_find(efl_app_main_get(EFL_APP_CLASS), EFL_LOOP_TIMER_CLASS);
+ t = efl_provider_find(efl_app_main_get(), EFL_LOOP_TIMER_CLASS);
fail_if(t != NULL);
ecore_shutdown();
EFL_START_TEST(efl_app_test_loop_timer_invalid)
{
- Efl_Object *t = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_get(EFL_APP_CLASS));
+ Efl_Object *t = efl_add(EFL_LOOP_TIMER_CLASS, efl_app_main_get());
fail_if(t != NULL);
}
EFL_END_TEST
static void
_resolve(struct resolve_ctx *ctx, const char *address, int family, int flags)
{
- ctx->future = efl_net_ip_address_resolve(EFL_NET_IP_ADDRESS_CLASS,
+ ctx->future = efl_net_ip_address_resolve(
address, family, flags);
ck_assert_ptr_ne(ctx->future, NULL);
ctx->future = eina_future_then(ctx->future, _resolve_done, ctx, NULL);
addr.sin_port = eina_htons(12345);
addr.sin_addr.s_addr = eina_htonl(0xabcdefafU);
- o = efl_net_ip_address_create(EFL_NET_IP_ADDRESS_CLASS,
+ o = efl_net_ip_address_create(
eina_ntohs(addr.sin_port),
slice);
_ipv4_check(o, &addr);
addr.sin_port = eina_htons(8081);
addr.sin_addr.s_addr = eina_htonl(0);
- o = efl_net_ip_address_create(EFL_NET_IP_ADDRESS_CLASS,
+ o = efl_net_ip_address_create(
eina_ntohs(addr.sin_port),
slice);
_ipv4_check(o, &addr);
addr.sin_port = eina_htons(0);
addr.sin_addr.s_addr = eina_htonl(0x12345678);
- o = efl_net_ip_address_create(EFL_NET_IP_ADDRESS_CLASS,
+ o = efl_net_ip_address_create(
eina_ntohs(addr.sin_port),
slice);
_ipv4_check(o, &addr);
Eo *o;
TRAP_ERRORS_BEGIN(eina_safety, ERR, "safety check failed: address.len != 4 && address.len != 16 is true");
- o = efl_net_ip_address_create(EFL_NET_IP_ADDRESS_CLASS,
+ o = efl_net_ip_address_create(
1234,
wrong_slice);
ck_assert_ptr_eq(o, NULL);
addr.sin_port = eina_htons(12345);
addr.sin_addr.s_addr = eina_htonl(0xabcdefafU);
- o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, &addr);
+ o = efl_net_ip_address_create_sockaddr(&addr);
ck_assert_ptr_ne(&addr, efl_net_ip_address_sockaddr_get(o));
_ipv4_check(o, &addr);
efl_unref(o);
addr.sin_port = eina_htons(0);
addr.sin_addr.s_addr = eina_htonl(0);
- o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, &addr);
+ o = efl_net_ip_address_create_sockaddr(&addr);
ck_assert_ptr_ne(&addr, efl_net_ip_address_sockaddr_get(o));
_ipv4_check(o, &addr);
efl_unref(o);
Eo *o;
TRAP_ERRORS_BEGIN(eina_safety, ERR, "safety check failed: sockaddr == NULL");
- o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, NULL);
+ o = efl_net_ip_address_create_sockaddr(NULL);
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(1);
TRAP_ERRORS_BEGIN(eina_safety, ERR, "safety check failed: (sockaddr->sa_family != AF_INET) && (sockaddr->sa_family != AF_INET6) is true");
- o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, &addr);
+ o = efl_net_ip_address_create_sockaddr(&addr);
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(1);
{
Eo *o;
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "127.0.0.1:12345");
+ o = efl_net_ip_address_parse( "127.0.0.1:12345");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "127.0.0.1:12345");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "127.0.0.1:0");
+ o = efl_net_ip_address_parse( "127.0.0.1:0");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "127.0.0.1");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "127.0.0.1");
+ o = efl_net_ip_address_parse( "127.0.0.1");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "127.0.0.1");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "192.168.0.123:80");
+ o = efl_net_ip_address_parse( "192.168.0.123:80");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "192.168.0.123:80");
efl_unref(o);
Eo *o;
TRAP_ERRORS_BEGIN(eina_safety, ERR, "safety check failed: numeric_address == NULL");
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, NULL);
+ o = efl_net_ip_address_parse( NULL);
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(1);
/* incomplete numbers */
TRAP_ERRORS_BEGIN(eina_safety, ERR, NULL);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "127.");
+ o = efl_net_ip_address_parse( "127.");
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(0); /* no error messages! */
TRAP_ERRORS_BEGIN(eina_safety, ERR, NULL);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "127.0.0.");
+ o = efl_net_ip_address_parse( "127.0.0.");
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(0); /* no error messages! */
/* hostnames are not numeric, shouldn't return an object */
TRAP_ERRORS_BEGIN(eina_safety, ERR, NULL);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "google.com");
+ o = efl_net_ip_address_parse( "google.com");
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(0); /* no error messages! */
/* port names are not numeric, shouldn't return an object */
TRAP_ERRORS_BEGIN(eina_safety, ERR, NULL);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "127.0.0.1:http");
+ o = efl_net_ip_address_parse( "127.0.0.1:http");
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(0); /* no error messages! */
struct resolve_ctx ctx = { };
TRAP_ERRORS_BEGIN(eina_safety, ERR, "safety check failed: address == NULL");
- ctx.future = efl_net_ip_address_resolve(EFL_NET_IP_ADDRESS_CLASS,
+ ctx.future = efl_net_ip_address_resolve(
NULL, 0, 0);
ck_assert_ptr_eq(ctx.future, NULL);
TRAP_ERRORS_FINISH(1);
TRAP_ERRORS_BEGIN(eina_safety, ERR, "safety check failed: (family != AF_UNSPEC) && (family != AF_INET) && (family != AF_INET6) is true");
- ctx.future = efl_net_ip_address_resolve(EFL_NET_IP_ADDRESS_CLASS,
+ ctx.future = efl_net_ip_address_resolve(
"localhost", 1234, 0);
ck_assert_ptr_eq(ctx.future, NULL);
TRAP_ERRORS_FINISH(1);
.sin_port = 0,
.sin_addr.s_addr = eina_htonl(itr->addr),
};
- Eo *o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, &a);
+ Eo *o = efl_net_ip_address_create_sockaddr(&a);
ck_assert_ptr_ne(o, NULL);
ck_assert_int_eq(efl_net_ip_address_ipv4_class_a_check(o), itr->is_a);
addr.sin6_port = eina_htons(12365);
_ipv6_set(&addr, 1, 2, 3, 4, 5, 6, 7, 8);
- o = efl_net_ip_address_create(EFL_NET_IP_ADDRESS_CLASS,
+ o = efl_net_ip_address_create(
eina_ntohs(addr.sin6_port),
slice);
_ipv6_check(o, &addr);
addr.sin6_port = eina_htons(8081);
_ipv6_set(&addr, 0, 0, 0, 0, 0, 0, 0, 0);
- o = efl_net_ip_address_create(EFL_NET_IP_ADDRESS_CLASS,
+ o = efl_net_ip_address_create(
eina_ntohs(addr.sin6_port),
slice);
_ipv6_check(o, &addr);
addr.sin6_port = eina_htons(0);
_ipv6_set(&addr, 0, 0, 0, 0, 0, 0, 0, 1);
- o = efl_net_ip_address_create(EFL_NET_IP_ADDRESS_CLASS,
+ o = efl_net_ip_address_create(
eina_ntohs(addr.sin6_port),
slice);
_ipv6_check(o, &addr);
addr.sin6_port = eina_htons(12345);
_ipv6_set(&addr, 1, 2, 3, 4, 5, 6, 7, 8);
- o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, &addr);
+ o = efl_net_ip_address_create_sockaddr(&addr);
ck_assert_ptr_ne(&addr, efl_net_ip_address_sockaddr_get(o));
_ipv6_check(o, &addr);
efl_unref(o);
addr.sin6_port = eina_htons(0);
_ipv6_set(&addr, 0, 0, 0, 0, 0, 0, 0, 0);
- o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, &addr);
+ o = efl_net_ip_address_create_sockaddr(&addr);
ck_assert_ptr_ne(&addr, efl_net_ip_address_sockaddr_get(o));
_ipv6_check(o, &addr);
efl_unref(o);
{
Eo *o;
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::1]:12345");
+ o = efl_net_ip_address_parse( "[::1]:12345");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::1]:12345");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::1]:0");
+ o = efl_net_ip_address_parse( "[::1]:0");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::1]");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::1]");
+ o = efl_net_ip_address_parse( "[::1]");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::1]");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "::1");
+ o = efl_net_ip_address_parse( "::1");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::1]");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::]:12345");
+ o = efl_net_ip_address_parse( "[::]:12345");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::]:12345");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::]:0");
+ o = efl_net_ip_address_parse( "[::]:0");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::]");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::]");
+ o = efl_net_ip_address_parse( "[::]");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::]");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "::");
+ o = efl_net_ip_address_parse( "::");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::]");
efl_unref(o);
/* IPv4 Mapped */
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::ffff:192.168.0.1]:12345");
+ o = efl_net_ip_address_parse( "[::ffff:192.168.0.1]:12345");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::ffff:192.168.0.1]:12345");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::ffff:192.168.0.1]");
+ o = efl_net_ip_address_parse( "[::ffff:192.168.0.1]");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::ffff:192.168.0.1]");
efl_unref(o);
/* IPv4 Compatible */
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::192.168.0.1]:12345");
+ o = efl_net_ip_address_parse( "[::192.168.0.1]:12345");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::192.168.0.1]:12345");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::192.168.0.1]");
+ o = efl_net_ip_address_parse( "[::192.168.0.1]");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[::192.168.0.1]");
efl_unref(o);
/* Link Local */
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[fe80::1]:12345");
+ o = efl_net_ip_address_parse( "[fe80::1]:12345");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[fe80::1]:12345");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[fe80::1]");
+ o = efl_net_ip_address_parse( "[fe80::1]");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[fe80::1]");
efl_unref(o);
/* Site Local */
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[fc00::1]:12345");
+ o = efl_net_ip_address_parse( "[fc00::1]:12345");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[fc00::1]:12345");
efl_unref(o);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[fc00::1]");
+ o = efl_net_ip_address_parse( "[fc00::1]");
ck_assert_ptr_ne(o, NULL);
ck_assert_str_eq(efl_net_ip_address_string_get(o), "[fc00::1]");
efl_unref(o);
/* incomplete numbers */
TRAP_ERRORS_BEGIN(eina_safety, ERR, NULL);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "::9999999");
+ o = efl_net_ip_address_parse( "::9999999");
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(0); /* no error messages! */
TRAP_ERRORS_BEGIN(eina_safety, ERR, NULL);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "ab:cd:ef:gh");
+ o = efl_net_ip_address_parse( "ab:cd:ef:gh");
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(0); /* no error messages! */
/* port names are not numeric, shouldn't return an object */
TRAP_ERRORS_BEGIN(eina_safety, ERR, NULL);
- o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, "[::1]:http");
+ o = efl_net_ip_address_parse( "[::1]:http");
ck_assert_ptr_eq(o, NULL);
TRAP_ERRORS_FINISH(0); /* no error messages! */
r = inet_pton(AF_INET6, itr->str, ia);
ck_assert_int_eq(r, 1);
- Eo *o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, &a);
+ Eo *o = efl_net_ip_address_create_sockaddr(&a);
ck_assert_ptr_ne(o, NULL);
ck_assert_int_eq(efl_net_ip_address_ipv4_class_a_check(o), EINA_FALSE);
/* Class Properties */
static int _dummy_test_object_klass_prop = 0;
-int _dummy_test_object_klass_prop_get(const Eo *klass, EINA_UNUSED void *pd)
+int _dummy_test_object_klass_prop_get(void)
{
- EINA_LOG_ERR("FAIL on GET");
- if (klass != dummy_test_object_class_get())
- {
- eina_error_set(EINVAL);
- return -1;
- }
+ EINA_LOG_ERR("FAIL on GET");
return _dummy_test_object_klass_prop;
}
-void _dummy_test_object_klass_prop_set(Eo *klass, EINA_UNUSED void *pd, int value)
+void _dummy_test_object_klass_prop_set(int value)
{
- EINA_LOG_ERR("FAIL on SET");
- if (klass != dummy_test_object_class_get())
- {
- eina_error_set(EINVAL);
- }
+ EINA_LOG_ERR("FAIL on SET");
_dummy_test_object_klass_prop = value;
}
{
if (pd->promise == NULL)
{
- Eo *loop = efl_app_main_get(EFL_APP_CLASS);
+ Eo *loop = efl_app_main_get();
Eina_Future_Scheduler *scheduler = efl_loop_future_scheduler_get(loop);
pd->promise = eina_promise_new(scheduler, _promise_cancelled, pd);
}
}
// Inherit
-int _dummy_inherit_helper_receive_dummy_and_call_int_out(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Dummy_Test_Object *x)
+int _dummy_inherit_helper_receive_dummy_and_call_int_out(Dummy_Test_Object *x)
{
int v = 8;
dummy_test_object_int_out (x, 5, &v);
return v;
}
-const char* _dummy_inherit_helper_receive_dummy_and_call_in_stringshare(Eo *obj EINA_UNUSED, void *pd EINA_UNUSED, Dummy_Test_Object *x)
+const char* _dummy_inherit_helper_receive_dummy_and_call_in_stringshare(Dummy_Test_Object *x)
{
return dummy_inherit_iface_stringshare_test (x, eina_stringshare_add("hello world"));
}
ck_assert_int_eq(_property_error_expected(model, "item.width"), EAGAIN);
ck_assert_int_eq(_property_error_expected(model, "item.height"), EAGAIN);
- ret__ = efl_loop_begin(efl_app_main_get(EFL_APP_CLASS));
+ ret__ = efl_loop_begin(efl_app_main_get());
real__ = efl_loop_exit_code_process(ret__);
fail_if(real__ != 0);
ck_assert_int_eq(_property_error_expected(model, "item.width"), EAGAIN);
ck_assert_int_eq(_property_error_expected(model, "item.height"), EAGAIN);
- ret__ = efl_loop_begin(efl_app_main_get(EFL_APP_CLASS));
+ ret__ = efl_loop_begin(efl_app_main_get());
real__ = efl_loop_exit_code_process(ret__);
fail_if(real__ != 0);
ck_assert_int_eq(_property_error_expected(model, "item.width"), EAGAIN);
ck_assert_int_eq(_property_error_expected(model, "item.height"), EAGAIN);
- ret__ = efl_loop_begin(efl_app_main_get(EFL_APP_CLASS));
+ ret__ = efl_loop_begin(efl_app_main_get());
real__ = efl_loop_exit_code_process(ret__);
fail_if(real__ != 0);
efl_ui_focus_manager_reset_history(m);
efl_ui_focus_manager_setup_on_first_touch(m, EFL_UI_FOCUS_DIRECTION_NEXT, root);
}
- next = efl_ui_focus_manager_focus_get(efl_ui_focus_util_active_manager(EFL_UI_FOCUS_UTIL_CLASS, m));
+ next = efl_ui_focus_manager_focus_get(efl_ui_focus_util_active_manager(m));
ck_assert_ptr_eq(next, objects[i]);
}
efl_ui_focus_manager_setup_on_first_touch(m, EFL_UI_FOCUS_DIRECTION_PREVIOUS, root);
}
- prev = efl_ui_focus_manager_focus_get(efl_ui_focus_util_active_manager(EFL_UI_FOCUS_UTIL_CLASS, m));
+ prev = efl_ui_focus_manager_focus_get(efl_ui_focus_util_active_manager(m));
ck_assert_ptr_eq(prev, objects[i - 1]);
}
ck_assert_ptr_eq(efl_ui_focus_manager_move(m, EFL_UI_FOCUS_DIRECTION_PREVIOUS), NULL);
Elm_Object_Item *it[3];
- efl_access_object_event_handler_add(EFL_ACCESS_OBJECT_MIXIN, _children_changed_cb, NULL);
+ efl_access_object_event_handler_add(_children_changed_cb, NULL);
it[0] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
ck_assert(genlist == current);
it[1] = elm_genlist_item_prepend(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
it[2] = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_TREE, NULL, NULL);
- efl_access_object_event_handler_add(EFL_ACCESS_OBJECT_MIXIN, _children_changed_cb, NULL);
+ efl_access_object_event_handler_add(_children_changed_cb, NULL);
elm_object_item_del(it[0]);
ck_assert(genlist == current);
it = elm_genlist_item_append(genlist, &itc, NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
- efl_access_object_event_handler_add(EFL_ACCESS_OBJECT_MIXIN, _children_changed_cb, NULL);
+ efl_access_object_event_handler_add(_children_changed_cb, NULL);
elm_genlist_clear(genlist);
ck_assert(genlist == current);
EFL_START_TEST (elm_win_test_app_exit_on_windows_close)
{
Eo *win = win_add(NULL, "win", ELM_WIN_BASIC);
- Eo *app = efl_app_main_get(EFL_APP_CLASS);
Eina_Value val, *exit_val;
int code;
val = eina_value_int_init(66);
- efl_ui_win_exit_on_all_windows_closed_set(win, &val);
+ efl_ui_win_exit_on_all_windows_closed_set(&val);
efl_gfx_entity_visible_set(win, EINA_TRUE);
Eina_Bool fail_flag = EINA_FALSE;
exit_val = efl_loop_begin(efl_loop_get(win));
ck_assert(eina_value_int_get(exit_val, &code));
ck_assert_int_eq(code, 66);
- efl_ui_win_exit_on_all_windows_closed_set(app, &EINA_VALUE_EMPTY);
+ efl_ui_win_exit_on_all_windows_closed_set(&EINA_VALUE_EMPTY);
}
EFL_END_TEST
{
Efl_Loop_Arguments *arge = ev->info;
-
+
fail_if(!arge->initialization);
fprintf(stderr, "ARGC %d\n", eina_array_count(arge->argv));
fail_if(eina_array_count(arge->argv) != 2);
_efl_startup_time = ecore_time_unix_get();
_EFL_APP_VERSION_SET();
fail_if(!ecore_init());
- efl_event_callback_add(efl_app_main_get(EFL_APP_CLASS), EFL_LOOP_EVENT_ARGUMENTS, efl_main, NULL);
+ efl_event_callback_add(efl_app_main_get(), EFL_LOOP_EVENT_ARGUMENTS, efl_main, NULL);
fail_if(!ecore_init_ex(argc, argv));
__EFL_MAIN_CONSTRUCTOR;
- ret__ = efl_loop_begin(efl_app_main_get(EFL_APP_CLASS));
+ ret__ = efl_loop_begin(efl_app_main_get());
real__ = efl_loop_exit_code_process(ret__);
fail_if(real__ != 0);
__EFL_MAIN_DESTRUCTOR;
else
failed_count = _efl_suite_build_and_run(0, NULL,
"Efl_Ui_Init", ui_init, NULL, NULL);
-
+
failed_count += !elm_init(1, (char*[]){"exe"});
if (buffer)
{
efl_event_callback_priority_add(obj, EV_A_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1);
fail_if(pd->cb_count != 1);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 0);
- efl_event_global_freeze(EO_CLASS);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ efl_event_global_freeze();
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 1);
- efl_event_global_freeze(EO_CLASS);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ efl_event_global_freeze();
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 2);
efl_event_callback_priority_add(obj, EV_A_CHANGED, EFL_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2);
simple_a_set(obj, 2);
fail_if(cb_count != 0);
- efl_event_global_thaw(EO_CLASS);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ efl_event_global_thaw();
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 1);
- efl_event_global_thaw(EO_CLASS);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ efl_event_global_thaw();
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 0);
simple_a_set(obj, 3);
fail_if(cb_count != 2);
cb_count = 0;
- efl_event_global_thaw(EO_CLASS);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ efl_event_global_thaw();
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 0);
- efl_event_global_freeze(EO_CLASS);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ efl_event_global_freeze();
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 1);
simple_a_set(obj, 2);
fail_if(cb_count != 0);
- efl_event_global_thaw(EO_CLASS);
- fcount = efl_event_global_freeze_count_get(EO_CLASS);
+ efl_event_global_thaw();
+ fcount = efl_event_global_freeze_count_get();
fail_if(fcount != 0);
efl_event_callback_priority_add(obj, EV_RESTART, EFL_CALLBACK_PRIORITY_DEFAULT, _restart_1_cb, NULL);
static Eina_Bool
_class_simple_class_initializer(Efl_Class *klass)
{
- const Efl_Object_Ops *opsp = NULL, *copsp = NULL;
+ const Efl_Object_Ops *opsp = NULL;
#ifndef CLASS_SIMPLE_EXTRA_OPS
#define CLASS_SIMPLE_EXTRA_OPS
);
opsp = &ops;
-#ifdef CLASS_SIMPLE_EXTRA_CLASS_OPS
- EFL_OPS_DEFINE(cops, CLASS_SIMPLE_EXTRA_CLASS_OPS);
- copsp = &cops;
-#endif
-
- return efl_class_functions_set(klass, opsp, copsp, NULL);
+ return efl_class_functions_set(klass, opsp, NULL, NULL);
}
static const Efl_Class_Description _class_simple_class_desc = {
static Eina_Bool
_function_as_argument_class_initializer(Efl_Class *klass)
{
- const Efl_Object_Ops *opsp = NULL, *copsp = NULL;
+ const Efl_Object_Ops *opsp = NULL;
#ifndef FUNCTION_AS_ARGUMENT_EXTRA_OPS
#define FUNCTION_AS_ARGUMENT_EXTRA_OPS
);
opsp = &ops;
-#ifdef FUNCTION_AS_ARGUMENT_EXTRA_CLASS_OPS
- EFL_OPS_DEFINE(cops, FUNCTION_AS_ARGUMENT_EXTRA_CLASS_OPS);
- copsp = &cops;
-#endif
-
- return efl_class_functions_set(klass, opsp, copsp, NULL);
+ return efl_class_functions_set(klass, opsp, NULL, NULL);
}
static const Efl_Class_Description _function_as_argument_class_desc = {
static Eina_Bool
_override_class_initializer(Efl_Class *klass)
{
- const Efl_Object_Ops *opsp = NULL, *copsp = NULL;
+ const Efl_Object_Ops *opsp = NULL;
#ifndef OVERRIDE_EXTRA_OPS
#define OVERRIDE_EXTRA_OPS
);
opsp = &ops;
-#ifdef OVERRIDE_EXTRA_CLASS_OPS
- EFL_OPS_DEFINE(cops, OVERRIDE_EXTRA_CLASS_OPS);
- copsp = &cops;
-#endif
-
- return efl_class_functions_set(klass, opsp, copsp, NULL);
+ return efl_class_functions_set(klass, opsp, NULL, NULL);
}
static const Efl_Class_Description _override_class_desc = {
static Eina_Bool
_owning_class_initializer(Efl_Class *klass)
{
- const Efl_Object_Ops *opsp = NULL, *copsp = NULL;
+ const Efl_Object_Ops *opsp = NULL;
#ifndef OWNING_EXTRA_OPS
#define OWNING_EXTRA_OPS
);
opsp = &ops;
-#ifdef OWNING_EXTRA_CLASS_OPS
- EFL_OPS_DEFINE(cops, OWNING_EXTRA_CLASS_OPS);
- copsp = &cops;
-#endif
-
- return efl_class_functions_set(klass, opsp, copsp, NULL);
+ return efl_class_functions_set(klass, opsp, NULL, NULL);
}
static const Efl_Class_Description _owning_class_desc = {
projects / platform / upstream / efl.git / commitdiff