Edje porting to Eo

Signed-off-by: Daniel Zaoui <daniel.zaoui@samsung.com>

SVN revision: 78305

1 files changed, 1848 insertions, 583 deletions

diff --git a/legacy/edje/src/lib/edje_util.c b/legacy/edje/src/lib/edje_util.c
index ad4525ee3b..1ff9de733e 100644
--- a/legacy/edje/src/lib/edje_util.c
+++ b/legacy/edje/src/lib/edje_util.c
@@ -349,46 +349,72 @@ edje_password_show_last_timeout_set(double password_show_last_timeout)
 EAPI Eina_Bool
 edje_object_scale_set(Evas_Object *obj, double scale)
 {
+   if (!eo_isa(obj, EDJE_OBJ_CLASS)) return EINA_FALSE;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_scale_set(scale, &ret));
+   return ret;
+}
+
+void
+_scale_set(Eo *obj, void *_pd, va_list *list)
+{
+   double scale = va_arg(*list, double);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   if (ret) *ret = EINA_TRUE;
+
    Edje *ed, *ged;
    Evas_Object *o;
    Eina_List *l;
 
-   ed = _edje_fetch(obj);
-   if (!ed) return EINA_FALSE;
-   if (ed->scale == scale) return EINA_TRUE;
+   ed = _pd;
+   if (ed->scale == scale) return;
    ed->scale = FROM_DOUBLE(scale);
    EINA_LIST_FOREACH(ed->groups, l, ged)
       ged->scale = ed->scale;
    EINA_LIST_FOREACH(ed->subobjs, l, o)
       edje_object_calc_force(o);
    edje_object_calc_force(obj);
-   return EINA_TRUE;
 }
 
 EAPI double
 edje_object_scale_get(const Evas_Object *obj)
 {
-   Edje *ed;
+   if (!obj) return 0.0;
+   double ret = 0.0;
+   eo_do((Eo *)obj, edje_obj_scale_get(&ret));
+   return ret;
+}
 
-   ed = _edje_fetch(obj);
-   if (!ed) return 0.0;
-   return TO_DOUBLE(ed->scale);
+void
+_scale_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   double *ret = va_arg(*list, double *);
+   const Edje *ed = _pd;
+   *ret = TO_DOUBLE(ed->scale);
 }
 
 EAPI Eina_Bool
 edje_object_mirrored_get(const Evas_Object *obj)
 {
-   Edje *ed;
-
-   ed = _edje_fetch(obj);
-   if (!ed) return EINA_FALSE;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_mirrored_get(&ret));
+   return ret;
+}
 
-   return ed->is_rtl;
+void
+_mirrored_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   const Edje *ed = _pd;
+   *ret = ed->is_rtl;
 }
 
 void
 _edje_object_orientation_inform(Evas_Object *obj)
 {
+   if (!obj) return;
    if (edje_object_mirrored_get(obj))
      edje_object_signal_emit(obj, "edje,state,rtl", "edje");
    else
@@ -398,11 +424,18 @@ _edje_object_orientation_inform(Evas_Object *obj)
 EAPI void
 edje_object_mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_mirrored_set(rtl));
+}
+
+void
+_mirrored_set(Eo *obj, void *_pd, va_list *list)
+{
+   Eina_Bool rtl = va_arg(*list, int);
+
+   Edje *ed = _pd;
    unsigned int i;
 
-   ed = _edje_fetch(obj);
-   if (!ed) return;
    if (ed->is_rtl == rtl) return;
 
    ed->is_rtl = rtl;
@@ -429,24 +462,46 @@ edje_object_mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 EAPI const char *
 edje_object_data_get(const Evas_Object *obj, const char *key)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const char *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_data_get(key, &ret));
+   return ret;
+}
+
+void
+_data_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *key = va_arg(*list, const char *);
+   const char **ret = va_arg(*list, const char **);
+   *ret = NULL;
+
+   const Edje *ed = _pd;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!key))
-     return NULL;
-   if (!ed->collection) return NULL;
-   if (!ed->collection->data) return NULL;
-   return edje_string_get(eina_hash_find(ed->collection->data, key));
+     return;
+   if (!ed->collection) return;
+   if (!ed->collection->data) return;
+   *ret = edje_string_get(eina_hash_find(ed->collection->data, key));
 }
 
 EAPI int
 edje_object_freeze(Evas_Object *obj)
 {
-   Edje *ed;
+   if (!obj) return 0;
+   int ret = 0;
+   eo_do(obj, edje_obj_freeze(&ret));
+   return ret;
+}
+
+void
+_freeze(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   int *ret = va_arg(*list, int *);
+
+   Edje *ed = _pd;
    unsigned int i;
 
-   ed = _edje_fetch(obj);
-   if (!ed) return 0;
+   if (ret) *ret = 0;
    for (i = 0; i < ed->table_parts_size; i++)
      {
         Edje_Real_Part *rp;
@@ -457,17 +512,27 @@ edje_object_freeze(Evas_Object *obj)
             (rp->typedata.swallow->swallowed_object))
           edje_object_freeze(rp->typedata.swallow->swallowed_object);
      }
-   return _edje_freeze(ed);
+   int int_ret = _edje_freeze(ed);
+   if (ret) *ret = int_ret;
 }
 
 EAPI int
 edje_object_thaw(Evas_Object *obj)
 {
-   Edje *ed;
+   if (!obj) return 0;
+   int ret;
+   eo_do(obj, edje_obj_thaw(&ret));
+   return ret;
+}
+
+void
+_thaw(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   int *ret = va_arg(*list, int *);
+   Edje *ed = _pd;
    unsigned int i;
 
-   ed = _edje_fetch(obj);
-   if (!ed) return 0;
+   if (ret) *ret = 0;
    for (i = 0; i < ed->table_parts_size; i++)
      {
         Edje_Real_Part *rp;
@@ -479,7 +544,8 @@ edje_object_thaw(Evas_Object *obj)
             (rp->typedata.swallow->swallowed_object))
           edje_object_thaw(rp->typedata.swallow->swallowed_object);
      }
-   return _edje_thaw(ed);
+   int int_ret = _edje_thaw(ed);
+   if (ret) *ret = int_ret;
 }
 
 EAPI Eina_Bool
@@ -645,12 +711,36 @@ _edje_color_class_list_foreach(const Eina_Hash *hash __UNUSED__, const void *key
 EAPI Eina_Bool
 edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, int g, int b, int a, int r2, int g2, int b2, int a2, int r3, int g3, int b3, int a3)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_color_class_set(color_class, r, g, b, a, r2, g2, b2, a2, r3, g3, b3, a3, &ret));
+   return ret;
+}
+
+void
+_color_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *color_class = va_arg(*list, const char *);
+   int r = va_arg(*list, int);
+   int g = va_arg(*list, int);
+   int b = va_arg(*list, int);
+   int a = va_arg(*list, int);
+   int r2 = va_arg(*list, int);
+   int g2 = va_arg(*list, int);
+   int b2 = va_arg(*list, int);
+   int a2 = va_arg(*list, int);
+   int r3 = va_arg(*list, int);
+   int g3 = va_arg(*list, int);
+   int b3 = va_arg(*list, int);
+   int a3 = va_arg(*list, int);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   if (ret) *ret = EINA_FALSE;
+
+   Edje *ed = _pd;
    Edje_Color_Class *cc;
    unsigned int i;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!color_class)) return EINA_FALSE;
+   if ((!ed) || (!color_class)) return;
    if (r < 0)        r = 0;
    else if (r > 255) r = 255;
    if (g < 0)        g = 0;
@@ -668,7 +758,10 @@ edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, in
            (cc->b2 == b2) && (cc->a2 == a2) &&
            (cc->r3 == r3) && (cc->g3 == g3) &&
            (cc->b3 == b3) && (cc->a3 == a3))
-         return EINA_TRUE;
+         {
+            if (ret) *ret = EINA_TRUE;
+            return;
+         }
        cc->r = r;
        cc->g = g;
        cc->b = b;
@@ -687,16 +780,17 @@ edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, in
        ed->all_part_change = EINA_TRUE;
 #endif
        _edje_recalc(ed);
-       return EINA_TRUE;
+       if (ret) *ret = EINA_TRUE;
+       return;
      }
 
    color_class = eina_stringshare_add(color_class);
-   if (!color_class) return EINA_FALSE;
+   if (!color_class) return;
    cc = malloc(sizeof(Edje_Color_Class));
    if (!cc)
      {
         eina_stringshare_del(color_class);
-        return EINA_FALSE;
+        return;
      }
    cc->name = color_class;
    cc->r = r;
@@ -735,13 +829,38 @@ edje_object_color_class_set(Evas_Object *obj, const char *color_class, int r, in
 
    _edje_recalc(ed);
    _edje_emit(ed, "color_class,set", color_class);
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_color_class_get(const Evas_Object *obj, const char *color_class, int *r, int *g, int *b, int *a, int *r2, int *g2, int *b2, int *a2, int *r3, int *g3, int *b3, int *a3)
 {
-   Edje *ed = _edje_fetch(obj);
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_color_class_get(color_class, r, g, b, a, r2, g2, b2, a2, r3, g3, b3, a3, &ret));
+   return ret;
+}
+
+void
+_color_class_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *color_class = va_arg(*list, const char *);
+   int *r = va_arg(*list, int *);
+   int *g = va_arg(*list, int *);
+   int *b = va_arg(*list, int *);
+   int *a = va_arg(*list, int *);
+   int *r2 = va_arg(*list, int *);
+   int *g2 = va_arg(*list, int *);
+   int *b2 = va_arg(*list, int *);
+   int *a2 = va_arg(*list, int *);
+   int *r3 = va_arg(*list, int *);
+   int *g3 = va_arg(*list, int *);
+   int *b3 = va_arg(*list, int *);
+   int *a3 = va_arg(*list, int *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   if (ret) *ret = EINA_FALSE;
+
+   const Edje *ed = _pd;
    Edje_Color_Class *cc = _edje_color_class_find(ed, color_class);
 
    if (cc)
@@ -753,7 +872,8 @@ edje_object_color_class_get(const Evas_Object *obj, const char *color_class, int
         S(r3, g3, b3, a3);
 #undef S
 #undef X
-        return EINA_TRUE;
+        if (ret) *ret = EINA_TRUE;
+        return;
      }
    else
      {
@@ -764,7 +884,7 @@ edje_object_color_class_get(const Evas_Object *obj, const char *color_class, int
         S(r3, g3, b3, a3);
 #undef S
 #undef X
-        return EINA_FALSE;
+        return;
      }
 }
 
@@ -917,13 +1037,27 @@ _edje_text_class_list_foreach(const Eina_Hash *hash __UNUSED__, const void *key,
 EAPI Eina_Bool
 edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char *font, Evas_Font_Size size)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_text_class_set(text_class, font, size, &ret));
+   return ret;
+}
+
+void
+_text_class_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *text_class = va_arg(*list, const char *);
+   const char *font = va_arg(*list, const char *);
+   Evas_Font_Size size = va_arg(*list, Evas_Font_Size);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+
+   Edje *ed = _pd;
    Eina_List *l;
    Edje_Text_Class *tc = NULL;
    unsigned int i;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!text_class)) return EINA_FALSE;
+   if ((!ed) || (!text_class)) return;
 
    /* for each text_class in the edje */
    EINA_LIST_FOREACH(ed->text_classes, l, tc)
@@ -934,7 +1068,10 @@ edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char
              if ((tc->size == size) &&
                  ((tc->font == font) ||
                      (tc->font && font && !strcmp(tc->font, font))))
-                return EINA_TRUE;
+               {
+                  if (ret) *ret = EINA_TRUE;
+                  return;
+               }
 
              /* Update new text class properties */
              eina_stringshare_replace(&tc->font, font);
@@ -947,12 +1084,12 @@ edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char
      {
         /* No matches, create a new text class */
         tc = calloc(1, sizeof(Edje_Text_Class));
-        if (!tc) return EINA_FALSE;
+        if (!tc) return;
         tc->name = eina_stringshare_add(text_class);
         if (!tc->name)
           {
              free(tc);
-             return EINA_FALSE;
+             return;
           }
         tc->font = eina_stringshare_add(font);
         tc->size = size;
@@ -980,53 +1117,92 @@ edje_object_text_class_set(Evas_Object *obj, const char *text_class, const char
 #endif
    _edje_textblock_style_all_update(ed);
    _edje_recalc(ed);
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_exists(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_exists(part, &ret));
+   return ret;
+}
+
+void
+_part_exists(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   *ret = EINA_FALSE;
+
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
-   return EINA_TRUE;
+   if (!rp) return;
+   *ret = EINA_TRUE;
 }
 
 EAPI const Evas_Object *
 edje_object_part_object_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const Evas_Object *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_object_get(part, &ret));
+   return ret;
+}
+
+void
+_part_object_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const Evas_Object **ret = va_arg(*list, const Evas_Object **);
+   *ret = NULL;
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
 
    /* Need to recalc before providing the object. */
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
-   return rp->object;
+   if (!rp) return;
+   *ret = rp->object;
 }
 
 EAPI Eina_Bool
 edje_object_part_geometry_get(const Evas_Object *obj, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h )
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_geometry_get(part, x, y, w, h, &ret));
+   return ret;
+}
+
+void
+_part_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Evas_Coord *x = va_arg(*list, Evas_Coord *);
+   Evas_Coord *y = va_arg(*list, Evas_Coord *);
+   Evas_Coord *w = va_arg(*list, Evas_Coord *);
+   Evas_Coord *h = va_arg(*list, Evas_Coord *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   if (ret) *ret = EINA_FALSE;
+
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part))
      {
         if (x) *x = 0;
         if (y) *y = 0;
         if (w) *w = 0;
         if (h) *h = 0;
-        return EINA_FALSE;
+        return;
      }
 
    /* Need to recalc before providing the object. */
@@ -1039,22 +1215,28 @@ edje_object_part_geometry_get(const Evas_Object *obj, const char *part, Evas_Coo
         if (y) *y = 0;
         if (w) *w = 0;
         if (h) *h = 0;
-        return EINA_FALSE;
+        return;
      }
    if (x) *x = rp->x;
    if (y) *y = rp->y;
    if (w) *w = rp->w;
    if (h) *h = rp->h;
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 EAPI void
 edje_object_item_provider_set(Evas_Object *obj, Edje_Item_Provider_Cb func, void *data)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_item_provider_set(func, data));
+}
 
-   ed = _edje_fetch(obj);
-   if (!ed) return;
+void
+_item_provider_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Edje_Item_Provider_Cb func = va_arg(*list, Edje_Item_Provider_Cb);
+   void *data = va_arg(*list, void *);
+   Edje *ed = _pd;
    ed->item_provider.func = func;
    ed->item_provider.data = data;
 }
@@ -1063,11 +1245,18 @@ edje_object_item_provider_set(Evas_Object *obj, Edje_Item_Provider_Cb func, void
 EAPI void
 edje_object_text_change_cb_set(Evas_Object *obj, Edje_Text_Change_Cb func, void *data)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_text_change_cb_set(func, data));
+}
+
+void
+_text_change_cb_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Edje_Text_Change_Cb func = va_arg(*list, Edje_Text_Change_Cb);
+   void *data = va_arg(*list, void *);
+   Edje *ed = _pd;
    unsigned int i;
 
-   ed = _edje_fetch(obj);
-   if (!ed) return;
    ed->text_change.func = func;
    ed->text_change.data = data;
 
@@ -1156,11 +1345,19 @@ EAPI void
 edje_object_part_text_style_user_push(Evas_Object *obj, const char *part,
                                 const char *style)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_style_user_push(part, style));
+}
+
+void
+_part_text_style_user_push(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *style = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
    Evas_Textblock_Style *ts;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part) || (!style)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1180,10 +1377,17 @@ edje_object_part_text_style_user_push(Evas_Object *obj, const char *part,
 EAPI void
 edje_object_part_text_style_user_pop(Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_style_user_pop(part));
+}
+
+void
+_part_text_style_user_pop(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1200,21 +1404,30 @@ edje_object_part_text_style_user_pop(Evas_Object *obj, const char *part)
 EAPI const char *
 edje_object_part_text_style_user_peek(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const char *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_style_user_peek(part, &ret));
+   return ret;
+}
+
+void
+_part_text_style_user_peek(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char **ret = va_arg(*list, const char **);
+   if (ret) *ret = NULL;
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
    const Evas_Textblock_Style *ts;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
-   if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return NULL;
+   if (!rp) return;
+   if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
 
    ts = evas_object_textblock_style_user_peek(rp->object);
    if (ts)
-      return evas_textblock_style_get(ts);
-   else
-      return NULL;
+      if (ret) *ret = evas_textblock_style_get(ts);
 }
 
 static void
@@ -1246,64 +1459,111 @@ _edje_user_define_string(Edje *ed, const char *part, const char *raw_text)
 EAPI Eina_Bool
 edje_object_part_text_set(Evas_Object *obj, const char *part, const char *text)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_set(part, text, &ret));
+   return ret;
+}
+
+void
+_part_text_set(Eo *obj, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *text = va_arg(*list, const char *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   if (ret) *ret = EINA_FALSE;
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
    Eina_Bool r;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if ((rp->part->type != EDJE_PART_TYPE_TEXT) &&
-       (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return EINA_FALSE;
+       (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK)) return;
    if ((rp->type != EDJE_RP_TYPE_TEXT) ||
-       (!rp->typedata.text)) return EINA_TRUE;
+       (!rp->typedata.text))
+     {
+        if (ret) *ret = EINA_TRUE;
+        return;
+     }
    r = _edje_object_part_text_raw_set(obj, rp, part, text);
    _edje_user_define_string(ed, part, rp->typedata.text->text);
-   return r;
+   if (ret) *ret = r;
 }
 
 EAPI const char *
 edje_object_part_text_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const char *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char **ret = va_arg(*list, const char **);
+   *ret = NULL;
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
 
    /* Need to recalc before providing the object. */
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if ((rp->type != EDJE_RP_TYPE_TEXT) ||
-       (!rp->typedata.text)) return NULL;
+       (!rp->typedata.text)) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
-     return _edje_entry_text_get(rp);
+     {
+        *ret = _edje_entry_text_get(rp);
+        return;
+     }
    else
      {
         if (rp->part->type == EDJE_PART_TYPE_TEXT)
-          return rp->typedata.text->text;
+          {
+             *ret = rp->typedata.text->text;
+             return;
+          }
         if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
-          return evas_object_textblock_text_markup_get(rp->object);
+          {
+             *ret = evas_object_textblock_text_markup_get(rp->object);
+             return;
+          }
      }
-   return NULL;
 }
 
 EAPI Eina_Bool
 edje_object_part_text_escaped_set(Evas_Object *obj, const char *part, const char *text)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_escaped_set(part, text, &ret));
+   return ret;
+}
+
+void
+_part_text_escaped_set(Eo *obj, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *text = va_arg(*list, const char *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   if (ret) *ret = EINA_FALSE;
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
-   Eina_Bool ret;
+   Eina_Bool int_ret;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if ((rp->type != EDJE_RP_TYPE_TEXT) ||
-       (!rp->typedata.text)) return EINA_FALSE;
+       (!rp->typedata.text)) return;
    if ((rp->part->type == EDJE_PART_TYPE_TEXT) && (text))
      {
         Eina_Strbuf *sbuf;
@@ -1354,16 +1614,17 @@ edje_object_part_text_escaped_set(Evas_Object *obj, const char *part, const char
                }
              p++;
           }
-        ret = _edje_object_part_text_raw_set
+        int_ret = _edje_object_part_text_raw_set
           (obj, rp, part, eina_strbuf_string_get(sbuf));
         _edje_user_define_string(ed, part, rp->typedata.text->text);
         eina_strbuf_free(sbuf);
-        return ret;
+        if (ret) *ret = int_ret;
+        return;
      }
-   if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return EINA_FALSE;
-   ret = _edje_object_part_text_raw_set(obj, rp, part, text);
+   if (rp->part->type != EDJE_PART_TYPE_TEXTBLOCK) return;
+   int_ret = _edje_object_part_text_raw_set(obj, rp, part, text);
    _edje_user_define_string(ed, part, rp->typedata.text->text);
-   return ret;
+   if (ret) *ret = int_ret;
 }
 
 
@@ -1478,84 +1739,129 @@ _edje_text_unescape(const char *text)
 EAPI Eina_Bool
 edje_object_part_text_unescaped_set(Evas_Object *obj, const char *part, const char *text_to_escape)
 {
-   Edje *ed;
-   Edje_Real_Part *rp;
+   if (!obj) return EINA_FALSE;
    Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_unescaped_set(part, text_to_escape, &ret));
+   return ret;
+}
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return ret;
+void
+_part_text_unescaped_set(Eo *obj, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *text_to_escape = va_arg(*list, const char *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
+   Edje_Real_Part *rp;
+   Eina_Bool int_ret;
+   if (ret) *ret = EINA_FALSE;
+
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return ret;
+   if (!rp) return;
    if ((rp->type != EDJE_RP_TYPE_TEXT) ||
-       (!rp->typedata.text)) return EINA_FALSE;
+       (!rp->typedata.text)) return;
    if (rp->part->type == EDJE_PART_TYPE_TEXT)
-     ret = _edje_object_part_text_raw_set(obj, rp, part, text_to_escape);
+     int_ret = _edje_object_part_text_raw_set(obj, rp, part, text_to_escape);
    else if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
      {
         char *text = _edje_text_escape(text_to_escape);
 
-        ret = _edje_object_part_text_raw_set(obj, rp, part, text);
+        int_ret = _edje_object_part_text_raw_set(obj, rp, part, text);
         free(text);
      }
    _edje_user_define_string(ed, part, rp->typedata.text->text);
-   return ret;
+   if (ret) *ret = int_ret;
 }
 
 EAPI char *
 edje_object_part_text_unescaped_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   char *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_unescaped_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_unescaped_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   char **ret = va_arg(*list, char **);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
 
    /* Need to recalc before providing the object. */
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if ((rp->type != EDJE_RP_TYPE_TEXT) ||
-       (!rp->typedata.text)) return NULL;
+       (!rp->typedata.text)) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
         const char *t = _edje_entry_text_get(rp);
-        return _edje_text_unescape(t);
+        *ret = _edje_text_unescape(t);
+        return;
      }
    else
      {
-        if (rp->part->type == EDJE_PART_TYPE_TEXT) return strdup(rp->typedata.text->text);
+        if (rp->part->type == EDJE_PART_TYPE_TEXT)
+          {
+             *ret = strdup(rp->typedata.text->text);
+             return;
+          }
         if (rp->part->type == EDJE_PART_TYPE_TEXTBLOCK)
           {
              const char *t = evas_object_textblock_text_markup_get(rp->object);
-             return _edje_text_unescape(t);
+             *ret = _edje_text_unescape(t);
+             return;
           }
      }
-   return NULL;
 }
 
 EAPI const char *
 edje_object_part_text_selection_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const char* ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_selection_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_selection_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char **ret = va_arg(*list, const char **);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
-     return _edje_entry_selection_get(rp);
-   return NULL;
+      *ret = _edje_entry_selection_get(rp);
 }
 
 EAPI void
 edje_object_part_text_select_none(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_select_none(part));
+}
+
+void
+_part_text_select_none(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1566,10 +1872,17 @@ edje_object_part_text_select_none(const Evas_Object *obj, const char *part)
 EAPI void
 edje_object_part_text_select_all(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_select_all(part));
+}
+
+void
+_part_text_select_all(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1580,10 +1893,18 @@ edje_object_part_text_select_all(const Evas_Object *obj, const char *part)
 EAPI void
 edje_object_part_text_insert(Evas_Object *obj, const char *part, const char *text)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_insert(part, text));
+}
+
+void
+_part_text_insert(Eo *obj, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *text = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1604,10 +1925,18 @@ edje_object_part_text_insert(Evas_Object *obj, const char *part, const char *tex
 EAPI void
 edje_object_part_text_append(Evas_Object *obj, const char *part, const char *text)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_append(part, text));
+}
+
+void
+_part_text_append(Eo *obj, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *text = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1627,70 +1956,130 @@ edje_object_part_text_append(Evas_Object *obj, const char *part, const char *tex
 EAPI const Eina_List *
 edje_object_part_text_anchor_list_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const Eina_List *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_anchor_list_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_anchor_list_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const Eina_List **ret = va_arg(*list, const Eina_List **);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
-     return _edje_entry_anchors_list(rp);
-   return NULL;
+     *ret = _edje_entry_anchors_list(rp);
 }
 
 EAPI const Eina_List *
 edje_object_part_text_anchor_geometry_get(const Evas_Object *obj, const char *part, const char *anchor)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const Eina_List *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_anchor_geometry_get(part, anchor, &ret));
+   return ret;
+}
+
+void
+_part_text_anchor_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *anchor = va_arg(*list, const char *);
+   const Eina_List **ret = va_arg(*list, const Eina_List **);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
-     return _edje_entry_anchor_geometry_get(rp, anchor);
-   return NULL;
+     *ret = _edje_entry_anchor_geometry_get(rp, anchor);
 }
 
 EAPI const Eina_List *
 edje_object_part_text_item_list_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const Eina_List *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_item_list_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_item_list_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const Eina_List **ret = va_arg(*list, const Eina_List **);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
-     return _edje_entry_items_list(rp);
-   return NULL;
+     *ret = _edje_entry_items_list(rp);
 }
 
 EAPI Eina_Bool
 edje_object_part_text_item_geometry_get(const Evas_Object *obj, const char *part, const char *item, Evas_Coord *cx, Evas_Coord *cy, Evas_Coord *cw, Evas_Coord *ch)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_text_item_geometry_get(part, item, cx, cy, cw, ch, &ret));
+   return ret;
+}
+
+void
+_part_text_item_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *item = va_arg(*list, const char *);
+   Evas_Coord *cx = va_arg(*list, Evas_Coord *);
+   Evas_Coord *cy = va_arg(*list, Evas_Coord *);
+   Evas_Coord *cw = va_arg(*list, Evas_Coord *);
+   Evas_Coord *ch = va_arg(*list, Evas_Coord *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
-     return _edje_entry_item_geometry_get(rp, item, cx, cy, cw, ch);
-   return EINA_FALSE;
+     {
+        Eina_Bool int_ret = _edje_entry_item_geometry_get(rp, item, cx, cy, cw, ch);
+        if (ret) *ret = int_ret;
+     }
 }
 
 EAPI void
 edje_object_part_text_cursor_geometry_get(const Evas_Object *obj, const char *part, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_cursor_geometry_get(part, x, y, w, h));
+}
+
+void
+_part_text_cursor_geometry_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Evas_Coord *x = va_arg(*list, Evas_Coord *);
+   Evas_Coord *y = va_arg(*list, Evas_Coord *);
+   Evas_Coord *w = va_arg(*list, Evas_Coord *);
+   Evas_Coord *h = va_arg(*list, Evas_Coord *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if (x) *x = 0;
    if (y) *y = 0;
    if (w) *w = 0;
@@ -1709,10 +2098,18 @@ edje_object_part_text_cursor_geometry_get(const Evas_Object *obj, const char *pa
 EAPI void
 edje_object_part_text_user_insert(const Evas_Object *obj, const char *part, const char *text)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_user_insert(part, text));
+}
+
+void
+_part_text_user_insert(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const char *text = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1723,10 +2120,18 @@ edje_object_part_text_user_insert(const Evas_Object *obj, const char *part, cons
 EAPI void
 edje_object_part_text_select_allow_set(const Evas_Object *obj, const char *part, Eina_Bool allow)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_select_allow_set(part, allow));
+}
+
+void
+_part_text_select_allow_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool allow = va_arg(*list, int);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1737,10 +2142,17 @@ edje_object_part_text_select_allow_set(const Evas_Object *obj, const char *part,
 EAPI void
 edje_object_part_text_select_abort(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_select_abort(part));
+}
+
+void
+_part_text_select_abort(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1751,10 +2163,17 @@ edje_object_part_text_select_abort(const Evas_Object *obj, const char *part)
 EAPI void
 edje_object_part_text_select_begin(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_select_begin(part));
+}
+
+void
+_part_text_select_begin(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1765,10 +2184,17 @@ edje_object_part_text_select_begin(const Evas_Object *obj, const char *part)
 EAPI void
 edje_object_part_text_select_extend(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_select_extend(part));
+}
+
+void
+_part_text_select_extend(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1779,96 +2205,161 @@ edje_object_part_text_select_extend(const Evas_Object *obj, const char *part)
 EAPI void *
 edje_object_part_text_imf_context_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   void *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_imf_context_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_imf_context_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   void **ret = va_arg(*list, void **);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
 
    rp = _edje_real_part_recursive_get(ed, (char *)part);
-   if (!rp) return NULL;
+   if (!rp) return;
 
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
-     return _edje_entry_imf_context_get(rp);
-   else
-     return NULL;
+     *ret = _edje_entry_imf_context_get(rp);
 }
 
 EAPI Eina_Bool
 edje_object_part_text_cursor_next(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_cursor_next(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_next(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_next(rp, cur);
+        Eina_Bool int_ret = _edje_entry_cursor_next(rp, cur);
+        if (ret) *ret = int_ret;
      }
-   return EINA_FALSE;
 }
 
 EAPI Eina_Bool
 edje_object_part_text_cursor_prev(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_cursor_prev(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_prev(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_prev(rp, cur);
+        Eina_Bool int_ret = _edje_entry_cursor_prev(rp, cur);
+        if (ret) *ret = int_ret;
      }
-   return EINA_FALSE;
 }
 
 EAPI Eina_Bool
 edje_object_part_text_cursor_up(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_cursor_up(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_up(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_up(rp, cur);
+        Eina_Bool int_ret = _edje_entry_cursor_up(rp, cur);
+        if (ret) *ret = int_ret;
      }
-   return EINA_FALSE;
 }
 
 EAPI Eina_Bool
 edje_object_part_text_cursor_down(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_cursor_down(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_down(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_down(rp, cur);
+        Eina_Bool int_ret = _edje_entry_cursor_down(rp, cur);
+        if (ret) *ret = int_ret;
      }
-   return EINA_FALSE;
 }
 
 EAPI void
 edje_object_part_text_cursor_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_cursor_begin_set(part, cur));
+}
+
+void
+_part_text_cursor_begin_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1881,10 +2372,18 @@ edje_object_part_text_cursor_begin_set(Evas_Object *obj, const char *part, Edje_
 EAPI void
 edje_object_part_text_cursor_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_cursor_end_set(part, cur));
+}
+
+void
+_part_text_cursor_end_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1897,10 +2396,19 @@ edje_object_part_text_cursor_end_set(Evas_Object *obj, const char *part, Edje_Cu
 EAPI void
 edje_object_part_text_cursor_copy(Evas_Object *obj, const char *part, Edje_Cursor src, Edje_Cursor dst)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_cursor_copy(part, src, dst));
+}
+
+void
+_part_text_cursor_copy(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor src = va_arg(*list, Edje_Cursor);
+   Edje_Cursor dst = va_arg(*list, Edje_Cursor);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1913,10 +2421,18 @@ edje_object_part_text_cursor_copy(Evas_Object *obj, const char *part, Edje_Curso
 EAPI void
 edje_object_part_text_cursor_line_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_cursor_line_begin_set(part, cur));
+}
+
+void
+_part_text_cursor_line_begin_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1929,10 +2445,18 @@ edje_object_part_text_cursor_line_begin_set(Evas_Object *obj, const char *part,
 EAPI void
 edje_object_part_text_cursor_line_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_cursor_line_end_set(part, cur));
+}
+
+void
+_part_text_cursor_line_end_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -1946,78 +2470,134 @@ EAPI Eina_Bool
 edje_object_part_text_cursor_coord_set(Evas_Object *obj, const char *part,
                 Edje_Cursor cur, Evas_Coord x, Evas_Coord y)
 {
- Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_text_cursor_coord_set(part, cur, x, y, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_coord_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Evas_Coord x = va_arg(*list, Evas_Coord);
+   Evas_Coord y = va_arg(*list, Evas_Coord);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if (ret) *ret = EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_coord_set(rp, cur, x, y);
+        Eina_Bool int_ret = _edje_entry_cursor_coord_set(rp, cur, x, y);
+        if (ret) *ret = int_ret;
      }
-   return EINA_FALSE;
 }
 
 EAPI Eina_Bool
 edje_object_part_text_cursor_is_format_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_text_cursor_is_format_get(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_is_format_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_is_format_get(rp, cur);
+        *ret = _edje_entry_cursor_is_format_get(rp, cur);
      }
-   return EINA_FALSE;
 }
 
 EAPI Eina_Bool
 edje_object_part_text_cursor_is_visible_format_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_text_cursor_is_visible_format_get(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_is_visible_format_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return 0;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return 0;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_is_visible_format_get(rp, cur);
+        *ret = _edje_entry_cursor_is_visible_format_get(rp, cur);
      }
-   return 0;
 }
 
 EAPI char *
 edje_object_part_text_cursor_content_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   char *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_text_cursor_content_get(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_content_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   char **ret = va_arg(*list, char **);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_content_get(rp, cur);
+        *ret = _edje_entry_cursor_content_get(rp, cur);
      }
-   return NULL;
 }
 
 EAPI void
 edje_object_part_text_cursor_pos_set(Evas_Object *obj, const char *part, Edje_Cursor cur, int pos)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_cursor_pos_set(part, cur, pos));
+}
+
+void
+_part_text_cursor_pos_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   int pos = va_arg(*list, int);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2030,27 +2610,45 @@ edje_object_part_text_cursor_pos_set(Evas_Object *obj, const char *part, Edje_Cu
 EAPI int
 edje_object_part_text_cursor_pos_get(const Evas_Object *obj, const char *part, Edje_Cursor cur)
 {
-   Edje *ed;
+   if (!obj) return 0;
+   int ret;
+   eo_do((Eo *)obj, edje_obj_part_text_cursor_pos_get(part, cur, &ret));
+   return ret;
+}
+
+void
+_part_text_cursor_pos_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Cursor cur = va_arg(*list, Edje_Cursor);
+   int *ret = va_arg(*list, int *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = 0;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return 0;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return 0;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_cursor_pos_get(rp, cur);
+        *ret = _edje_entry_cursor_pos_get(rp, cur);
      }
-   return 0;
 }
 
 EAPI void
 edje_object_part_text_imf_context_reset(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_imf_context_reset(part));
+}
+
+void
+_part_text_imf_context_reset(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2063,10 +2661,18 @@ edje_object_part_text_imf_context_reset(const Evas_Object *obj, const char *part
 EAPI void
 edje_object_part_text_input_panel_layout_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Layout layout)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_input_panel_layout_set(part, layout));
+}
+
+void
+_part_text_input_panel_layout_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Input_Panel_Layout layout = va_arg(*list, Edje_Input_Panel_Layout);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2079,27 +2685,45 @@ edje_object_part_text_input_panel_layout_set(Evas_Object *obj, const char *part,
 EAPI Edje_Input_Panel_Layout
 edje_object_part_text_input_panel_layout_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EDJE_INPUT_PANEL_LAYOUT_INVALID;
+   Edje_Input_Panel_Layout ret;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_layout_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_input_panel_layout_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Input_Panel_Layout *ret = va_arg(*list, Edje_Input_Panel_Layout *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EDJE_INPUT_PANEL_LAYOUT_INVALID;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EDJE_INPUT_PANEL_LAYOUT_INVALID;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_input_panel_layout_get(rp);
+        *ret = _edje_entry_input_panel_layout_get(rp);
      }
-   return EDJE_INPUT_PANEL_LAYOUT_INVALID;
 }
 
 EAPI void
 edje_object_part_text_autocapital_type_set(Evas_Object *obj, const char *part, Edje_Text_Autocapital_Type autocapital_type)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_autocapital_type_set(part, autocapital_type));
+}
+
+void
+_part_text_autocapital_type_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Text_Autocapital_Type autocapital_type = va_arg(*list, Edje_Text_Autocapital_Type);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2112,27 +2736,45 @@ edje_object_part_text_autocapital_type_set(Evas_Object *obj, const char *part, E
 EAPI Edje_Text_Autocapital_Type
 edje_object_part_text_autocapital_type_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
+   Edje_Text_Autocapital_Type ret;
+   eo_do((Eo *)obj, edje_obj_part_text_autocapital_type_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_autocapital_type_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Text_Autocapital_Type *ret = va_arg(*list, Edje_Text_Autocapital_Type *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_autocapital_type_get(rp);
+        *ret = _edje_entry_autocapital_type_get(rp);
      }
-   return EDJE_TEXT_AUTOCAPITAL_TYPE_NONE;
 }
 
 EAPI void
 edje_object_part_text_prediction_allow_set(Evas_Object *obj, const char *part, Eina_Bool prediction)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_prediction_allow_set(part, prediction));
+}
+
+void
+_part_text_prediction_allow_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool prediction = va_arg(*list, int);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2145,27 +2787,45 @@ edje_object_part_text_prediction_allow_set(Evas_Object *obj, const char *part, E
 EAPI Eina_Bool
 edje_object_part_text_prediction_allow_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_text_prediction_allow_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_prediction_allow_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_prediction_allow_get(rp);
+        *ret = _edje_entry_prediction_allow_get(rp);
      }
-   return EINA_FALSE;
 }
 
 EAPI void
 edje_object_part_text_input_panel_enabled_set(Evas_Object *obj, const char *part, Eina_Bool enabled)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_input_panel_enabled_set(part, enabled));
+}
+
+void
+_part_text_input_panel_enabled_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool enabled = va_arg(*list, int);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2178,27 +2838,44 @@ edje_object_part_text_input_panel_enabled_set(Evas_Object *obj, const char *part
 EAPI Eina_Bool
 edje_object_part_text_input_panel_enabled_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_enabled_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_input_panel_enabled_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_input_panel_enabled_get(rp);
+        *ret = _edje_entry_input_panel_enabled_get(rp);
      }
-   return EINA_FALSE;
 }
 
 EAPI void
 edje_object_part_text_input_panel_show(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_show(part));
+}
+
+void
+_part_text_input_panel_show(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2209,10 +2886,17 @@ edje_object_part_text_input_panel_show(const Evas_Object *obj, const char *part)
 EAPI void
 edje_object_part_text_input_panel_hide(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_hide(part));
+}
+
+void
+_part_text_input_panel_hide(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2223,10 +2907,18 @@ edje_object_part_text_input_panel_hide(const Evas_Object *obj, const char *part)
 EAPI void
 edje_object_part_text_input_panel_language_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Lang lang)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_input_panel_language_set(part, lang));
+}
+
+void
+_part_text_input_panel_language_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Input_Panel_Lang lang = va_arg(*list, Edje_Input_Panel_Lang);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2239,27 +2931,46 @@ edje_object_part_text_input_panel_language_set(Evas_Object *obj, const char *par
 EAPI Edje_Input_Panel_Lang
 edje_object_part_text_input_panel_language_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
+   Edje_Input_Panel_Lang ret;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_language_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_input_panel_language_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Input_Panel_Lang *ret = va_arg(*list, Edje_Input_Panel_Lang *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EDJE_INPUT_PANEL_LANG_AUTOMATIC;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_input_panel_language_get(rp);
+        *ret = _edje_entry_input_panel_language_get(rp);
      }
-   return EDJE_INPUT_PANEL_LANG_AUTOMATIC;
 }
 
 EAPI void
 edje_object_part_text_input_panel_imdata_set(Evas_Object *obj, const char *part, const void *data, int len)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_input_panel_imdata_set(part, data, len));
+}
+
+void
+_part_text_input_panel_imdata_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   const void *data = va_arg(*list, const void *);
+   int len = va_arg(*list, int);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2272,10 +2983,19 @@ edje_object_part_text_input_panel_imdata_set(Evas_Object *obj, const char *part,
 EAPI void
 edje_object_part_text_input_panel_imdata_get(const Evas_Object *obj, const char *part, void *data, int *len)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_imdata_get(part, data, len));
+}
+
+void
+_part_text_input_panel_imdata_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   void *data = va_arg(*list, void *);
+   int *len = va_arg(*list, int *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2288,10 +3008,18 @@ edje_object_part_text_input_panel_imdata_get(const Evas_Object *obj, const char
 EAPI void
 edje_object_part_text_input_panel_return_key_type_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_input_panel_return_key_type_set(part, return_key_type));
+}
+
+void
+_part_text_input_panel_return_key_type_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Input_Panel_Return_Key_Type return_key_type = va_arg(*list, Edje_Input_Panel_Return_Key_Type);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2304,27 +3032,45 @@ edje_object_part_text_input_panel_return_key_type_set(Evas_Object *obj, const ch
 EAPI Edje_Input_Panel_Return_Key_Type
 edje_object_part_text_input_panel_return_key_type_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
+   Edje_Input_Panel_Return_Key_Type ret;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_return_key_type_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_input_panel_return_key_type_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Input_Panel_Return_Key_Type *ret = va_arg(*list, Edje_Input_Panel_Return_Key_Type *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_input_panel_return_key_type_get(rp);
+        *ret = _edje_entry_input_panel_return_key_type_get(rp);
      }
-   return EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
 }
 
 EAPI void
 edje_object_part_text_input_panel_return_key_disabled_set(Evas_Object *obj, const char *part, Eina_Bool disabled)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_text_input_panel_return_key_disabled_set(part, disabled));
+}
+
+void
+_part_text_input_panel_return_key_disabled_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool disabled = va_arg(*list, int);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
    if (!rp) return;
@@ -2337,27 +3083,46 @@ edje_object_part_text_input_panel_return_key_disabled_set(Evas_Object *obj, cons
 EAPI Eina_Bool
 edje_object_part_text_input_panel_return_key_disabled_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_text_input_panel_return_key_disabled_get(part, &ret));
+   return ret;
+}
+
+void
+_part_text_input_panel_return_key_disabled_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   const Edje *ed = _pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
+   if (!rp) return;
    if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE)
      {
-        return _edje_entry_input_panel_return_key_disabled_get(rp);
+        *ret = _edje_entry_input_panel_return_key_disabled_get(rp);
      }
-   return EINA_FALSE;
 }
 
 EAPI void
 edje_object_text_insert_filter_callback_add(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_text_insert_filter_callback_add(part, func, data));
+}
+
+void
+_text_insert_filter_callback_add(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Text_Filter_Cb func = va_arg(*list, Edje_Text_Filter_Cb);
+   void *data = va_arg(*list, void *);
+   Edje *ed = _pd;
    Edje_Text_Insert_Filter_Callback *cb;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    cb = calloc(1, sizeof(Edje_Text_Insert_Filter_Callback));
    cb->part = eina_stringshare_add(part);
@@ -2370,12 +3135,24 @@ edje_object_text_insert_filter_callback_add(Evas_Object *obj, const char *part,
 EAPI void *
 edje_object_text_insert_filter_callback_del(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   void *ret = NULL;
+   eo_do(obj, edje_obj_text_insert_filter_callback_del(part, func, &ret));
+   return ret;
+}
+
+void
+_text_insert_filter_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Text_Filter_Cb func = va_arg(*list, Edje_Text_Filter_Cb);
+   void **ret = va_arg(*list, void **);
+   Edje *ed = _pd;
    Edje_Text_Insert_Filter_Callback *cb;
    Eina_List *l;
+   if (ret) *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
      {
         if ((!strcmp(cb->part, part)) && (cb->func == func))
@@ -2385,21 +3162,34 @@ edje_object_text_insert_filter_callback_del(Evas_Object *obj, const char *part,
                 eina_list_remove_list(ed->text_insert_filter_callbacks, l);
              eina_stringshare_del(cb->part);
              free(cb);
-             return data;
+             if (ret) *ret = data;
+             return;
           }
      }
-   return NULL;
 }
 
 EAPI void *
 edje_object_text_insert_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   void *ret = NULL;
+   eo_do(obj, edje_obj_text_insert_filter_callback_del_full(part, func, data, &ret));
+   return ret;
+}
+
+void
+_text_insert_filter_callback_del_full(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Text_Filter_Cb func = va_arg(*list, Edje_Text_Filter_Cb);
+   void *data = va_arg(*list, void *);
+   void **ret = va_arg(*list, void **);
+   Edje *ed = _pd;
    Edje_Text_Insert_Filter_Callback *cb;
    Eina_List *l;
+   if (ret) *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    EINA_LIST_FOREACH(ed->text_insert_filter_callbacks, l, cb)
      {
         if ((!strcmp(cb->part, part)) && (cb->func == func) &&
@@ -2410,19 +3200,28 @@ edje_object_text_insert_filter_callback_del_full(Evas_Object *obj, const char *p
                 eina_list_remove_list(ed->text_insert_filter_callbacks, l);
              eina_stringshare_del(cb->part);
              free(cb);
-             return tmp;
+             if (ret) *ret = tmp;
+             return;
           }
      }
-   return NULL;
 }
 
 EAPI void
 edje_object_text_markup_filter_callback_add(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_text_markup_filter_callback_add(part, func, data));
+}
+
+void
+_text_markup_filter_callback_add(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Markup_Filter_Cb func = va_arg(*list, Edje_Markup_Filter_Cb);
+   void *data = va_arg(*list, void *);
+   Edje *ed = _pd;
    Edje_Markup_Filter_Callback *cb;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part)) return;
    cb = calloc(1, sizeof(Edje_Markup_Filter_Callback));
    cb->part = eina_stringshare_add(part);
@@ -2435,12 +3234,24 @@ edje_object_text_markup_filter_callback_add(Evas_Object *obj, const char *part,
 EAPI void *
 edje_object_text_markup_filter_callback_del(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   void *ret = NULL;
+   eo_do(obj, edje_obj_text_markup_filter_callback_del(part, func, &ret));
+   return ret;
+}
+
+void
+_text_markup_filter_callback_del(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Markup_Filter_Cb func = va_arg(*list, Edje_Markup_Filter_Cb);
+   void **ret = va_arg(*list, void **);
+   Edje *ed = _pd;
    Edje_Markup_Filter_Callback *cb;
    Eina_List *l;
+   if (ret) *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
      {
         if ((!strcmp(cb->part, part)) && (cb->func == func))
@@ -2450,21 +3261,34 @@ edje_object_text_markup_filter_callback_del(Evas_Object *obj, const char *part,
                 eina_list_remove_list(ed->markup_filter_callbacks, l);
              eina_stringshare_del(cb->part);
              free(cb);
-             return data;
+             if (ret) *ret = data;
+             return;
           }
      }
-   return NULL;
 }
 
 EAPI void *
 edje_object_text_markup_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   void *ret = NULL;
+   eo_do(obj, edje_obj_text_markup_filter_callback_del_full(part, func, data, &ret));
+   return ret;
+}
+
+void
+_text_markup_filter_callback_del_full(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Markup_Filter_Cb func = va_arg(*list, Edje_Markup_Filter_Cb);
+   void *data = va_arg(*list, void *);
+   void **ret = va_arg(*list, void **);
+   Edje *ed = _pd;
    Edje_Markup_Filter_Callback *cb;
    Eina_List *l;
+   if (ret) *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
    EINA_LIST_FOREACH(ed->markup_filter_callbacks, l, cb)
      {
         if ((!strcmp(cb->part, part)) && (cb->func == func) &&
@@ -2475,21 +3299,33 @@ edje_object_text_markup_filter_callback_del_full(Evas_Object *obj, const char *p
                 eina_list_remove_list(ed->markup_filter_callbacks, l);
              eina_stringshare_del(cb->part);
              free(cb);
-             return tmp;
+             if (ret) *ret = tmp;
+             return;
           }
      }
-   return NULL;
 }
 
 EAPI Eina_Bool
 edje_object_part_swallow(Evas_Object *obj, const char *part, Evas_Object *obj_swallow)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_swallow(part, obj_swallow, &ret));
+   return ret;
+}
+
+void
+_part_swallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Evas_Object *obj_swallow = va_arg(*list, Evas_Object *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
    Edje_User_Defined *eud = NULL;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
 
    /* Need to recalc before providing the object. */
    // XXX: I guess this is not required, removing for testing purposes
@@ -2512,15 +3348,15 @@ edje_object_part_swallow(Evas_Object *obj, const char *part, Evas_Object *obj_sw
    if (!rp)
      {
         DBG("cannot swallow part %s: part not exist!", part);
-        return EINA_FALSE;
+        return;
      }
    if (rp->part->type != EDJE_PART_TYPE_SWALLOW)
      {
         ERR("cannot swallow part %s: not swallow type!", rp->part->name);
-        return EINA_FALSE;
+        return;
      }
    if ((rp->type != EDJE_RP_TYPE_SWALLOW) ||
-       (!rp->typedata.swallow)) return EINA_FALSE;
+       (!rp->typedata.swallow)) return;
    _edje_real_part_swallow(rp, obj_swallow, EINA_TRUE);
 
    if (rp->typedata.swallow->swallowed_object)
@@ -2538,7 +3374,7 @@ edje_object_part_swallow(Evas_Object *obj, const char *part, Evas_Object *obj_sw
           }
      }
 
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 static void
@@ -2558,6 +3394,7 @@ _recalc_extern_parent(Evas_Object *obj)
 EAPI void
 edje_extern_object_min_size_set(Evas_Object *obj, Evas_Coord minw, Evas_Coord minh)
 {
+   if (!obj) return;
    Edje_Real_Part *rp;
 
    evas_object_size_hint_min_set(obj, minw, minh);
@@ -2576,6 +3413,7 @@ edje_extern_object_min_size_set(Evas_Object *obj, Evas_Coord minw, Evas_Coord mi
 EAPI void
 edje_extern_object_max_size_set(Evas_Object *obj, Evas_Coord maxw, Evas_Coord maxh)
 {
+   if (!obj) return;
    Edje_Real_Part *rp;
 
    evas_object_size_hint_max_set(obj, maxw, maxh);
@@ -2594,6 +3432,7 @@ edje_extern_object_max_size_set(Evas_Object *obj, Evas_Coord maxw, Evas_Coord ma
 EAPI void
 edje_extern_object_aspect_set(Evas_Object *obj, Edje_Aspect_Control aspect, Evas_Coord aw, Evas_Coord ah)
 {
+   if (!obj) return;
    Edje_Real_Part *rp;
    Evas_Aspect_Control asp;
 
@@ -2813,6 +3652,14 @@ edje_box_layout_register(const char *name, Evas_Object_Box_Layout func, void *(*
 EAPI void
 edje_object_part_unswallow(Evas_Object *obj, Evas_Object *obj_swallow)
 {
+   if (!obj) return;
+   eo_do(obj, edje_obj_part_unswallow(obj_swallow));
+}
+
+void
+_part_unswallow(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Evas_Object *obj_swallow = va_arg(*list, Evas_Object *);
    Edje_Real_Part *rp;
 
    if (!obj_swallow) return;
@@ -2836,9 +3683,8 @@ edje_object_part_unswallow(Evas_Object *obj, Evas_Object *obj_swallow)
 
         if (obj)
           {
-             Edje *ed;
+             Edje *ed = _pd;
 
-             ed = _edje_fetch(obj);
              if (!ed && obj)
                {
                   ERR("edje_object_part_unswallow called on a non Edje object ('%s').",
@@ -2874,28 +3720,47 @@ edje_object_part_unswallow(Evas_Object *obj, Evas_Object *obj_swallow)
 EAPI Evas_Object *
 edje_object_part_swallow_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   Evas_Object *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_swallow_get(part, &ret));
+   return ret;
+}
+
+void
+_part_swallow_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Evas_Object **ret = va_arg(*list, Evas_Object **);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
+   *ret = NULL;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return NULL;
+   if ((!ed) || (!part)) return;
 
    /* Need to recalc before providing the object. */
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return NULL;
+   if (!rp) return;
    if ((rp->type != EDJE_RP_TYPE_SWALLOW) ||
-       (!rp->typedata.swallow)) return NULL;
-   return rp->typedata.swallow->swallowed_object;
+       (!rp->typedata.swallow)) return;
+   *ret = rp->typedata.swallow->swallowed_object;
 }
 
 EAPI void
 edje_object_size_min_get(const Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_size_min_get(minw, minh));
+}
+
+void
+_size_min_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Evas_Coord *minw = va_arg(*list, Evas_Coord *);
+   Evas_Coord *minh = va_arg(*list, Evas_Coord *);
+   const Edje *ed = _pd;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!ed->collection))
      {
         if (minw) *minw = 0;
@@ -2909,9 +3774,17 @@ edje_object_size_min_get(const Evas_Object *obj, Evas_Coord *minw, Evas_Coord *m
 EAPI void
 edje_object_size_max_get(const Evas_Object *obj, Evas_Coord *maxw, Evas_Coord *maxh)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do((Eo *)obj, edje_obj_size_max_get(maxw, maxh));
+}
+
+void
+_size_max_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Evas_Coord *maxw = va_arg(*list, Evas_Coord *);
+   Evas_Coord *maxh = va_arg(*list, Evas_Coord *);
+   Edje *ed = (Edje *)_pd;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!ed->collection))
      {
         if (maxw) *maxw = 0;
@@ -2945,10 +3818,16 @@ edje_object_size_max_get(const Evas_Object *obj, Evas_Coord *maxw, Evas_Coord *m
 EAPI void
 edje_object_calc_force(Evas_Object *obj)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_calc_force());
+}
+
+void
+_calc_force(Eo *obj EINA_UNUSED, void *_pd, va_list *list EINA_UNUSED)
+{
+   Edje *ed = _pd;
    int pf, pf2;
 
-   ed = _edje_fetch(obj);
    if (!ed) return;
    ed->dirty = EINA_TRUE;
 #ifdef EDJE_CALC_CACHE
@@ -2970,25 +3849,48 @@ edje_object_calc_force(Evas_Object *obj)
 EAPI void
 edje_object_size_min_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh)
 {
+   if (!obj) return;
+   eo_do(obj, edje_obj_size_min_calc(minw, minh));
+}
+
+void
+_size_min_calc(Eo *obj, void *_pd EINA_UNUSED, va_list *list)
+{
+   Evas_Coord *minw = va_arg(*list, Evas_Coord *);
+   Evas_Coord *minh = va_arg(*list, Evas_Coord *);
    edje_object_size_min_restricted_calc(obj, minw, minh, 0, 0);
 }
 
 EAPI Eina_Bool
 edje_object_parts_extends_calc(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_parts_extends_calc(x, y, w, h, &ret));
+   return ret;
+}
+
+void
+_parts_extends_calc(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Evas_Coord *x = va_arg(*list, Evas_Coord *);
+   Evas_Coord *y = va_arg(*list, Evas_Coord *);
+   Evas_Coord *w = va_arg(*list, Evas_Coord *);
+   Evas_Coord *h = va_arg(*list, Evas_Coord *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Evas_Coord xx1 = INT_MAX, yy1 = INT_MAX;
    Evas_Coord xx2 = 0, yy2 = 0;
    unsigned int i;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
    if (!ed)
      {
         if (x) *x = 0;
         if (y) *y = 0;
         if (w) *w = 0;
         if (h) *h = 0;
-        return EINA_FALSE;
+        return;
      }
 
    ed->calc_only = EINA_TRUE;
@@ -3023,13 +3925,24 @@ edje_object_parts_extends_calc(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, E
    if (w) *w = xx2 - xx1;
    if (h) *h = yy2 - yy1;
 
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 EAPI void
 edje_object_size_min_restricted_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Coord *minh, Evas_Coord restrictedw, Evas_Coord restrictedh)
 {
-   Edje *ed;
+   if (!obj) return;
+   eo_do(obj, edje_obj_size_min_restricted_calc(minw, minh, restrictedw, restrictedh));
+}
+
+void
+_size_min_restricted_calc(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   Evas_Coord *minw = va_arg(*list, Evas_Coord *);
+   Evas_Coord *minh = va_arg(*list, Evas_Coord *);
+   Evas_Coord restrictedw = va_arg(*list, Evas_Coord);
+   Evas_Coord restrictedh = va_arg(*list, Evas_Coord);
+   Edje *ed = _pd;
    Evas_Coord pw, ph;
    int maxw, maxh;
    int okw, okh;
@@ -3037,7 +3950,6 @@ edje_object_size_min_restricted_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Co
    Edje_Real_Part *pep = NULL;
    Eina_Bool has_non_fixed_tb = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!ed->collection))
      {
         if (minw) *minw = restrictedw;
@@ -3181,14 +4093,26 @@ edje_object_size_min_restricted_calc(Evas_Object *obj, Evas_Coord *minw, Evas_Co
 EAPI const char *
 edje_object_part_state_get(const Evas_Object *obj, const char *part, double *val_ret)
 {
-   Edje *ed;
+   if (!obj) return NULL;
+   const char *ret = NULL;
+   eo_do((Eo *)obj, edje_obj_part_state_get(part, val_ret, &ret));
+   return ret;
+}
+
+void
+_part_state_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double *val_ret = va_arg(*list, double *);
+   const char **ret = va_arg(*list, const char **);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
+   *ret = "";
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part))
      {
         if (val_ret) *val_ret = 0;
-        return "";
+        return;
      }
 
    /* Need to recalc before providing the object. */
@@ -3199,14 +4123,16 @@ edje_object_part_state_get(const Evas_Object *obj, const char *part, double *val
      {
         if (val_ret) *val_ret = 0;
         INF("part not found");
-        return "";
+        return;
      }
    if (rp->chosen_description)
      {
         if (val_ret) *val_ret = rp->chosen_description->state.value;
         if (rp->chosen_description->state.name)
-          return rp->chosen_description->state.name;
-        return "default";
+           *ret = rp->chosen_description->state.name;
+        else
+           *ret = "default";
+        return;
      }
    else
      {
@@ -3214,48 +4140,72 @@ edje_object_part_state_get(const Evas_Object *obj, const char *part, double *val
           {
              if (val_ret) *val_ret = rp->param1.description->state.value;
              if (rp->param1.description->state.name)
-               return rp->param1.description->state.name;
-             return "default";
+                *ret = rp->param1.description->state.name;
+             else
+                *ret = "default";
+             return;
           }
      }
    if (val_ret) *val_ret = 0;
-   return "";
 }
 
 EAPI Edje_Drag_Dir
 edje_object_part_drag_dir_get(const Evas_Object *obj, const char *part)
 {
-   Edje *ed;
+   if (!obj) return EDJE_DRAG_DIR_NONE;
+   Edje_Drag_Dir ret;
+   eo_do((Eo *)obj, edje_obj_part_drag_dir_get(part, &ret));
+   return ret;
+}
+
+void
+_part_drag_dir_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   Edje_Drag_Dir *ret = va_arg(*list, Edje_Drag_Dir *);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
+   *ret = EDJE_DRAG_DIR_NONE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EDJE_DRAG_DIR_NONE;
+   if ((!ed) || (!part)) return;
 
    /* Need to recalc before providing the object. */
    _edje_recalc_do(ed);
 
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EDJE_DRAG_DIR_NONE;
-   if ((rp->part->dragable.x) && (rp->part->dragable.y)) return EDJE_DRAG_DIR_XY;
-   else if (rp->part->dragable.x) return EDJE_DRAG_DIR_X;
-   else if (rp->part->dragable.y) return EDJE_DRAG_DIR_Y;
-   return EDJE_DRAG_DIR_NONE;
+   if (!rp) return;
+   if ((rp->part->dragable.x) && (rp->part->dragable.y)) *ret = EDJE_DRAG_DIR_XY;
+   else if (rp->part->dragable.x) *ret = EDJE_DRAG_DIR_X;
+   else if (rp->part->dragable.y) *ret = EDJE_DRAG_DIR_Y;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, double dy)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_drag_value_set(part, dx, dy, &ret));
+   return ret;
+}
+
+void
+_part_drag_value_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double dx = va_arg(*list, double);
+   double dy = va_arg(*list, double);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
    Edje_User_Defined *eud;
    Eina_List *l;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
-   if (!rp->drag) return EINA_FALSE;
-   if (rp->drag->down.count > 0) return EINA_FALSE;
+   if (!rp) return;
+   if (!rp->drag) return;
+   if (rp->drag->down.count > 0) return;
 
    EINA_LIST_FOREACH(ed->user_defined, l, eud)
      if (eud->type == EDJE_USER_DRAG_VALUE && !strcmp(part, eud->part))
@@ -3281,7 +4231,11 @@ edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, d
      }
    if (rp->part->dragable.x < 0) dx = 1.0 - dx;
    if (rp->part->dragable.y < 0) dy = 1.0 - dy;
-   if ((rp->drag->val.x == FROM_DOUBLE(dx)) && (rp->drag->val.y == FROM_DOUBLE(dy))) return EINA_TRUE;
+   if ((rp->drag->val.x == FROM_DOUBLE(dx)) && (rp->drag->val.y == FROM_DOUBLE(dy)))
+     {
+        if (ret) *ret = EINA_TRUE;
+        return;
+     }
    rp->drag->val.x = FROM_DOUBLE(dx);
    rp->drag->val.y = FROM_DOUBLE(dy);
 #ifdef EDJE_CALC_CACHE
@@ -3289,23 +4243,36 @@ edje_object_part_drag_value_set(Evas_Object *obj, const char *part, double dx, d
 #endif
    _edje_dragable_pos_set(rp->edje, rp, rp->drag->val.x, rp->drag->val.y);
    _edje_emit(rp->edje, "drag,set", rp->part->name);
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 /* FIXME: Should this be x and y instead of dx/dy? */
 EAPI Eina_Bool
 edje_object_part_drag_value_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_drag_value_get(part, dx, dy, &ret));
+   return ret;
+}
+
+void
+_part_drag_value_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double *dx = va_arg(*list, double *);
+   double *dy = va_arg(*list, double *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
    double ddx, ddy;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part))
      {
         if (dx) *dx = 0;
         if (dy) *dy = 0;
-        return EINA_FALSE;
+        return;
      }
 
    /* Need to recalc before providing the object. */
@@ -3316,7 +4283,7 @@ edje_object_part_drag_value_get(const Evas_Object *obj, const char *part, double
      {
         if (dx) *dx = 0;
         if (dy) *dy = 0;
-        return EINA_FALSE;
+        return;
      }
    ddx = TO_DOUBLE(rp->drag->val.x);
    ddy = TO_DOUBLE(rp->drag->val.y);
@@ -3324,22 +4291,35 @@ edje_object_part_drag_value_get(const Evas_Object *obj, const char *part, double
    if (rp->part->dragable.y < 0) ddy = 1.0 - ddy;
    if (dx) *dx = ddx;
    if (dy) *dy = ddy;
-   return EINA_TRUE;
+   *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, double dh)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_drag_size_set(part, dw, dh, &ret));
+   return ret;
+}
+
+void
+_part_drag_size_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double dw = va_arg(*list, double);
+   double dh = va_arg(*list, double);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
    Edje_User_Defined *eud;
    Eina_List *l;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
-   if (!rp->drag) return EINA_FALSE;
+   if (!rp) return;
+   if (!rp->drag) return;
 
    EINA_LIST_FOREACH(ed->user_defined, l, eud)
      if (eud->type == EDJE_USER_DRAG_SIZE && !strcmp(part, eud->part))
@@ -3362,7 +4342,11 @@ edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, do
    else if (dw > 1.0) dw = 1.0;
    if (dh < 0.0) dh = 0.0;
    else if (dh > 1.0) dh = 1.0;
-   if ((rp->drag->size.x == FROM_DOUBLE(dw)) && (rp->drag->size.y == FROM_DOUBLE(dh))) return EINA_TRUE;
+   if ((rp->drag->size.x == FROM_DOUBLE(dw)) && (rp->drag->size.y == FROM_DOUBLE(dh)))
+     {
+        if (ret) *ret = EINA_TRUE;
+        return;
+     }
    rp->drag->size.x = FROM_DOUBLE(dw);
    rp->drag->size.y = FROM_DOUBLE(dh);
    rp->edje->dirty = EINA_TRUE;
@@ -3371,21 +4355,34 @@ edje_object_part_drag_size_set(Evas_Object *obj, const char *part, double dw, do
    rp->invalidate = 1;
 #endif
    _edje_recalc(rp->edje);
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_size_get(const Evas_Object *obj, const char *part, double *dw, double *dh)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_drag_size_get(part, dw, dh, &ret));
+   return ret;
+}
+
+void
+_part_drag_size_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double *dw = va_arg(*list, double *);
+   double *dh = va_arg(*list, double *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part))
      {
         if (dw) *dw = 0;
         if (dh) *dh = 0;
-        return EINA_FALSE;
+        return;
      }
 
    /* Need to recalc before providing the object. */
@@ -3396,26 +4393,39 @@ edje_object_part_drag_size_get(const Evas_Object *obj, const char *part, double
      {
         if (dw) *dw = 0;
         if (dh) *dh = 0;
-        return EINA_FALSE;
+        return;
      }
    if (dw) *dw = TO_DOUBLE(rp->drag->size.x);
    if (dh) *dh = TO_DOUBLE(rp->drag->size.y);
-   return EINA_TRUE;
+   *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_step_set(Evas_Object *obj, const char *part, double dx, double dy)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_drag_step_set(part, dx, dy, &ret));
+   return ret;
+}
+
+void
+_part_drag_step_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double dx = va_arg(*list, double);
+   double dy = va_arg(*list, double);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
    Edje_User_Defined *eud;
    Eina_List *l;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
-   if (!rp->drag) return EINA_FALSE;
+   if (!rp) return;
+   if (!rp->drag) return;
 
    EINA_LIST_FOREACH(ed->user_defined, l, eud)
      if (eud->type == EDJE_USER_DRAG_STEP && !strcmp(part, eud->part))
@@ -3443,21 +4453,34 @@ edje_object_part_drag_step_set(Evas_Object *obj, const char *part, double dx, do
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
 #endif
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_step_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_drag_step_get(part, dx, dy, &ret));
+   return ret;
+}
+
+void
+_part_drag_step_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double *dx = va_arg(*list, double *);
+   double *dy = va_arg(*list, double *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part))
      {
         if (dx) *dx = 0;
         if (dy) *dy = 0;
-        return EINA_FALSE;
+        return;
      }
 
    /* Need to recalc before providing the object. */
@@ -3468,26 +4491,39 @@ edje_object_part_drag_step_get(const Evas_Object *obj, const char *part, double
      {
         if (dx) *dx = 0;
         if (dy) *dy = 0;
-        return EINA_FALSE;
+        return;
      }
    if (dx) *dx = TO_DOUBLE(rp->drag->step.x);
    if (dy) *dy = TO_DOUBLE(rp->drag->step.y);
-   return EINA_TRUE;
+   *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_page_set(Evas_Object *obj, const char *part, double dx, double dy)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_drag_page_set(part, dx, dy, &ret));
+   return ret;
+}
+
+void
+_part_drag_page_set(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double dx = va_arg(*list, double);
+   double dy = va_arg(*list, double);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = _pd;
    Edje_Real_Part *rp;
    Edje_User_Defined *eud;
    Eina_List *l;
+   if (ret) *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
-   if ((!ed) || (!part)) return EINA_FALSE;
+   if ((!ed) || (!part)) return;
    rp = _edje_real_part_recursive_get(ed, part);
-   if (!rp) return EINA_FALSE;
-   if (!rp->drag) return EINA_FALSE;
+   if (!rp) return;
+   if (!rp->drag) return;
 
    EINA_LIST_FOREACH(ed->user_defined, l, eud)
      if (eud->type == EDJE_USER_DRAG_PAGE && !strcmp(part, eud->part))
@@ -3515,21 +4551,34 @@ edje_object_part_drag_page_set(Evas_Object *obj, const char *part, double dx, do
 #ifdef EDJE_CALC_CACHE
    rp->invalidate = 1;
 #endif
-   return EINA_TRUE;
+   if (ret) *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_page_get(const Evas_Object *obj, const char *part, double *dx, double *dy)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do((Eo *)obj, edje_obj_part_drag_page_get(part, dx, dy, &ret));
+   return ret;
+}
+
+void
+_part_drag_page_get(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);
+   double *dx = va_arg(*list, double *);
+   double *dy = va_arg(*list, double *);
+   Eina_Bool *ret = va_arg(*list, Eina_Bool *);
+   Edje *ed = (Edje *)_pd;
    Edje_Real_Part *rp;
+   *ret = EINA_FALSE;
 
-   ed = _edje_fetch(obj);
    if ((!ed) || (!part))
      {
         if (dx) *dx = 0;
         if (dy) *dy = 0;
-        return EINA_FALSE;
+        return;
      }
 
    /* Need to recalc before providing the object. */
@@ -3540,28 +4589,41 @@ edje_object_part_drag_page_get(const Evas_Object *obj, const char *part, double
      {
         if (dx) *dx = 0;
         if (dy) *dy = 0;
-        return EINA_FALSE;
+        return;
      }
    if (dx) *dx = TO_DOUBLE(rp->drag->page.x);
    if (dy) *dy = TO_DOUBLE(rp->drag->page.y);
-   return EINA_TRUE;
+   *ret = EINA_TRUE;
 }
 
 EAPI Eina_Bool
 edje_object_part_drag_step(Evas_Object *obj, const char *part, double dx, double dy)
 {
-   Edje *ed;
+   if (!obj) return EINA_FALSE;
+   Eina_Bool ret = EINA_FALSE;
+   eo_do(obj, edje_obj_part_drag_step(part, dx, dy, &ret));
+   return ret;
+}
+
+void
+_part_drag_step(Eo *obj EINA_UNUSED, void *_pd, va_list *list)
+{
+   const char *part = va_arg(*list, const char *);