EOLIAN static Eina_Bool
_efl_vpath_file_core_efl_vpath_file_do(Eo *obj, Efl_Vpath_File_Core_Data *pd)
{
const char *path;
if (efl_vpath_file_result_get(obj))
return efl_vpath_file_do(efl_super(obj, MY_CLASS));
// vpath core didn't find a match, so it'ss likely a protocol like
// http:// etc. etc. so deal with that here
path = efl_vpath_file_path_get(obj);
if (path)
{
if ((!strncasecmp(path, "http://", 7)) ||
(!strncasecmp(path, "https://", 8)))
{
// XXX: handle urls --- need a loop object
}
}
// ...
pd->dummy = 0;
// not a magic path - just set result to path
efl_vpath_file_result_set(obj, efl_vpath_file_path_get(obj));
return efl_vpath_file_do(efl_super(obj, MY_CLASS));
}
EOLIAN static Efl_Object *
_efl_vpath_file_core_efl_object_constructor(Eo *obj, Efl_Vpath_File_Core_Data *pd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
pd->dummy = 0;
return obj;
}
EOLIAN static void
_efl_net_control_technology_efl_object_destructor(Eo *o, Efl_Net_Control_Technology_Data *pd)
{
Eldbus_Pending *p;
Eldbus_Signal_Handler *sh;
EINA_LIST_FREE(pd->pending, p)
eldbus_pending_cancel(p);
EINA_LIST_FREE(pd->signal_handlers, sh)
eldbus_signal_handler_del(sh);
if (pd->proxy)
{
Eldbus_Object *obj = eldbus_proxy_object_get(pd->proxy);
eldbus_proxy_unref(pd->proxy);
pd->proxy = NULL;
eldbus_object_unref(obj);
}
efl_destructor(efl_super(o, MY_CLASS));
eina_stringshare_replace(&pd->path, NULL);
eina_stringshare_replace(&pd->name, NULL);
eina_stringshare_replace(&pd->tethering.identifier, NULL);
eina_stringshare_replace(&pd->tethering.passphrase, NULL);
}
EOLIAN static Eo *
_efl_net_ip_address_efl_object_finalize(Eo *o, Efl_Net_Ip_Address_Data *pd)
{
const uint16_t *pport;
o = efl_finalize(efl_super(o, MY_CLASS));
if (!o) return NULL;
EINA_SAFETY_ON_TRUE_RETURN_VAL(pd->addr.sa_family == 0, NULL);
if (!efl_net_ip_port_fmt(pd->string, sizeof(pd->string), &pd->addr))
{
ERR("Could not format address!");
return NULL;
}
if (pd->addr.sa_family == AF_INET6)
pport = &pd->ipv6.sin6_port;
else
pport = &pd->ipv4.sin_port;
if (*pport == 0) /* port == 0, no ":0" in the string */
{
char *d = strrchr(pd->string, ':');
EINA_SAFETY_ON_NULL_RETURN_VAL(d, NULL);
*d = '\0';
}
return o;
}
EOLIAN static Efl_Object *
_efl_net_dialer_simple_efl_object_finalize(Eo *o, Efl_Net_Dialer_Simple_Data *pd)
{
if (efl_io_buffered_stream_inner_io_get(o)) goto end;
if (!pd->inner_class)
{
ERR("no valid dialer was set with efl_io_buffered_stream_inner_io_set() and no class set with efl_net_dialer_simple_inner_class_set()!");
return NULL;
}
else
{
Eo *dialer = efl_add(pd->inner_class, o);
EINA_SAFETY_ON_NULL_RETURN_VAL(dialer, NULL);
if (!efl_isa(dialer, EFL_NET_DIALER_INTERFACE))
{
ERR("class %s=%p doesn't implement Efl.Net.Dialer interface!", efl_class_name_get(pd->inner_class), pd->inner_class);
efl_del(dialer);
return NULL;
}
DBG("created new inner dialer %p (%s)", dialer, efl_class_name_get(efl_class_get(dialer)));
efl_io_buffered_stream_inner_io_set(o, dialer);
}
end:
return efl_finalize(efl_super(o, MY_CLASS));
}
EOLIAN static Efl_Object *
_efl_input_pointer_efl_object_constructor(Eo *obj, Efl_Input_Pointer_Data *pd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
pd->fake = 1;
efl_input_reset(obj);
return obj;
}
EOLIAN static Eo *
_efl_ui_pager_efl_object_constructor(Eo *obj,
Efl_Ui_Pager_Data *pd)
{
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, NULL);
if (!elm_widget_theme_klass_get(obj))
elm_widget_theme_klass_set(obj, "pager");
obj = efl_constructor(efl_super(obj, MY_CLASS));
if (elm_widget_theme_object_set(obj, wd->resize_obj,
elm_widget_theme_klass_get(obj),
elm_widget_theme_element_get(obj),
elm_widget_theme_style_get(obj)) == EFL_UI_THEME_APPLY_ERROR_GENERIC)
CRI("Failed to set layout!");
pd->cnt = 0;
pd->loop = EFL_UI_PAGER_LOOP_DISABLED;
pd->curr.page = -1;
pd->curr.pos = 0.0;
pd->transition = NULL;
pd->indicator = NULL;
pd->fill_width = EINA_TRUE;
pd->fill_height = EINA_TRUE;
pd->page_spec.sz.w = -1;
pd->page_spec.sz.h = -1;
elm_widget_can_focus_set(obj, EINA_TRUE);
pd->page_root = efl_add(EFL_CANVAS_GROUP_CLASS, evas_object_evas_get(obj));
efl_content_set(efl_part(obj, "efl.page_root"), pd->page_root);
efl_event_callback_add(pd->page_root, EFL_GFX_ENTITY_EVENT_SIZE_CHANGED, _resize_cb, pd);
efl_event_callback_add(pd->page_root, EFL_GFX_ENTITY_EVENT_POSITION_CHANGED, _move_cb, pd);
pd->page_box = efl_add(EFL_UI_BOX_CLASS, obj);
efl_ui_widget_internal_set(pd->page_box, EINA_TRUE);
efl_canvas_group_member_add(pd->page_root, pd->page_box);
pd->foreclip = efl_add(EFL_CANVAS_RECTANGLE_CLASS,
evas_object_evas_get(obj));
efl_canvas_group_member_add(pd->page_root, pd->foreclip);
evas_object_static_clip_set(pd->foreclip, EINA_TRUE);
efl_canvas_object_clipper_set(pd->page_box, pd->foreclip);
pd->backclip = efl_add(EFL_CANVAS_RECTANGLE_CLASS,
evas_object_evas_get(obj));
efl_canvas_group_member_add(pd->page_root, pd->backclip);
evas_object_static_clip_set(pd->backclip, EINA_TRUE);
efl_gfx_entity_visible_set(pd->backclip, EINA_FALSE);
return obj;
}
EOLIAN static Eo *
_evas_canvas3d_primitive_efl_object_constructor(Eo *obj, Evas_Canvas3D_Primitive_Data *pd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
evas_canvas3d_object_type_set(obj, EVAS_CANVAS3D_OBJECT_TYPE_PRIMITIVE);
_primitive_init(pd);
return obj;
}
EOLIAN static Efl_Object *
_jk_spinner_efl_object_constructor(Eo *obj, Jk_Spinner_Data *pd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_canvas_object_type_set(obj, MY_CLASS_NAME_LEGACY);
//evas_object_smart_callbacks_descriptions_set(obj, _smart_callbacks);
elm_interface_atspi_accessible_role_set(obj, ELM_ATSPI_ROLE_SPIN_BUTTON);
return obj;
}
EOLIAN static Eo *
_elm_web_efl_object_constructor(Eo *obj, Elm_Web_Data *sd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
sd->obj = obj;
efl_canvas_object_type_set(obj, MY_CLASS_NAME_LEGACY);
evas_object_smart_callbacks_descriptions_set(obj, _elm_web_smart_callbacks);
efl_access_object_role_set(obj, EFL_ACCESS_ROLE_HTML_CONTAINER);
legacy_object_focus_handle(obj);
return obj;
}
EOLIAN static void
_efl_vpath_file_core_efl_vpath_file_wait(Eo *obj, Efl_Vpath_File_Core_Data *pd)
{
if (efl_vpath_file_result_get(obj))
{
efl_vpath_file_do(efl_super(obj, MY_CLASS));
return;
}
pd->dummy = 0;
// XXX: not found yet, so do what is necessary
}
EOLIAN static void
_efl_ui_pager_efl_object_invalidate(Eo *obj,
Efl_Ui_Pager_Data *pd)
{
efl_invalidate(efl_super(obj, MY_CLASS));
/* Since the parent of foreclip and backclip is evas, foreclip and backclip
* are not deleted automatically when pager is deleted.
* Therefore, foreclip and backclip are deleted manually here. */
efl_del(pd->foreclip);
efl_del(pd->backclip);
}
static void
_efl_model_composite_boolean_children_efl_object_destructor(Eo *obj,
Efl_Model_Composite_Boolean_Children_Data *pd)
{
if (pd->properties_names)
_properties_names_array_free(pd->properties_names);
if (pd->composite_child)
efl_unref(pd->composite_child);
efl_destructor(efl_super(obj, EFL_MODEL_COMPOSITE_BOOLEAN_CHILDREN_CLASS));
}
static Efl_Object*
_eldbus_model_arguments_efl_object_constructor(Eo *obj, Eldbus_Model_Arguments_Data *pd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
pd->obj = obj;
pd->properties_array = NULL;
pd->properties_hash = eina_hash_string_superfast_new(EINA_FREE_CB(_eldbus_model_arguments_hash_free));
pd->pending_list = NULL;
pd->proxy = NULL;
pd->arguments = NULL;
pd->name = NULL;
return obj;
}
EOLIAN static void
_efl_net_dialer_simple_efl_io_buffered_stream_inner_io_set(Eo *o, Efl_Net_Dialer_Simple_Data *pd, Efl_Object *io)
{
EINA_SAFETY_ON_FALSE_RETURN(efl_isa(io, EFL_NET_DIALER_INTERFACE));
efl_io_buffered_stream_inner_io_set(efl_super(o, MY_CLASS), io);
efl_event_callback_array_add(io, _efl_net_dialer_simple_inner_io_cbs(), o);
/* apply pending dialer values */
if (pd->pending.proxy_url)
{
pd->pending.proxy_url = EINA_FALSE;
efl_net_dialer_proxy_set(io, pd->proxy_url);
eina_stringshare_replace(&pd->proxy_url, NULL);
}
if (pd->pending.dial_timeout)
{
pd->pending.dial_timeout = EINA_FALSE;
efl_net_dialer_timeout_dial_set(io, pd->dial_timeout);
}
/* apply pending io buffered stream (own) values */
if (pd->pending.timeout_inactivity)
{
pd->pending.timeout_inactivity = EINA_FALSE;
efl_io_buffered_stream_timeout_inactivity_set(o, pd->timeout_inactivity);
}
if (pd->pending.max_queue_size_input)
{
pd->pending.max_queue_size_input = EINA_FALSE;
efl_io_buffered_stream_max_queue_size_input_set(o, pd->max_queue_size_input);
}
if (pd->pending.max_queue_size_output)
{
pd->pending.max_queue_size_output = EINA_FALSE;
efl_io_buffered_stream_max_queue_size_output_set(o, pd->max_queue_size_output);
}
if (pd->pending.read_chunk_size)
{
pd->pending.read_chunk_size = EINA_FALSE;
efl_io_buffered_stream_read_chunk_size_set(o, pd->read_chunk_size);
}
if (pd->pending.line_delimiter)
{
pd->pending.line_delimiter = EINA_FALSE;
efl_io_buffered_stream_line_delimiter_set(o, pd->line_delimiter);
free((void *)pd->line_delimiter.mem);
pd->line_delimiter.mem = NULL;
}
}
EOLIAN static void
_efl_ui_text_alert_popup_efl_canvas_group_group_calculate(Eo *obj, Efl_Ui_Text_Alert_Popup_Data *pd)
{
/* When elm_layout_sizing_eval() is called, just flag is set instead of size
* calculation.
* The actual size calculation is done here when the object is rendered to
* avoid duplicate size calculations. */
EFL_UI_POPUP_DATA_GET_OR_RETURN(obj, ppd);
if (ppd->needs_group_calc)
{
if (ppd->needs_size_calc)
_sizing_eval(obj, pd);
//Not to calculate size by super class
ppd->needs_size_calc = EINA_FALSE;
efl_canvas_group_calculate(efl_super(obj, MY_CLASS));
}
}
EOLIAN static Eo *
_efl_canvas_surface_wayland_efl_object_constructor(Eo *eo, Efl_Canvas_Surface_Wayland_Data *pd)
{
Evas_Object_Protected_Data *obj;
eo = efl_constructor(efl_super(eo, MY_CLASS));
obj = efl_data_scope_get(eo, EFL_CANVAS_OBJECT_CLASS);
if (!obj) return NULL;
if (!ENFN->image_native_init(ENDT, EVAS_NATIVE_SURFACE_WL))
{
ERR("Wayland surfaces are not supported on this platform");
return NULL;
}
pd->base = efl_data_ref(eo, EFL_CANVAS_SURFACE_MIXIN);
pd->base->surf.type = EVAS_NATIVE_SURFACE_WL;
return eo;
}
EOLIAN static Elm_Theme_Apply
_elm_photo_elm_widget_theme_apply(Eo *obj, Elm_Photo_Data *sd)
{
Elm_Theme_Apply int_ret = ELM_THEME_APPLY_FAILED;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EINA_FALSE);
int_ret = elm_obj_widget_theme_apply(efl_super(obj, MY_CLASS));
if (!int_ret) return ELM_THEME_APPLY_FAILED;
edje_object_mirrored_set
(wd->resize_obj, elm_widget_mirrored_get(obj));
elm_widget_theme_object_set
(obj, wd->resize_obj, "photo", "base",
elm_widget_style_get(obj));
elm_object_scale_set(sd->icon, elm_widget_scale_get(obj));
edje_object_scale_set(wd->resize_obj,
elm_widget_scale_get(obj) * elm_config_scale_get());
_sizing_eval(obj);
return int_ret;
}
EOLIAN static void
_efl_net_dialer_simple_efl_object_destructor(Eo *o, Efl_Net_Dialer_Simple_Data *pd)
{
Eo *inner_io;
if (pd->inner_class) pd->inner_class = NULL;
eina_stringshare_replace(&pd->proxy_url, NULL);
if (pd->line_delimiter.mem)
{
free((void *)pd->line_delimiter.mem);
pd->line_delimiter.mem = NULL;
}
inner_io = efl_io_buffered_stream_inner_io_get(o);
if (inner_io)
{
efl_event_callback_array_del(inner_io, _efl_net_dialer_simple_inner_io_cbs(), o);
if (efl_parent_get(inner_io) == o)
efl_parent_set(inner_io, NULL);
}
efl_destructor(efl_super(o, EFL_NET_DIALER_SIMPLE_CLASS));
}
EOLIAN static Eina_Error
_elm_photo_efl_ui_widget_theme_apply(Eo *obj, Elm_Photo_Data *sd)
{
Eina_Error int_ret = EFL_UI_THEME_APPLY_ERROR_GENERIC;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EINA_FALSE);
int_ret = efl_ui_widget_theme_apply(efl_super(obj, MY_CLASS));
if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
edje_object_mirrored_set
(wd->resize_obj, efl_ui_mirrored_get(obj));
elm_widget_theme_object_set
(obj, wd->resize_obj, "photo", "base",
elm_widget_style_get(obj));
elm_object_scale_set(sd->icon, efl_gfx_entity_scale_get(obj));
edje_object_scale_set(wd->resize_obj,
efl_gfx_entity_scale_get(obj) * elm_config_scale_get());
_sizing_eval(obj);
return int_ret;
}
EOLIAN static void
_jk_spinner_efl_canvas_group_group_add(Eo *obj, Jk_Spinner_Data *priv)
{
printf("jk spinner group group add \n");
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd);
JK_SPINNER_DATA_GET(obj, sd);
efl_canvas_group_add(efl_super(obj, JK_SPINNER_CLASS));
elm_widget_sub_object_parent_add(obj);
/*
pd->rect = evas_object_rectangle_add(evas_object_evas_get(obj));
//evas_object_color_set(pd->rect, rand() % 255, rand() % 255, rand() % 255, 255/2);
evas_object_show(pd->rect);
evas_object_color_set(pd->rect, rand() % 255, rand() % 255, rand() % 255, 255/2);
int r,g,b,a;
evas_object_color_get(pd->rect, &r, &g, &b, &a);
printf("color before : %d, %d, %d, %d \n", r, g, b, a);
// evas_object_smart_member_add(pd->rect, obj);
//elm_layout_content_set(obj, "elm.swallow.content", pd->rect);
evas_object_color_get(pd->rect, &r, &g, &b, &a);
printf("color after : %d, %d, %d, %d \n", r, g, b, a);
evas_object_color_set(pd->rect, rand() % 255, rand() % 255, rand() % 255, 255/2);
elm_widget_sub_object_add(obj, pd->rect);
evas_object_color_get(pd->rect, &r, &g, &b, &a);
printf("color after 222: %d, %d, %d, %d \n", r, g, b, a);
*/
elm_layout_file_set(obj, "edc/entry.edj", "main");
Evas_Object* en = elm_entry_add(obj);
elm_entry_single_line_set(en, EINA_TRUE);
elm_entry_editable_set(en, EINA_FALSE);
//pd->entry = en;
evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, 0.0);
//evas_object_size_hint_weight_set(en, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
evas_object_size_hint_align_set(en, EVAS_HINT_FILL, 0.5);
//evas_object_size_hint_align_set(en, EVAS_HINT_FILL, EVAS_HINT_FILL);
//elm_object_text_set(en, "<align=center>hello</align>");
//elm_entry_text_style_user_push(en, "DEFAULT='align=center'");
//elm_entry_text_style_user_push(en, "DEFAULT='color=#0f0'");
elm_entry_text_style_user_push(en, user_style);
evas_object_data_set(obj, "realentry", en);
const char* cur_style = elm_entry_text_style_user_peek(en);
/*
if (cur_style)
printf("Current style user: %s\n", cur_style);
else
printf("Style user stack is empty.\n");
*/
const char* yep = "aaa";
/*
elm_object_text_set(en, "aaa");
if (test == 1)
yep = "xxx";
if (test == 2)
yep = "yyy";
if (test == 3)
yep = "zzz";
test++;
*/
elm_object_text_set(en, yep);
evas_object_name_set(en, yep);
//elm_entry_scrollable_set(en, EINA_TRUE);
//elm_entry_scrollbar_policy_set(en,
// ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
//evas_object_smart_member_add(rect, en);
elm_layout_content_set(obj, "content", en);
elm_widget_sub_object_add(obj, en);
evas_object_show(en);
elm_widget_can_focus_set(obj, EINA_TRUE);
elm_layout_sizing_eval(obj);
evas_object_data_set(en, "smart", obj);
/*
evas_object_smart_callback_add(en, "activated", _entry_activated, obj);
evas_object_smart_callback_add(en, "unfocused", _entry_unfocused, obj);
evas_object_smart_callback_add(en, "changed,user", _entry_changed, obj);
//evas_object_smart_callback_add(en, "focused", _select_all, pd);
//evas_object_smart_callback_add(en, "selection,changed", _print_signal, "selection changed");
evas_object_smart_callback_add(en, "selection,cleared", _entry_cleared, pd);
//evas_object_smart_callback_add(en, "selection,start", _print_signal, "selection start");
//evas_object_smart_callback_add(en, "clicked", _print_signal, "clicked");
//evas_object_smart_callback_add(en, "cursor,changed", _print_signal, "cursor,changed");
//evas_object_smart_callback_add(en, "cursor,changed,manual", _print_signal, "cursor,changed,manual");
elm_layout_signal_callback_add(obj, "mouse,down,1", "bg",_ondown, pd);
elm_layout_signal_callback_add(obj, "mouse,move", "bg", _onmove, obj);
elm_layout_signal_callback_add(obj, "mouse,up,1", "bg", _onup, obj);
elm_layout_signal_callback_add(obj, "mouse,clicked,1", "bg", _onclicked, pd);
elm_layout_signal_callback_add(obj, "drag", "*", _drag_cb, obj);
elm_layout_signal_callback_add(obj, "drag,start", "*", _drag_start_cb, obj);
elm_layout_signal_callback_add(obj, "drag,stop", "*", _drag_stop_cb, obj);
elm_layout_signal_callback_add(obj, "drag,step", "*", _drag_stop_cb, obj);
elm_layout_signal_callback_add(obj, "drag,page", "*", _drag_stop_cb, obj);
*/
}
EOLIAN static void
_efl_input_pointer_efl_object_destructor(Eo *obj, Efl_Input_Pointer_Data *pd)
{
_efl_input_pointer_free(pd);
efl_destructor(efl_super(obj, MY_CLASS));
}
EOLIAN static void
_efl_vpath_file_core_efl_object_destructor(Eo *obj, Efl_Vpath_File_Core_Data *pd)
{
pd->dummy = 0;
efl_destructor(efl_super(obj, MY_CLASS));
}
(wd->resize_obj, "elm.drag_button_base", &pos, NULL);
edje_object_part_drag_value_set
(wd->resize_obj, "elm.drag_button_base", 1.0 - pos, 0.5);
}
EOLIAN static Eina_Error
_elm_actionslider_efl_ui_widget_theme_apply(Eo *obj, Elm_Actionslider_Data *sd EINA_UNUSED)
{
Eina_Bool mirrored;
Eina_Error int_ret = EFL_UI_THEME_APPLY_ERROR_GENERIC;
ELM_WIDGET_DATA_GET_OR_RETURN(obj, wd, EFL_UI_THEME_APPLY_ERROR_GENERIC);
mirrored = elm_object_mirrored_get(obj);
int_ret = efl_ui_widget_theme_apply(efl_super(obj, MY_CLASS));
if (int_ret == EFL_UI_THEME_APPLY_ERROR_GENERIC) return int_ret;
if (elm_object_mirrored_get(obj) != mirrored)
_mirroredness_change_eval(obj);
edje_object_message_signal_process(wd->resize_obj);
return int_ret;
}
static void
_drag_button_down_cb(void *data,
Evas_Object *o EINA_UNUSED,
const char *emission EINA_UNUSED,
const char *source EINA_UNUSED)
EOLIAN static void
_jk_spinner_efl_canvas_group_group_del(Eo *obj, Jk_Spinner_Data *pd)
{
efl_canvas_group_del(efl_super(obj, MY_CLASS));
}
#include "evas_image_private.h"
#include "efl_canvas_snapshot.eo.h"
#define MY_CLASS EFL_CANVAS_SNAPSHOT_CLASS
EOLIAN static Eo *
_efl_canvas_snapshot_efl_object_constructor(Eo *eo_obj, void *pd EINA_UNUSED)
{
Evas_Object_Protected_Data *obj;
eo_obj = efl_constructor(efl_super(eo_obj, MY_CLASS));
if (!eo_obj) return NULL;
efl_canvas_object_pass_events_set(eo_obj, EINA_TRUE);
obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
EINA_COW_STATE_WRITE_BEGIN(obj, sw, cur)
sw->snapshot = EINA_TRUE;
EINA_COW_STATE_WRITE_END(obj, sw, cur);
return eo_obj;
}
#include "efl_canvas_snapshot.eo.c"
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "Eo.h"
#include "function_overrides_simple.h"
#include "function_overrides_inherit2.h"
#include "function_overrides_inherit3.h"
#define MY_CLASS INHERIT3_CLASS
static void
_a_set(Eo *obj, void *class_data EINA_UNUSED, int a)
{
printf("%s %d\n", efl_class_name_get(MY_CLASS), a);
simple_a_set(efl_super(obj, MY_CLASS), a + 1);
}
static Eina_Bool
_class_initializer(Efl_Class *klass)
{
EFL_OPS_DEFINE(ops,
EFL_OBJECT_OP_FUNC(simple_a_set, _a_set),
);
return efl_class_functions_set(klass, &ops, NULL);
}
static const Efl_Class_Description class_desc = {
EO_VERSION,
"Inherit3",
#include "elm_priv.h"
#include "efl_ui_grid_default_item_part_icon.eo.h"
#include "efl_ui_grid_default_item_part_end.eo.h"
#include "elm_part_helper.h"
#define MY_CLASS EFL_UI_GRID_DEFAULT_ITEM_CLASS
#define MY_CLASS_PFX efl_ui_grid_default_item
#define MY_CLASS_NAME "Efl.Ui.Grid_Default_Item"
EOLIAN static Efl_Object *
_efl_ui_grid_default_item_efl_object_finalize(Eo *obj, void *pd EINA_UNUSED)
{
Eo *eo;
eo = efl_finalize(efl_super(obj, MY_CLASS));
ELM_WIDGET_DATA_GET_OR_RETURN(eo, wd, eo);
Eina_Error theme_apply = efl_ui_layout_theme_set(obj, "grid_item", NULL, NULL);
if (theme_apply == EFL_UI_THEME_APPLY_ERROR_GENERIC)
CRI("Default Item(%p) failed to set theme [efl/grid_item]!", eo);
return eo;
}
EOLIAN static void
_efl_ui_grid_default_item_efl_object_destructor(Eo *obj, void *pd EINA_UNUSED)
{
efl_destructor(efl_super(obj, MY_CLASS));
}
/* Efl.Part */
